PLParser.java
// Generated from org/apache/doris/nereids/PLParser.g4 by ANTLR 4.13.1
package org.apache.doris.nereids;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class PLParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
ACTION=1, ALLOCATE=2, ANSI_NULLS=3, ANSI_PADDING=4, ASSOCIATE=5, AVG=6,
BATCHSIZE=7, BINARY_DOUBLE=8, BINARY_FLOAT=9, BINARY_INTEGER=10, BIT=11,
BODY=12, BREAK=13, BYTE=14, CALLER=15, CASCADE=16, CASESPECIFIC=17, CLIENT=18,
CLOSE=19, CLUSTERED=20, CMP=21, COLLECTION=22, COMPRESS=23, CONCAT=24,
CONDITION=25, CONSTANT=26, CONTINUE=27, COUNT_BIG=28, CREATOR=29, CS=30,
CURRENT_SCHEMA=31, CURSOR=32, DAYS=33, DEC=34, DECLARE=35, DEFINED=36,
DEFINER=37, DEFINITION=38, DELIMITED=39, DELIMITER=40, DIAGNOSTICS=41,
DIR=42, DIRECTORY=43, DISTRIBUTE=44, ELSEIF=45, ELSIF=46, ESCAPED=47,
EXEC=48, EXCEPTION=49, EXCLUSIVE=50, EXIT=51, FALLBACK=52, FETCH=53, FILES=54,
FOUND=55, GET=56, GO=57, HANDLER=58, HOST=59, IDENTITY=60, INCLUDE=61,
INITRANS=62, INOUT=63, INT2=64, INT4=65, INT8=66, INVOKER=67, ISOPEN=68,
ITEMS=69, KEEP=70, LANGUAGE=71, LEAVE=72, LOCATOR=73, LOCATORS=74, LOCKS=75,
LOG=76, LOGGED=77, LOGGING=78, LOOP=79, MATCHED=80, MAXTRANS=81, MESSAGE_TEXT=82,
MICROSECOND=83, MICROSECONDS=84, MULTISET=85, NCHAR=86, NEW=87, NVARCHAR=88,
NOCOUNT=89, NOCOMPRESS=90, NOLOGGING=91, NONE=92, NOTFOUND=93, NUMERIC=94,
NUMBER=95, OBJECT=96, OFF=97, OUT=98, OWNER=99, PACKAGE=100, PCTFREE=101,
PCTUSED=102, PLS_INTEGER=103, PRECISION=104, PRESERVE=105, PRINT=106,
QUALIFY=107, QUERY_BAND=108, QUIT=109, QUOTED_IDENTIFIER=110, RAISE=111,
RESIGNAL=112, RESTRICT=113, RESULT=114, RESULT_SET_LOCATOR=115, RETURN=116,
REVERSE=117, ROWTYPE=118, ROW_COUNT=119, RR=120, RS=121, PWD=122, SECONDS=123,
SECURITY=124, SEGMENT=125, SEL=126, SESSIONS=127, SHARE=128, SIGNAL=129,
SIMPLE_DOUBLE=130, SIMPLE_FLOAT=131, SIMPLE_INTEGER=132, SMALLDATETIME=133,
SQL=134, SQLEXCEPTION=135, SQLINSERT=136, SQLSTATE=137, SQLWARNING=138,
STATISTICS=139, STEP=140, STORED=141, SUBDIR=142, SUBSTRING=143, SUMMARY=144,
SYS_REFCURSOR=145, TABLESPACE=146, TEXTIMAGE_ON=147, TITLE=148, TOP=149,
UR=150, VAR=151, VARCHAR2=152, VARYING=153, VOLATILE=154, WHILE=155, WITHOUT=156,
XACT_ABORT=157, XML=158, YES=159, ACTIVITY_COUNT=160, CUME_DIST=161, DENSE_RANK=162,
FIRST_VALUE=163, LAG=164, LAST_VALUE=165, LEAD=166, MAX_PART_STRING=167,
MIN_PART_STRING=168, MAX_PART_INT=169, MIN_PART_INT=170, MAX_PART_DATE=171,
MIN_PART_DATE=172, PART_COUNT=173, PART_LOC=174, RANK=175, ROW_NUMBER=176,
STDEV=177, SYSDATE=178, VARIANCE=179, DOT2=180, SEMICOLON=181, LEFT_PAREN=182,
RIGHT_PAREN=183, COMMA=184, DOT=185, DOTDOTDOT=186, LEFT_BRACKET=187,
RIGHT_BRACKET=188, LEFT_BRACE=189, RIGHT_BRACE=190, ACCOUNT_LOCK=191,
ACCOUNT_UNLOCK=192, ACTIONS=193, ADD=194, ADMIN=195, AFTER=196, AGG_STATE=197,
AGGREGATE=198, ALIAS=199, ALL=200, ALTER=201, ANALYZE=202, ANALYZED=203,
ANALYZER=204, AND=205, ANTI=206, APPEND=207, ARRAY=208, AS=209, ASC=210,
AT=211, AUTHORS=212, AUTO=213, AUTO_INCREMENT=214, ALWAYS=215, BACKEND=216,
BACKENDS=217, BACKUP=218, BEGIN=219, BELONG=220, BETWEEN=221, BIGINT=222,
BIN=223, BINARY=224, BINLOG=225, BITAND=226, BITMAP=227, BITMAP_EMPTY=228,
BITMAP_UNION=229, BITOR=230, BITXOR=231, BLOB=232, BOOLEAN=233, BRANCH=234,
BRIEF=235, BROKER=236, BUCKETS=237, BUILD=238, BUILTIN=239, BULK=240,
BY=241, CACHE=242, CACHED=243, CALL=244, CANCEL=245, CASE=246, CAST=247,
CATALOG=248, CATALOGS=249, CHAIN=250, CHAR=251, CHARSET=252, CHECK=253,
CLEAN=254, CLUSTER=255, CLUSTERS=256, COLLATE=257, COLLATION=258, COLLECT=259,
COLOCATE=260, COLUMN=261, COLUMNS=262, COMMENT=263, COMMIT=264, COMMITTED=265,
COMPACT=266, COMPLETE=267, COMPRESS_TYPE=268, COMPUTE=269, CONDITIONS=270,
CONFIG=271, CONNECTION=272, CONNECTION_ID=273, CONSISTENT=274, CONSTRAINT=275,
CONSTRAINTS=276, CONVERT=277, CONVERT_LSC=278, COPY=279, COUNT=280, CREATE=281,
CREATION=282, CRON=283, CROSS=284, CUBE=285, CURRENT=286, CURRENT_CATALOG=287,
CURRENT_DATE=288, CURRENT_TIME=289, CURRENT_TIMESTAMP=290, CURRENT_USER=291,
DATA=292, DATABASE=293, DATABASES=294, DATE=295, DATETIME=296, DATETIMEV2=297,
DATEV2=298, DATETIMEV1=299, DATEV1=300, DAY=301, DECIMAL=302, DECIMALV2=303,
DECIMALV3=304, DECOMMISSION=305, DEFAULT=306, DEFERRED=307, DELETE=308,
DEMAND=309, DESC=310, DESCRIBE=311, DIAGNOSE=312, DIAGNOSIS=313, DISK=314,
DISTINCT=315, DISTINCTPC=316, DISTINCTPCSA=317, DISTRIBUTED=318, DISTRIBUTION=319,
DIV=320, DO=321, DORIS_INTERNAL_TABLE_ID=322, DOUBLE=323, DROP=324, DROPP=325,
DUAL=326, DUMP=327, DUPLICATE=328, DYNAMIC=329, E=330, ELSE=331, ENABLE=332,
ENCRYPTKEY=333, ENCRYPTKEYS=334, END=335, ENDS=336, ENGINE=337, ENGINES=338,
ENTER=339, ERRORS=340, ESCAPE=341, EVENTS=342, EVERY=343, EXCEPT=344,
EXCLUDE=345, EXECUTE=346, EXISTS=347, EXPIRED=348, EXPLAIN=349, EXPORT=350,
EXTENDED=351, EXTERNAL=352, EXTRACT=353, FAILED_LOGIN_ATTEMPTS=354, FALSE=355,
FAST=356, FEATURE=357, FIELDS=358, FILE=359, FILTER=360, FIRST=361, FLOAT=362,
FOLLOWER=363, FOLLOWING=364, FOR=365, FOREIGN=366, FORCE=367, FORMAT=368,
FREE=369, FROM=370, FRONTEND=371, FRONTENDS=372, FULL=373, FUNCTION=374,
FUNCTIONS=375, GENERATED=376, GENERIC=377, GLOBAL=378, GRANT=379, GRANTS=380,
GRAPH=381, GROUP=382, GROUPING=383, GROUPS=384, HASH=385, HAVING=386,
HDFS=387, HELP=388, HISTOGRAM=389, HLL=390, HLL_UNION=391, HOSTNAME=392,
HOTSPOT=393, HOUR=394, HOURS=395, HUB=396, IDENTIFIED=397, IF=398, IGNORE=399,
IMMEDIATE=400, IN=401, INCREMENTAL=402, INDEX=403, INDEXES=404, INFILE=405,
INNER=406, INSERT=407, INSTALL=408, INT=409, INTEGER=410, INTERMEDIATE=411,
INTERSECT=412, INTERVAL=413, INTO=414, INVERTED=415, IPV4=416, IPV6=417,
IS=418, IS_NOT_NULL_PRED=419, IS_NULL_PRED=420, ISNULL=421, ISOLATION=422,
JOB=423, JOBS=424, JOIN=425, JSON=426, JSONB=427, KEY=428, KEYS=429, KILL=430,
LABEL=431, LARGEINT=432, LAST=433, LATERAL=434, LDAP=435, LDAP_ADMIN_PASSWORD=436,
LEFT=437, LESS=438, LEVEL=439, LIKE=440, LIMIT=441, LINES=442, LINK=443,
LIST=444, LOAD=445, LOCAL=446, LOCALTIME=447, LOCALTIMESTAMP=448, LOCATION=449,
LOCK=450, LOGICAL=451, LOW_PRIORITY=452, MANUAL=453, MAP=454, MATCH=455,
MATCH_ALL=456, MATCH_ANY=457, MATCH_PHRASE=458, MATCH_PHRASE_EDGE=459,
MATCH_PHRASE_PREFIX=460, MATCH_REGEXP=461, MATCH_NAME=462, MATCH_NAME_GLOB=463,
MATERIALIZED=464, MAX=465, MAXVALUE=466, MEMO=467, MERGE=468, MIGRATE=469,
MIGRATIONS=470, MIN=471, MINUS=472, MINUTE=473, MINUTES=474, MODIFY=475,
MONTH=476, MTMV=477, NAME=478, NAMES=479, NATURAL=480, NEGATIVE=481, NEVER=482,
NEXT=483, NGRAM_BF=484, NO=485, NON_NULLABLE=486, NOT=487, NULL=488, NULLS=489,
OBSERVER=490, OF=491, OFFSET=492, ON=493, ONLY=494, OPEN=495, OPTIMIZED=496,
OR=497, ORDER=498, OUTER=499, OUTFILE=500, OVER=501, OVERWRITE=502, PARAMETER=503,
PARSED=504, PARTITION=505, PARTITIONS=506, PASSWORD=507, PASSWORD_EXPIRE=508,
PASSWORD_HISTORY=509, PASSWORD_LOCK_TIME=510, PASSWORD_REUSE=511, PATH=512,
PAUSE=513, PERCENT=514, PERIOD=515, PERMISSIVE=516, PHYSICAL=517, PI=518,
PLACEHOLDER=519, PLAN=520, PLAY=521, PRIVILEGES=522, PROCESS=523, PLUGIN=524,
PLUGINS=525, POLICY=526, PRECEDING=527, PREPARE=528, PRIMARY=529, PROC=530,
PROCEDURE=531, PROCESSLIST=532, PROFILE=533, PROPERTIES=534, PROPERTY=535,
QUANTILE_STATE=536, QUANTILE_UNION=537, QUERY=538, QUOTA=539, RANDOM=540,
RANGE=541, READ=542, REAL=543, REBALANCE=544, RECENT=545, RECOVER=546,
RECYCLE=547, REFRESH=548, REFERENCES=549, REGEXP=550, RELEASE=551, RENAME=552,
REPAIR=553, REPEATABLE=554, REPLACE=555, REPLACE_IF_NOT_NULL=556, REPLAYER=557,
REPLICA=558, REPOSITORIES=559, REPOSITORY=560, RESOURCE=561, RESOURCES=562,
RESTORE=563, RESTRICTIVE=564, RESUME=565, RETAIN=566, RETENTION=567, RETURNS=568,
REVOKE=569, REWRITTEN=570, RIGHT=571, RLIKE=572, ROLE=573, ROLES=574,
ROLLBACK=575, ROLLUP=576, ROUTINE=577, ROW=578, ROWS=579, S3=580, SAMPLE=581,
SCHEDULE=582, SCHEDULER=583, SCHEMA=584, SCHEMAS=585, SECOND=586, SELECT=587,
SEMI=588, SERIALIZABLE=589, SESSION=590, SESSION_USER=591, SET=592, SETS=593,
SET_SESSION_VARIABLE=594, SHAPE=595, SHOW=596, SIGNED=597, SKEW=598, SMALLINT=599,
SNAPSHOT=600, SNAPSHOTS=601, SONAME=602, SPLIT=603, SQL_BLOCK_RULE=604,
STAGE=605, STAGES=606, START=607, STARTS=608, STATS=609, STATUS=610, STOP=611,
STORAGE=612, STREAM=613, STREAMING=614, STRING=615, STRUCT=616, SUM=617,
SUPERUSER=618, SWITCH=619, SYNC=620, SYSTEM=621, TABLE=622, TABLES=623,
TABLESAMPLE=624, TABLET=625, TABLETS=626, TAG=627, TASK=628, TASKS=629,
TEMPORARY=630, TERMINATED=631, TEXT=632, THAN=633, THEN=634, TIME=635,
TIMESTAMP=636, TINYINT=637, TO=638, TOKENIZER=639, TOKEN_FILTER=640, TRANSACTION=641,
TRASH=642, TREE=643, TRIGGERS=644, TRIM=645, TRUE=646, TRUNCATE=647, TYPE=648,
TYPECAST=649, TYPES=650, UNBOUNDED=651, UNCOMMITTED=652, UNINSTALL=653,
UNION=654, UNIQUE=655, UNLOCK=656, UNSET=657, UNSIGNED=658, UP=659, UPDATE=660,
USE=661, USER=662, USING=663, VALUE=664, VALUES=665, VARCHAR=666, VARIABLE=667,
VARIABLES=668, VARIANT=669, VAULT=670, VAULTS=671, VERBOSE=672, VERSION=673,
VIEW=674, VIEWS=675, WARM=676, WARNINGS=677, WEEK=678, WHEN=679, WHERE=680,
WHITELIST=681, WITH=682, WORK=683, WORKLOAD=684, WRITE=685, XOR=686, YEAR=687,
EQ=688, NSEQ=689, NEQ=690, LT=691, LTE=692, GT=693, GTE=694, PLUS=695,
SUBTRACT=696, ASTERISK=697, SLASH=698, MOD=699, TILDE=700, AMPERSAND=701,
LOGICALAND=702, LOGICALNOT=703, PIPE=704, DOUBLEPIPES=705, HAT=706, COLON=707,
ARROW=708, HINT_START=709, HINT_END=710, COMMENT_START=711, ATSIGN=712,
DOUBLEATSIGN=713, STRING_LITERAL=714, LEADING_STRING=715, BIGINT_LITERAL=716,
SMALLINT_LITERAL=717, TINYINT_LITERAL=718, INTEGER_VALUE=719, EXPONENT_VALUE=720,
DECIMAL_VALUE=721, BIGDECIMAL_LITERAL=722, IDENTIFIER=723, BACKQUOTED_IDENTIFIER=724,
SIMPLE_COMMENT=725, BRACKETED_COMMENT=726, FROM_DUAL=727, WS=728, UNRECOGNIZED=729;
public static final int
RULE_program = 0, RULE_block = 1, RULE_begin_end_block = 2, RULE_single_block_stmt = 3,
RULE_block_end = 4, RULE_procedure_block = 5, RULE_doris_statement = 6,
RULE_stmt = 7, RULE_semicolon_stmt = 8, RULE_exception_block = 9, RULE_exception_block_item = 10,
RULE_null_stmt = 11, RULE_expr_stmt = 12, RULE_assignment_stmt = 13, RULE_assignment_stmt_item = 14,
RULE_assignment_stmt_single_item = 15, RULE_assignment_stmt_collection_item = 16,
RULE_assignment_stmt_multiple_item = 17, RULE_assignment_stmt_select_item = 18,
RULE_allocate_cursor_stmt = 19, RULE_associate_locator_stmt = 20, RULE_break_stmt = 21,
RULE_call_stmt = 22, RULE_declare_stmt = 23, RULE_declare_block = 24,
RULE_declare_block_inplace = 25, RULE_declare_stmt_item = 26, RULE_declare_var_item = 27,
RULE_declare_condition_item = 28, RULE_declare_cursor_item = 29, RULE_cursor_with_return = 30,
RULE_cursor_without_return = 31, RULE_declare_handler_item = 32, RULE_dtype = 33,
RULE_dtype_len = 34, RULE_dtype_attr = 35, RULE_dtype_default = 36, RULE_create_function_stmt = 37,
RULE_create_function_return = 38, RULE_create_package_stmt = 39, RULE_package_spec = 40,
RULE_package_spec_item = 41, RULE_create_package_body_stmt = 42, RULE_package_body = 43,
RULE_package_body_item = 44, RULE_create_procedure_stmt = 45, RULE_drop_procedure_stmt = 46,
RULE_show_procedure_stmt = 47, RULE_show_create_procedure_stmt = 48, RULE_show_config_stmt = 49,
RULE_create_routine_params = 50, RULE_create_routine_param_item = 51,
RULE_create_routine_options = 52, RULE_create_routine_option = 53, RULE_exec_stmt = 54,
RULE_if_stmt = 55, RULE_if_plsql_stmt = 56, RULE_if_tsql_stmt = 57, RULE_if_bteq_stmt = 58,
RULE_elseif_block = 59, RULE_else_block = 60, RULE_include_stmt = 61,
RULE_exit_stmt = 62, RULE_get_diag_stmt = 63, RULE_get_diag_stmt_item = 64,
RULE_get_diag_stmt_exception_item = 65, RULE_get_diag_stmt_rowcount_item = 66,
RULE_leave_stmt = 67, RULE_map_object_stmt = 68, RULE_open_stmt = 69,
RULE_fetch_stmt = 70, RULE_fetch_limit = 71, RULE_close_stmt = 72, RULE_print_stmt = 73,
RULE_quit_stmt = 74, RULE_raise_stmt = 75, RULE_resignal_stmt = 76, RULE_return_stmt = 77,
RULE_set_session_option = 78, RULE_set_doris_session_option = 79, RULE_set_current_schema_option = 80,
RULE_set_mssql_session_option = 81, RULE_set_teradata_session_option = 82,
RULE_signal_stmt = 83, RULE_values_into_stmt = 84, RULE_while_stmt = 85,
RULE_unconditional_loop_stmt = 86, RULE_for_cursor_stmt = 87, RULE_for_range_stmt = 88,
RULE_label_stmt = 89, RULE_using_clause = 90, RULE_bool_expr = 91, RULE_bool_expr_atom = 92,
RULE_bool_expr_unary = 93, RULE_bool_expr_binary = 94, RULE_bool_expr_logical_operator = 95,
RULE_bool_expr_binary_operator = 96, RULE_expr = 97, RULE_expr_atom = 98,
RULE_expr_interval = 99, RULE_interval_item = 100, RULE_expr_concat = 101,
RULE_expr_concat_item = 102, RULE_expr_case = 103, RULE_expr_case_simple = 104,
RULE_expr_case_searched = 105, RULE_expr_cursor_attribute = 106, RULE_expr_agg_window_func = 107,
RULE_expr_func_all_distinct = 108, RULE_order_by_clause = 109, RULE_expr_func_over_clause = 110,
RULE_expr_func_partition_by_clause = 111, RULE_expr_spec_func = 112, RULE_expr_func = 113,
RULE_expr_dot = 114, RULE_expr_dot_method_call = 115, RULE_expr_dot_property_access = 116,
RULE_expr_func_params = 117, RULE_func_param = 118, RULE_host_pl = 119,
RULE_host_cmd = 120, RULE_host_stmt = 121, RULE_file_name = 122, RULE_date_literal = 123,
RULE_timestamp_literal = 124, RULE_ident_pl = 125, RULE_qident = 126,
RULE_string = 127, RULE_int_number = 128, RULE_dec_number = 129, RULE_bool_literal = 130,
RULE_null_const = 131, RULE_non_reserved_words = 132, RULE_multiStatements = 133,
RULE_singleStatement = 134, RULE_expressionWithEof = 135, RULE_statement = 136,
RULE_statementBase = 137, RULE_unsupportedStatement = 138, RULE_materializedViewStatement = 139,
RULE_supportedJobStatement = 140, RULE_constraintStatement = 141, RULE_optSpecBranch = 142,
RULE_supportedDmlStatement = 143, RULE_supportedCreateStatement = 144,
RULE_supportedAlterStatement = 145, RULE_supportedDropStatement = 146,
RULE_supportedShowStatement = 147, RULE_supportedKillStatement = 148,
RULE_unsupportedOtherStatement = 149, RULE_warmUpItem = 150, RULE_lockTable = 151,
RULE_unsupportedShowStatement = 152, RULE_unsupportedLoadStatement = 153,
RULE_loadProperty = 154, RULE_importSequenceStatement = 155, RULE_importDeleteOnStatement = 156,
RULE_importWhereStatement = 157, RULE_importPrecedingFilterStatement = 158,
RULE_importColumnsStatement = 159, RULE_importColumnDesc = 160, RULE_unsupportedRefreshStatement = 161,
RULE_unsupportedCleanStatement = 162, RULE_unsupportedJobStatement = 163,
RULE_unsupportedCancelStatement = 164, RULE_unsupportedRecoverStatement = 165,
RULE_unsupportedAdminStatement = 166, RULE_baseTableRef = 167, RULE_wildWhere = 168,
RULE_unsupportedTransactionStatement = 169, RULE_unsupportedGrantRevokeStatement = 170,
RULE_privilege = 171, RULE_privilegeList = 172, RULE_unsupportedAlterStatement = 173,
RULE_alterSystemClause = 174, RULE_dropRollupClause = 175, RULE_addRollupClause = 176,
RULE_alterTableClause = 177, RULE_createOrReplaceTagClause = 178, RULE_createOrReplaceBranchClause = 179,
RULE_tagOptions = 180, RULE_branchOptions = 181, RULE_retainTime = 182,
RULE_retentionSnapshot = 183, RULE_minSnapshotsToKeep = 184, RULE_timeValueWithUnit = 185,
RULE_dropBranchClause = 186, RULE_dropTagClause = 187, RULE_columnPosition = 188,
RULE_toRollup = 189, RULE_fromRollup = 190, RULE_unsupportedDropStatement = 191,
RULE_unsupportedStatsStatement = 192, RULE_analyzeProperties = 193, RULE_unsupportedCreateStatement = 194,
RULE_workloadPolicyActions = 195, RULE_workloadPolicyAction = 196, RULE_workloadPolicyConditions = 197,
RULE_workloadPolicyCondition = 198, RULE_storageBackend = 199, RULE_passwordOption = 200,
RULE_functionArguments = 201, RULE_functionArgument = 202, RULE_unsupportedSetStatement = 203,
RULE_optionWithType = 204, RULE_optionWithoutType = 205, RULE_variable = 206,
RULE_transactionAccessMode = 207, RULE_isolationLevel = 208, RULE_unsupoortedUnsetStatement = 209,
RULE_unsupportedUseStatement = 210, RULE_unsupportedDmlStatement = 211,
RULE_stageAndPattern = 212, RULE_unsupportedDescribeStatement = 213, RULE_constraint = 214,
RULE_partitionSpec = 215, RULE_partitionTable = 216, RULE_identityOrFunctionList = 217,
RULE_identityOrFunction = 218, RULE_dataDesc = 219, RULE_buildMode = 220,
RULE_refreshTrigger = 221, RULE_refreshSchedule = 222, RULE_refreshMethod = 223,
RULE_mvPartition = 224, RULE_identifierOrText = 225, RULE_identifierOrTextOrAsterisk = 226,
RULE_multipartIdentifierOrAsterisk = 227, RULE_identifierOrAsterisk = 228,
RULE_userIdentify = 229, RULE_grantUserIdentify = 230, RULE_explain = 231,
RULE_explainCommand = 232, RULE_planType = 233, RULE_replayCommand = 234,
RULE_replayType = 235, RULE_mergeType = 236, RULE_preFilterClause = 237,
RULE_deleteOnClause = 238, RULE_sequenceColClause = 239, RULE_colFromPath = 240,
RULE_colMappingList = 241, RULE_mappingExpr = 242, RULE_withRemoteStorageSystem = 243,
RULE_resourceDesc = 244, RULE_mysqlDataDesc = 245, RULE_skipLines = 246,
RULE_outFileClause = 247, RULE_query = 248, RULE_queryTerm = 249, RULE_setQuantifier = 250,
RULE_queryPrimary = 251, RULE_querySpecification = 252, RULE_cte = 253,
RULE_aliasQuery = 254, RULE_columnAliases = 255, RULE_selectClause = 256,
RULE_selectColumnClause = 257, RULE_whereClause = 258, RULE_fromClause = 259,
RULE_intoClause = 260, RULE_bulkCollectClause = 261, RULE_tableRow = 262,
RULE_relations = 263, RULE_relation = 264, RULE_joinRelation = 265, RULE_distributeType = 266,
RULE_relationHint = 267, RULE_aggClause = 268, RULE_groupingElement = 269,
RULE_groupingSet = 270, RULE_havingClause = 271, RULE_selectHint = 272,
RULE_hintStatement = 273, RULE_hintAssignment = 274, RULE_updateAssignment = 275,
RULE_updateAssignmentSeq = 276, RULE_lateralView = 277, RULE_queryOrganization = 278,
RULE_sortClause = 279, RULE_sortItem = 280, RULE_limitClause = 281, RULE_partitionClause = 282,
RULE_joinType = 283, RULE_joinCriteria = 284, RULE_identifierList = 285,
RULE_identifierSeq = 286, RULE_optScanParams = 287, RULE_relationPrimary = 288,
RULE_materializedViewName = 289, RULE_propertyClause = 290, RULE_propertyItemList = 291,
RULE_propertyItem = 292, RULE_propertyKey = 293, RULE_propertyValue = 294,
RULE_tableAlias = 295, RULE_multipartIdentifier = 296, RULE_simpleColumnDefs = 297,
RULE_simpleColumnDef = 298, RULE_columnDefs = 299, RULE_columnDef = 300,
RULE_indexDefs = 301, RULE_indexDef = 302, RULE_partitionsDef = 303, RULE_partitionDef = 304,
RULE_lessThanPartitionDef = 305, RULE_fixedPartitionDef = 306, RULE_stepPartitionDef = 307,
RULE_inPartitionDef = 308, RULE_partitionValueList = 309, RULE_partitionValueDef = 310,
RULE_rollupDefs = 311, RULE_rollupDef = 312, RULE_aggTypeDef = 313, RULE_tabletList = 314,
RULE_inlineTable = 315, RULE_namedExpression = 316, RULE_namedExpressionSeq = 317,
RULE_expression = 318, RULE_lambdaExpression = 319, RULE_booleanExpression = 320,
RULE_rowConstructor = 321, RULE_rowConstructorItem = 322, RULE_predicate = 323,
RULE_valueExpression = 324, RULE_primaryExpression = 325, RULE_castDataType = 326,
RULE_functionCallExpression = 327, RULE_functionIdentifier = 328, RULE_functionNameIdentifier = 329,
RULE_windowSpec = 330, RULE_windowFrame = 331, RULE_frameUnits = 332,
RULE_frameBoundary = 333, RULE_qualifiedName = 334, RULE_specifiedPartition = 335,
RULE_constant = 336, RULE_comparisonOperator = 337, RULE_booleanValue = 338,
RULE_whenClause = 339, RULE_interval = 340, RULE_unitIdentifier = 341,
RULE_dataTypeWithNullable = 342, RULE_dataType = 343, RULE_primitiveColType = 344,
RULE_complexColTypeList = 345, RULE_complexColType = 346, RULE_variantTypeDefinitions = 347,
RULE_variantSubColTypeList = 348, RULE_variantSubColType = 349, RULE_variantSubColMatchType = 350,
RULE_commentSpec = 351, RULE_sample = 352, RULE_sampleMethod = 353, RULE_tableSnapshot = 354,
RULE_errorCapturingIdentifier = 355, RULE_errorCapturingIdentifierExtra = 356,
RULE_identifier = 357, RULE_strictIdentifier = 358, RULE_quotedIdentifier = 359,
RULE_number = 360, RULE_nonReserved = 361;
private static String[] makeRuleNames() {
return new String[] {
"program", "block", "begin_end_block", "single_block_stmt", "block_end",
"procedure_block", "doris_statement", "stmt", "semicolon_stmt", "exception_block",
"exception_block_item", "null_stmt", "expr_stmt", "assignment_stmt",
"assignment_stmt_item", "assignment_stmt_single_item", "assignment_stmt_collection_item",
"assignment_stmt_multiple_item", "assignment_stmt_select_item", "allocate_cursor_stmt",
"associate_locator_stmt", "break_stmt", "call_stmt", "declare_stmt",
"declare_block", "declare_block_inplace", "declare_stmt_item", "declare_var_item",
"declare_condition_item", "declare_cursor_item", "cursor_with_return",
"cursor_without_return", "declare_handler_item", "dtype", "dtype_len",
"dtype_attr", "dtype_default", "create_function_stmt", "create_function_return",
"create_package_stmt", "package_spec", "package_spec_item", "create_package_body_stmt",
"package_body", "package_body_item", "create_procedure_stmt", "drop_procedure_stmt",
"show_procedure_stmt", "show_create_procedure_stmt", "show_config_stmt",
"create_routine_params", "create_routine_param_item", "create_routine_options",
"create_routine_option", "exec_stmt", "if_stmt", "if_plsql_stmt", "if_tsql_stmt",
"if_bteq_stmt", "elseif_block", "else_block", "include_stmt", "exit_stmt",
"get_diag_stmt", "get_diag_stmt_item", "get_diag_stmt_exception_item",
"get_diag_stmt_rowcount_item", "leave_stmt", "map_object_stmt", "open_stmt",
"fetch_stmt", "fetch_limit", "close_stmt", "print_stmt", "quit_stmt",
"raise_stmt", "resignal_stmt", "return_stmt", "set_session_option", "set_doris_session_option",
"set_current_schema_option", "set_mssql_session_option", "set_teradata_session_option",
"signal_stmt", "values_into_stmt", "while_stmt", "unconditional_loop_stmt",
"for_cursor_stmt", "for_range_stmt", "label_stmt", "using_clause", "bool_expr",
"bool_expr_atom", "bool_expr_unary", "bool_expr_binary", "bool_expr_logical_operator",
"bool_expr_binary_operator", "expr", "expr_atom", "expr_interval", "interval_item",
"expr_concat", "expr_concat_item", "expr_case", "expr_case_simple", "expr_case_searched",
"expr_cursor_attribute", "expr_agg_window_func", "expr_func_all_distinct",
"order_by_clause", "expr_func_over_clause", "expr_func_partition_by_clause",
"expr_spec_func", "expr_func", "expr_dot", "expr_dot_method_call", "expr_dot_property_access",
"expr_func_params", "func_param", "host_pl", "host_cmd", "host_stmt",
"file_name", "date_literal", "timestamp_literal", "ident_pl", "qident",
"string", "int_number", "dec_number", "bool_literal", "null_const", "non_reserved_words",
"multiStatements", "singleStatement", "expressionWithEof", "statement",
"statementBase", "unsupportedStatement", "materializedViewStatement",
"supportedJobStatement", "constraintStatement", "optSpecBranch", "supportedDmlStatement",
"supportedCreateStatement", "supportedAlterStatement", "supportedDropStatement",
"supportedShowStatement", "supportedKillStatement", "unsupportedOtherStatement",
"warmUpItem", "lockTable", "unsupportedShowStatement", "unsupportedLoadStatement",
"loadProperty", "importSequenceStatement", "importDeleteOnStatement",
"importWhereStatement", "importPrecedingFilterStatement", "importColumnsStatement",
"importColumnDesc", "unsupportedRefreshStatement", "unsupportedCleanStatement",
"unsupportedJobStatement", "unsupportedCancelStatement", "unsupportedRecoverStatement",
"unsupportedAdminStatement", "baseTableRef", "wildWhere", "unsupportedTransactionStatement",
"unsupportedGrantRevokeStatement", "privilege", "privilegeList", "unsupportedAlterStatement",
"alterSystemClause", "dropRollupClause", "addRollupClause", "alterTableClause",
"createOrReplaceTagClause", "createOrReplaceBranchClause", "tagOptions",
"branchOptions", "retainTime", "retentionSnapshot", "minSnapshotsToKeep",
"timeValueWithUnit", "dropBranchClause", "dropTagClause", "columnPosition",
"toRollup", "fromRollup", "unsupportedDropStatement", "unsupportedStatsStatement",
"analyzeProperties", "unsupportedCreateStatement", "workloadPolicyActions",
"workloadPolicyAction", "workloadPolicyConditions", "workloadPolicyCondition",
"storageBackend", "passwordOption", "functionArguments", "functionArgument",
"unsupportedSetStatement", "optionWithType", "optionWithoutType", "variable",
"transactionAccessMode", "isolationLevel", "unsupoortedUnsetStatement",
"unsupportedUseStatement", "unsupportedDmlStatement", "stageAndPattern",
"unsupportedDescribeStatement", "constraint", "partitionSpec", "partitionTable",
"identityOrFunctionList", "identityOrFunction", "dataDesc", "buildMode",
"refreshTrigger", "refreshSchedule", "refreshMethod", "mvPartition",
"identifierOrText", "identifierOrTextOrAsterisk", "multipartIdentifierOrAsterisk",
"identifierOrAsterisk", "userIdentify", "grantUserIdentify", "explain",
"explainCommand", "planType", "replayCommand", "replayType", "mergeType",
"preFilterClause", "deleteOnClause", "sequenceColClause", "colFromPath",
"colMappingList", "mappingExpr", "withRemoteStorageSystem", "resourceDesc",
"mysqlDataDesc", "skipLines", "outFileClause", "query", "queryTerm",
"setQuantifier", "queryPrimary", "querySpecification", "cte", "aliasQuery",
"columnAliases", "selectClause", "selectColumnClause", "whereClause",
"fromClause", "intoClause", "bulkCollectClause", "tableRow", "relations",
"relation", "joinRelation", "distributeType", "relationHint", "aggClause",
"groupingElement", "groupingSet", "havingClause", "selectHint", "hintStatement",
"hintAssignment", "updateAssignment", "updateAssignmentSeq", "lateralView",
"queryOrganization", "sortClause", "sortItem", "limitClause", "partitionClause",
"joinType", "joinCriteria", "identifierList", "identifierSeq", "optScanParams",
"relationPrimary", "materializedViewName", "propertyClause", "propertyItemList",
"propertyItem", "propertyKey", "propertyValue", "tableAlias", "multipartIdentifier",
"simpleColumnDefs", "simpleColumnDef", "columnDefs", "columnDef", "indexDefs",
"indexDef", "partitionsDef", "partitionDef", "lessThanPartitionDef",
"fixedPartitionDef", "stepPartitionDef", "inPartitionDef", "partitionValueList",
"partitionValueDef", "rollupDefs", "rollupDef", "aggTypeDef", "tabletList",
"inlineTable", "namedExpression", "namedExpressionSeq", "expression",
"lambdaExpression", "booleanExpression", "rowConstructor", "rowConstructorItem",
"predicate", "valueExpression", "primaryExpression", "castDataType",
"functionCallExpression", "functionIdentifier", "functionNameIdentifier",
"windowSpec", "windowFrame", "frameUnits", "frameBoundary", "qualifiedName",
"specifiedPartition", "constant", "comparisonOperator", "booleanValue",
"whenClause", "interval", "unitIdentifier", "dataTypeWithNullable", "dataType",
"primitiveColType", "complexColTypeList", "complexColType", "variantTypeDefinitions",
"variantSubColTypeList", "variantSubColType", "variantSubColMatchType",
"commentSpec", "sample", "sampleMethod", "tableSnapshot", "errorCapturingIdentifier",
"errorCapturingIdentifierExtra", "identifier", "strictIdentifier", "quotedIdentifier",
"number", "nonReserved"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'ACTION'", "'ALLOCATE'", "'ANSI_NULLS'", "'ANSI_PADDING'", "'ASSOCIATE'",
"'AVG'", "'BATCHSIZE'", "'BINARY_DOUBLE'", "'BINARY_FLOAT'", "'BINARY_INTEGER'",
"'BIT'", "'BODY'", "'BREAK'", "'BYTE'", "'CALLER'", "'CASCADE'", "'CASESPECIFIC'",
"'CLIENT'", "'CLOSE'", "'CLUSTERED'", "'CMP'", "'COLLECTION'", "'COMPRESS'",
"'CONCAT'", "'CONDITION'", "'CONSTANT'", "'CONTINUE'", "'COUNT_BIG'",
"'CREATOR'", "'CS'", "'CURRENT_SCHEMA'", "'CURSOR'", "'DAYS'", "'DEC'",
"'DECLARE'", "'DEFINED'", "'DEFINER'", "'DEFINITION'", "'DELIMITED'",
"'DELIMITER'", "'DIAGNOSTICS'", "'DIR'", "'DIRECTORY'", "'DISTRIBUTE'",
"'ELSEIF'", "'ELSIF'", "'ESCAPED'", "'EXEC'", "'EXCEPTION'", "'EXCLUSIVE'",
"'EXIT'", "'FALLBACK'", "'FETCH'", "'FILES'", "'FOUND'", "'GET'", "'GO'",
"'HANDLER'", "'HOST'", "'IDENTITY'", "'INCLUDE'", "'INITRANS'", "'INOUT'",
"'INT2'", "'INT4'", "'INT8'", "'INVOKER'", "'ISOPEN'", "'ITEMS'", "'KEEP'",
"'LANGUAGE'", "'LEAVE'", "'LOCATOR'", "'LOCATORS'", "'LOCKS'", "'LOG'",
"'LOGGED'", "'LOGGING'", "'LOOP'", "'MATCHED'", "'MAXTRANS'", "'MESSAGE_TEXT'",
"'MICROSECOND'", "'MICROSECONDS'", "'MULTISET'", "'NCHAR'", "'NEW'",
"'NVARCHAR'", "'NOCOUNT'", "'NOCOMPRESS'", "'NOLOGGING'", "'NONE'", "'NOTFOUND'",
"'NUMERIC'", "'NUMBER'", "'OBJECT'", "'OFF'", "'OUT'", "'OWNER'", "'PACKAGE'",
"'PCTFREE'", "'PCTUSED'", "'PLS_INTEGER'", "'PRECISION'", "'PRESERVE'",
"'PRINT'", "'QUALIFY'", "'QUERY_BAND'", "'QUIT'", "'QUOTED_IDENTIFIER'",
"'RAISE'", "'RESIGNAL'", "'RESTRICT'", "'RESULT'", "'RESULT_SET_LOCATOR'",
"'RETURN'", "'REVERSE'", "'ROWTYPE'", "'ROW_COUNT'", "'RR'", "'RS'",
"'PWD'", "'SECONDS'", "'SECURITY'", "'SEGMENT'", "'SEL'", "'SESSIONS'",
"'SHARE'", "'SIGNAL'", "'SIMPLE_DOUBLE'", "'SIMPLE_FLOAT'", "'SIMPLE_INTEGER'",
"'SMALLDATETIME'", "'SQL'", "'SQLEXCEPTION'", "'SQLINSERT'", "'SQLSTATE'",
"'SQLWARNING'", "'STATISTICS'", "'STEP'", "'STORED'", "'SUBDIR'", "'SUBSTRING'",
"'SUMMARY'", "'SYS_REFCURSOR'", "'TABLESPACE'", "'TEXTIMAGE_ON'", "'TITLE'",
"'TOP'", "'UR'", "'VAR'", "'VARCHAR2'", "'VARYING'", "'VOLATILE'", "'WHILE'",
"'WITHOUT'", "'XACT_ABORT'", "'XML'", "'YES'", "'ACTIVITY_COUNT'", "'CUME_DIST'",
"'DENSE_RANK'", "'FIRST_VALUE'", "'LAG'", "'LAST_VALUE'", "'LEAD'", "'MAX_PART_STRING'",
"'MIN_PART_STRING'", "'MAX_PART_INT'", "'MIN_PART_INT'", "'MAX_PART_DATE'",
"'MIN_PART_DATE'", "'PART_COUNT'", "'PART_LOC'", "'RANK'", "'ROW_NUMBER'",
"'STDEV'", "'SYSDATE'", "'VARIANCE'", "'..'", "';'", "'('", "')'", "','",
"'.'", "'...'", "'['", "']'", "'{'", "'}'", "'ACCOUNT_LOCK'", "'ACCOUNT_UNLOCK'",
"'ACTIONS'", "'ADD'", "'ADMIN'", "'AFTER'", "'AGG_STATE'", "'AGGREGATE'",
"'ALIAS'", "'ALL'", "'ALTER'", "'ANALYZE'", "'ANALYZED'", "'ANALYZER'",
"'AND'", "'ANTI'", "'APPEND'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORS'",
"'AUTO'", "'AUTO_INCREMENT'", "'ALWAYS'", "'BACKEND'", "'BACKENDS'",
"'BACKUP'", "'BEGIN'", "'BELONG'", "'BETWEEN'", "'BIGINT'", "'BIN'",
"'BINARY'", "'BINLOG'", "'BITAND'", "'BITMAP'", "'BITMAP_EMPTY'", "'BITMAP_UNION'",
"'BITOR'", "'BITXOR'", "'BLOB'", "'BOOLEAN'", "'BRANCH'", "'BRIEF'",
"'BROKER'", "'BUCKETS'", "'BUILD'", "'BUILTIN'", "'BULK'", "'BY'", "'CACHE'",
"'CACHED'", "'CALL'", "'CANCEL'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'",
"'CHAIN'", null, "'CHARSET'", "'CHECK'", "'CLEAN'", "'CLUSTER'", "'CLUSTERS'",
"'COLLATE'", "'COLLATION'", "'COLLECT'", "'COLOCATE'", "'COLUMN'", "'COLUMNS'",
"'COMMENT'", "'COMMIT'", "'COMMITTED'", "'COMPACT'", "'COMPLETE'", "'COMPRESS_TYPE'",
"'COMPUTE'", "'CONDITIONS'", "'CONFIG'", "'CONNECTION'", "'CONNECTION_ID'",
"'CONSISTENT'", "'CONSTRAINT'", "'CONSTRAINTS'", "'CONVERT'", "'CONVERT_LIGHT_SCHEMA_CHANGE_PROCESS'",
"'COPY'", "'COUNT'", "'CREATE'", "'CREATION'", "'CRON'", "'CROSS'", "'CUBE'",
"'CURRENT'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", "'CURRENT_TIME'",
"'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DATA'", "'DATABASE'", "'DATABASES'",
"'DATE'", "'DATETIME'", "'DATETIMEV2'", "'DATEV2'", "'DATETIMEV1'", "'DATEV1'",
"'DAY'", "'DECIMAL'", "'DECIMALV2'", "'DECIMALV3'", "'DECOMMISSION'",
"'DEFAULT'", "'DEFERRED'", "'DELETE'", "'DEMAND'", "'DESC'", "'DESCRIBE'",
"'DIAGNOSE'", "'DIAGNOSIS'", "'DISK'", "'DISTINCT'", "'DISTINCTPC'",
"'DISTINCTPCSA'", "'DISTRIBUTED'", "'DISTRIBUTION'", "'DIV'", "'DO'",
"'DORIS_INTERNAL_TABLE_ID'", "'DOUBLE'", "'DROP'", "'DROPP'", "'DUAL'",
"'DUMP'", "'DUPLICATE'", "'DYNAMIC'", "'E'", "'ELSE'", "'ENABLE'", "'ENCRYPTKEY'",
"'ENCRYPTKEYS'", "'END'", "'ENDS'", "'ENGINE'", "'ENGINES'", "'ENTER'",
"'ERRORS'", "'ESCAPE'", "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCLUDE'",
"'EXECUTE'", "'EXISTS'", "'EXPIRED'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'",
"'EXTERNAL'", "'EXTRACT'", "'FAILED_LOGIN_ATTEMPTS'", "'FALSE'", "'FAST'",
"'FEATURE'", "'FIELDS'", "'FILE'", "'FILTER'", "'FIRST'", "'FLOAT'",
"'FOLLOWER'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORCE'", "'FORMAT'",
"'FREE'", "'FROM'", "'FRONTEND'", "'FRONTENDS'", "'FULL'", "'FUNCTION'",
"'FUNCTIONS'", "'GENERATED'", "'GENERIC'", "'GLOBAL'", "'GRANT'", "'GRANTS'",
"'GRAPH'", "'GROUP'", "'GROUPING'", "'GROUPS'", "'HASH'", "'HAVING'",
"'HDFS'", "'HELP'", "'HISTOGRAM'", "'HLL'", "'HLL_UNION'", "'HOSTNAME'",
"'HOTSPOT'", "'HOUR'", "'HOURS'", "'HUB'", "'IDENTIFIED'", "'IF'", "'IGNORE'",
"'IMMEDIATE'", "'IN'", "'INCREMENTAL'", "'INDEX'", "'INDEXES'", "'INFILE'",
"'INNER'", "'INSERT'", "'INSTALL'", "'INT'", "'INTEGER'", "'INTERMEDIATE'",
"'INTERSECT'", "'INTERVAL'", "'INTO'", "'INVERTED'", "'IPV4'", "'IPV6'",
"'IS'", "'IS_NOT_NULL_PRED'", "'IS_NULL_PRED'", "'ISNULL'", "'ISOLATION'",
"'JOB'", "'JOBS'", "'JOIN'", "'JSON'", "'JSONB'", "'KEY'", "'KEYS'",
"'KILL'", "'LABEL'", "'LARGEINT'", "'LAST'", "'LATERAL'", "'LDAP'", "'LDAP_ADMIN_PASSWORD'",
"'LEFT'", "'LESS'", "'LEVEL'", "'LIKE'", "'LIMIT'", "'LINES'", "'LINK'",
"'LIST'", "'LOAD'", "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'LOCATION'",
"'LOCK'", "'LOGICAL'", "'LOW_PRIORITY'", "'MANUAL'", "'MAP'", "'MATCH'",
"'MATCH_ALL'", "'MATCH_ANY'", "'MATCH_PHRASE'", "'MATCH_PHRASE_EDGE'",
"'MATCH_PHRASE_PREFIX'", "'MATCH_REGEXP'", "'MATCH_NAME'", "'MATCH_NAME_GLOB'",
"'MATERIALIZED'", "'MAX'", "'MAXVALUE'", "'MEMO'", "'MERGE'", "'MIGRATE'",
"'MIGRATIONS'", "'MIN'", "'MINUS'", "'MINUTE'", "'MINUTES'", "'MODIFY'",
"'MONTH'", "'MTMV'", "'NAME'", "'NAMES'", "'NATURAL'", "'NEGATIVE'",
"'NEVER'", "'NEXT'", "'NGRAM_BF'", "'NO'", "'NON_NULLABLE'", "'NOT'",
"'NULL'", "'NULLS'", "'OBSERVER'", "'OF'", "'OFFSET'", "'ON'", "'ONLY'",
"'OPEN'", "'OPTIMIZED'", "'OR'", "'ORDER'", "'OUTER'", "'OUTFILE'", "'OVER'",
"'OVERWRITE'", "'PARAMETER'", "'PARSED'", "'PARTITION'", "'PARTITIONS'",
"'PASSWORD'", "'PASSWORD_EXPIRE'", "'PASSWORD_HISTORY'", "'PASSWORD_LOCK_TIME'",
"'PASSWORD_REUSE'", "'PATH'", "'PAUSE'", "'PERCENT'", "'PERIOD'", "'PERMISSIVE'",
"'PHYSICAL'", "'PI'", "'?'", "'PLAN'", "'PLAY'", "'PRIVILEGES'", "'PROCESS'",
"'PLUGIN'", "'PLUGINS'", "'POLICY'", "'PRECEDING'", "'PREPARE'", "'PRIMARY'",
"'PROC'", "'PROCEDURE'", "'PROCESSLIST'", "'PROFILE'", "'PROPERTIES'",
"'PROPERTY'", "'QUANTILE_STATE'", "'QUANTILE_UNION'", "'QUERY'", "'QUOTA'",
"'RANDOM'", "'RANGE'", "'READ'", "'REAL'", "'REBALANCE'", "'RECENT'",
"'RECOVER'", "'RECYCLE'", "'REFRESH'", "'REFERENCES'", "'REGEXP'", "'RELEASE'",
"'RENAME'", "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'REPLACE_IF_NOT_NULL'",
"'REPLAYER'", "'REPLICA'", "'REPOSITORIES'", "'REPOSITORY'", "'RESOURCE'",
"'RESOURCES'", "'RESTORE'", "'RESTRICTIVE'", "'RESUME'", "'RETAIN'",
"'RETENTION'", "'RETURNS'", "'REVOKE'", "'REWRITTEN'", "'RIGHT'", "'RLIKE'",
"'ROLE'", "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROUTINE'", "'ROW'",
"'ROWS'", "'S3'", "'SAMPLE'", "'SCHEDULE'", "'SCHEDULER'", "'SCHEMA'",
"'SCHEMAS'", "'SECOND'", "'SELECT'", "'SEMI'", "'SERIALIZABLE'", "'SESSION'",
"'SESSION_USER'", "'SET'", "'SETS'", "'SET_SESSION_VARIABLE'", "'SHAPE'",
"'SHOW'", "'SIGNED'", "'SKEW'", "'SMALLINT'", "'SNAPSHOT'", "'SNAPSHOTS'",
"'SONAME'", "'SPLIT'", "'SQL_BLOCK_RULE'", "'STAGE'", "'STAGES'", "'START'",
"'STARTS'", "'STATS'", "'STATUS'", "'STOP'", "'STORAGE'", "'STREAM'",
"'STREAMING'", "'STRING'", "'STRUCT'", "'SUM'", "'SUPERUSER'", "'SWITCH'",
"'SYNC'", "'SYSTEM'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TABLET'",
"'TABLETS'", "'TAG'", "'TASK'", "'TASKS'", "'TEMPORARY'", "'TERMINATED'",
"'TEXT'", "'THAN'", "'THEN'", "'TIME'", "'TIMESTAMP'", "'TINYINT'", "'TO'",
"'TOKENIZER'", "'TOKEN_FILTER'", "'TRANSACTION'", "'TRASH'", "'TREE'",
"'TRIGGERS'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TYPE'", "'TYPE_CAST'",
"'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNINSTALL'", "'UNION'",
"'UNIQUE'", "'UNLOCK'", "'UNSET'", "'UNSIGNED'", "'UP'", "'UPDATE'",
"'USE'", "'USER'", "'USING'", "'VALUE'", "'VALUES'", "'VARCHAR'", "'VARIABLE'",
"'VARIABLES'", "'VARIANT'", "'VAULT'", "'VAULTS'", "'VERBOSE'", "'VERSION'",
"'VIEW'", "'VIEWS'", "'WARM'", "'WARNINGS'", "'WEEK'", "'WHEN'", "'WHERE'",
"'WHITELIST'", "'WITH'", "'WORK'", "'WORKLOAD'", "'WRITE'", "'XOR'",
"'YEAR'", null, "'<=>'", null, "'<'", null, "'>'", null, "'+'", "'-'",
"'*'", "'/'", "'%'", "'~'", "'&'", "'&&'", "'!'", "'|'", "'||'", "'^'",
"':'", "'->'", "'/*+'", "'*/'", "'/*'", "'@'", "'@@'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "ACTION", "ALLOCATE", "ANSI_NULLS", "ANSI_PADDING", "ASSOCIATE",
"AVG", "BATCHSIZE", "BINARY_DOUBLE", "BINARY_FLOAT", "BINARY_INTEGER",
"BIT", "BODY", "BREAK", "BYTE", "CALLER", "CASCADE", "CASESPECIFIC",
"CLIENT", "CLOSE", "CLUSTERED", "CMP", "COLLECTION", "COMPRESS", "CONCAT",
"CONDITION", "CONSTANT", "CONTINUE", "COUNT_BIG", "CREATOR", "CS", "CURRENT_SCHEMA",
"CURSOR", "DAYS", "DEC", "DECLARE", "DEFINED", "DEFINER", "DEFINITION",
"DELIMITED", "DELIMITER", "DIAGNOSTICS", "DIR", "DIRECTORY", "DISTRIBUTE",
"ELSEIF", "ELSIF", "ESCAPED", "EXEC", "EXCEPTION", "EXCLUSIVE", "EXIT",
"FALLBACK", "FETCH", "FILES", "FOUND", "GET", "GO", "HANDLER", "HOST",
"IDENTITY", "INCLUDE", "INITRANS", "INOUT", "INT2", "INT4", "INT8", "INVOKER",
"ISOPEN", "ITEMS", "KEEP", "LANGUAGE", "LEAVE", "LOCATOR", "LOCATORS",
"LOCKS", "LOG", "LOGGED", "LOGGING", "LOOP", "MATCHED", "MAXTRANS", "MESSAGE_TEXT",
"MICROSECOND", "MICROSECONDS", "MULTISET", "NCHAR", "NEW", "NVARCHAR",
"NOCOUNT", "NOCOMPRESS", "NOLOGGING", "NONE", "NOTFOUND", "NUMERIC",
"NUMBER", "OBJECT", "OFF", "OUT", "OWNER", "PACKAGE", "PCTFREE", "PCTUSED",
"PLS_INTEGER", "PRECISION", "PRESERVE", "PRINT", "QUALIFY", "QUERY_BAND",
"QUIT", "QUOTED_IDENTIFIER", "RAISE", "RESIGNAL", "RESTRICT", "RESULT",
"RESULT_SET_LOCATOR", "RETURN", "REVERSE", "ROWTYPE", "ROW_COUNT", "RR",
"RS", "PWD", "SECONDS", "SECURITY", "SEGMENT", "SEL", "SESSIONS", "SHARE",
"SIGNAL", "SIMPLE_DOUBLE", "SIMPLE_FLOAT", "SIMPLE_INTEGER", "SMALLDATETIME",
"SQL", "SQLEXCEPTION", "SQLINSERT", "SQLSTATE", "SQLWARNING", "STATISTICS",
"STEP", "STORED", "SUBDIR", "SUBSTRING", "SUMMARY", "SYS_REFCURSOR",
"TABLESPACE", "TEXTIMAGE_ON", "TITLE", "TOP", "UR", "VAR", "VARCHAR2",
"VARYING", "VOLATILE", "WHILE", "WITHOUT", "XACT_ABORT", "XML", "YES",
"ACTIVITY_COUNT", "CUME_DIST", "DENSE_RANK", "FIRST_VALUE", "LAG", "LAST_VALUE",
"LEAD", "MAX_PART_STRING", "MIN_PART_STRING", "MAX_PART_INT", "MIN_PART_INT",
"MAX_PART_DATE", "MIN_PART_DATE", "PART_COUNT", "PART_LOC", "RANK", "ROW_NUMBER",
"STDEV", "SYSDATE", "VARIANCE", "DOT2", "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN",
"COMMA", "DOT", "DOTDOTDOT", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE",
"RIGHT_BRACE", "ACCOUNT_LOCK", "ACCOUNT_UNLOCK", "ACTIONS", "ADD", "ADMIN",
"AFTER", "AGG_STATE", "AGGREGATE", "ALIAS", "ALL", "ALTER", "ANALYZE",
"ANALYZED", "ANALYZER", "AND", "ANTI", "APPEND", "ARRAY", "AS", "ASC",
"AT", "AUTHORS", "AUTO", "AUTO_INCREMENT", "ALWAYS", "BACKEND", "BACKENDS",
"BACKUP", "BEGIN", "BELONG", "BETWEEN", "BIGINT", "BIN", "BINARY", "BINLOG",
"BITAND", "BITMAP", "BITMAP_EMPTY", "BITMAP_UNION", "BITOR", "BITXOR",
"BLOB", "BOOLEAN", "BRANCH", "BRIEF", "BROKER", "BUCKETS", "BUILD", "BUILTIN",
"BULK", "BY", "CACHE", "CACHED", "CALL", "CANCEL", "CASE", "CAST", "CATALOG",
"CATALOGS", "CHAIN", "CHAR", "CHARSET", "CHECK", "CLEAN", "CLUSTER",
"CLUSTERS", "COLLATE", "COLLATION", "COLLECT", "COLOCATE", "COLUMN",
"COLUMNS", "COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPLETE", "COMPRESS_TYPE",
"COMPUTE", "CONDITIONS", "CONFIG", "CONNECTION", "CONNECTION_ID", "CONSISTENT",
"CONSTRAINT", "CONSTRAINTS", "CONVERT", "CONVERT_LSC", "COPY", "COUNT",
"CREATE", "CREATION", "CRON", "CROSS", "CUBE", "CURRENT", "CURRENT_CATALOG",
"CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER",
"DATA", "DATABASE", "DATABASES", "DATE", "DATETIME", "DATETIMEV2", "DATEV2",
"DATETIMEV1", "DATEV1", "DAY", "DECIMAL", "DECIMALV2", "DECIMALV3", "DECOMMISSION",
"DEFAULT", "DEFERRED", "DELETE", "DEMAND", "DESC", "DESCRIBE", "DIAGNOSE",
"DIAGNOSIS", "DISK", "DISTINCT", "DISTINCTPC", "DISTINCTPCSA", "DISTRIBUTED",
"DISTRIBUTION", "DIV", "DO", "DORIS_INTERNAL_TABLE_ID", "DOUBLE", "DROP",
"DROPP", "DUAL", "DUMP", "DUPLICATE", "DYNAMIC", "E", "ELSE", "ENABLE",
"ENCRYPTKEY", "ENCRYPTKEYS", "END", "ENDS", "ENGINE", "ENGINES", "ENTER",
"ERRORS", "ESCAPE", "EVENTS", "EVERY", "EXCEPT", "EXCLUDE", "EXECUTE",
"EXISTS", "EXPIRED", "EXPLAIN", "EXPORT", "EXTENDED", "EXTERNAL", "EXTRACT",
"FAILED_LOGIN_ATTEMPTS", "FALSE", "FAST", "FEATURE", "FIELDS", "FILE",
"FILTER", "FIRST", "FLOAT", "FOLLOWER", "FOLLOWING", "FOR", "FOREIGN",
"FORCE", "FORMAT", "FREE", "FROM", "FRONTEND", "FRONTENDS", "FULL", "FUNCTION",
"FUNCTIONS", "GENERATED", "GENERIC", "GLOBAL", "GRANT", "GRANTS", "GRAPH",
"GROUP", "GROUPING", "GROUPS", "HASH", "HAVING", "HDFS", "HELP", "HISTOGRAM",
"HLL", "HLL_UNION", "HOSTNAME", "HOTSPOT", "HOUR", "HOURS", "HUB", "IDENTIFIED",
"IF", "IGNORE", "IMMEDIATE", "IN", "INCREMENTAL", "INDEX", "INDEXES",
"INFILE", "INNER", "INSERT", "INSTALL", "INT", "INTEGER", "INTERMEDIATE",
"INTERSECT", "INTERVAL", "INTO", "INVERTED", "IPV4", "IPV6", "IS", "IS_NOT_NULL_PRED",
"IS_NULL_PRED", "ISNULL", "ISOLATION", "JOB", "JOBS", "JOIN", "JSON",
"JSONB", "KEY", "KEYS", "KILL", "LABEL", "LARGEINT", "LAST", "LATERAL",
"LDAP", "LDAP_ADMIN_PASSWORD", "LEFT", "LESS", "LEVEL", "LIKE", "LIMIT",
"LINES", "LINK", "LIST", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP",
"LOCATION", "LOCK", "LOGICAL", "LOW_PRIORITY", "MANUAL", "MAP", "MATCH",
"MATCH_ALL", "MATCH_ANY", "MATCH_PHRASE", "MATCH_PHRASE_EDGE", "MATCH_PHRASE_PREFIX",
"MATCH_REGEXP", "MATCH_NAME", "MATCH_NAME_GLOB", "MATERIALIZED", "MAX",
"MAXVALUE", "MEMO", "MERGE", "MIGRATE", "MIGRATIONS", "MIN", "MINUS",
"MINUTE", "MINUTES", "MODIFY", "MONTH", "MTMV", "NAME", "NAMES", "NATURAL",
"NEGATIVE", "NEVER", "NEXT", "NGRAM_BF", "NO", "NON_NULLABLE", "NOT",
"NULL", "NULLS", "OBSERVER", "OF", "OFFSET", "ON", "ONLY", "OPEN", "OPTIMIZED",
"OR", "ORDER", "OUTER", "OUTFILE", "OVER", "OVERWRITE", "PARAMETER",
"PARSED", "PARTITION", "PARTITIONS", "PASSWORD", "PASSWORD_EXPIRE", "PASSWORD_HISTORY",
"PASSWORD_LOCK_TIME", "PASSWORD_REUSE", "PATH", "PAUSE", "PERCENT", "PERIOD",
"PERMISSIVE", "PHYSICAL", "PI", "PLACEHOLDER", "PLAN", "PLAY", "PRIVILEGES",
"PROCESS", "PLUGIN", "PLUGINS", "POLICY", "PRECEDING", "PREPARE", "PRIMARY",
"PROC", "PROCEDURE", "PROCESSLIST", "PROFILE", "PROPERTIES", "PROPERTY",
"QUANTILE_STATE", "QUANTILE_UNION", "QUERY", "QUOTA", "RANDOM", "RANGE",
"READ", "REAL", "REBALANCE", "RECENT", "RECOVER", "RECYCLE", "REFRESH",
"REFERENCES", "REGEXP", "RELEASE", "RENAME", "REPAIR", "REPEATABLE",
"REPLACE", "REPLACE_IF_NOT_NULL", "REPLAYER", "REPLICA", "REPOSITORIES",
"REPOSITORY", "RESOURCE", "RESOURCES", "RESTORE", "RESTRICTIVE", "RESUME",
"RETAIN", "RETENTION", "RETURNS", "REVOKE", "REWRITTEN", "RIGHT", "RLIKE",
"ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROUTINE", "ROW", "ROWS", "S3",
"SAMPLE", "SCHEDULE", "SCHEDULER", "SCHEMA", "SCHEMAS", "SECOND", "SELECT",
"SEMI", "SERIALIZABLE", "SESSION", "SESSION_USER", "SET", "SETS", "SET_SESSION_VARIABLE",
"SHAPE", "SHOW", "SIGNED", "SKEW", "SMALLINT", "SNAPSHOT", "SNAPSHOTS",
"SONAME", "SPLIT", "SQL_BLOCK_RULE", "STAGE", "STAGES", "START", "STARTS",
"STATS", "STATUS", "STOP", "STORAGE", "STREAM", "STREAMING", "STRING",
"STRUCT", "SUM", "SUPERUSER", "SWITCH", "SYNC", "SYSTEM", "TABLE", "TABLES",
"TABLESAMPLE", "TABLET", "TABLETS", "TAG", "TASK", "TASKS", "TEMPORARY",
"TERMINATED", "TEXT", "THAN", "THEN", "TIME", "TIMESTAMP", "TINYINT",
"TO", "TOKENIZER", "TOKEN_FILTER", "TRANSACTION", "TRASH", "TREE", "TRIGGERS",
"TRIM", "TRUE", "TRUNCATE", "TYPE", "TYPECAST", "TYPES", "UNBOUNDED",
"UNCOMMITTED", "UNINSTALL", "UNION", "UNIQUE", "UNLOCK", "UNSET", "UNSIGNED",
"UP", "UPDATE", "USE", "USER", "USING", "VALUE", "VALUES", "VARCHAR",
"VARIABLE", "VARIABLES", "VARIANT", "VAULT", "VAULTS", "VERBOSE", "VERSION",
"VIEW", "VIEWS", "WARM", "WARNINGS", "WEEK", "WHEN", "WHERE", "WHITELIST",
"WITH", "WORK", "WORKLOAD", "WRITE", "XOR", "YEAR", "EQ", "NSEQ", "NEQ",
"LT", "LTE", "GT", "GTE", "PLUS", "SUBTRACT", "ASTERISK", "SLASH", "MOD",
"TILDE", "AMPERSAND", "LOGICALAND", "LOGICALNOT", "PIPE", "DOUBLEPIPES",
"HAT", "COLON", "ARROW", "HINT_START", "HINT_END", "COMMENT_START", "ATSIGN",
"DOUBLEATSIGN", "STRING_LITERAL", "LEADING_STRING", "BIGINT_LITERAL",
"SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", "EXPONENT_VALUE",
"DECIMAL_VALUE", "BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER",
"SIMPLE_COMMENT", "BRACKETED_COMMENT", "FROM_DUAL", "WS", "UNRECOGNIZED"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "PLParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public boolean doris_legacy_SQL_syntax = true;
public PLParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class ProgramContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode EOF() { return getToken(PLParser.EOF, 0); }
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitProgram(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitProgram(this);
else return visitor.visitChildren(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
try {
enterOuterAlt(_localctx, 1);
{
setState(724);
block();
setState(725);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BlockContext extends ParserRuleContext {
public List<Begin_end_blockContext> begin_end_block() {
return getRuleContexts(Begin_end_blockContext.class);
}
public Begin_end_blockContext begin_end_block(int i) {
return getRuleContext(Begin_end_blockContext.class,i);
}
public List<StmtContext> stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public List<TerminalNode> GO() { return getTokens(PLParser.GO); }
public TerminalNode GO(int i) {
return getToken(PLParser.GO, i);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBlock(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 2, RULE_block);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(734);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(729);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(727);
begin_end_block();
}
break;
case 2:
{
setState(728);
stmt();
}
break;
}
setState(732);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(731);
match(GO);
}
break;
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(736);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Begin_end_blockContext extends ParserRuleContext {
public TerminalNode BEGIN() { return getToken(PLParser.BEGIN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public Block_endContext block_end() {
return getRuleContext(Block_endContext.class,0);
}
public Declare_blockContext declare_block() {
return getRuleContext(Declare_blockContext.class,0);
}
public Exception_blockContext exception_block() {
return getRuleContext(Exception_blockContext.class,0);
}
public Begin_end_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_begin_end_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBegin_end_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBegin_end_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBegin_end_block(this);
else return visitor.visitChildren(this);
}
}
public final Begin_end_blockContext begin_end_block() throws RecognitionException {
Begin_end_blockContext _localctx = new Begin_end_blockContext(_ctx, getState());
enterRule(_localctx, 4, RULE_begin_end_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(739);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DECLARE) {
{
setState(738);
declare_block();
}
}
setState(741);
match(BEGIN);
setState(742);
block();
setState(744);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(743);
exception_block();
}
break;
}
setState(746);
block_end();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Single_block_stmtContext extends ParserRuleContext {
public TerminalNode BEGIN() { return getToken(PLParser.BEGIN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public Block_endContext block_end() {
return getRuleContext(Block_endContext.class,0);
}
public Exception_blockContext exception_block() {
return getRuleContext(Exception_blockContext.class,0);
}
public StmtContext stmt() {
return getRuleContext(StmtContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public Single_block_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_single_block_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSingle_block_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSingle_block_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSingle_block_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Single_block_stmtContext single_block_stmt() throws RecognitionException {
Single_block_stmtContext _localctx = new Single_block_stmtContext(_ctx, getState());
enterRule(_localctx, 6, RULE_single_block_stmt);
try {
setState(759);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(748);
match(BEGIN);
setState(749);
block();
setState(751);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(750);
exception_block();
}
break;
}
setState(753);
block_end();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(755);
stmt();
setState(757);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(756);
match(SEMICOLON);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Block_endContext extends ParserRuleContext {
public TerminalNode END() { return getToken(PLParser.END, 0); }
public Block_endContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block_end; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBlock_end(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBlock_end(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBlock_end(this);
else return visitor.visitChildren(this);
}
}
public final Block_endContext block_end() throws RecognitionException {
Block_endContext _localctx = new Block_endContext(_ctx, getState());
enterRule(_localctx, 8, RULE_block_end);
try {
enterOuterAlt(_localctx, 1);
{
setState(761);
if (!(!_input.LT(2).getText().equalsIgnoreCase("TRANSACTION"))) throw new FailedPredicateException(this, "!_input.LT(2).getText().equalsIgnoreCase(\"TRANSACTION\")");
setState(762);
match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Procedure_blockContext extends ParserRuleContext {
public Begin_end_blockContext begin_end_block() {
return getRuleContext(Begin_end_blockContext.class,0);
}
public List<StmtContext> stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public TerminalNode GO() { return getToken(PLParser.GO, 0); }
public Procedure_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_procedure_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterProcedure_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitProcedure_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitProcedure_block(this);
else return visitor.visitChildren(this);
}
}
public final Procedure_blockContext procedure_block() throws RecognitionException {
Procedure_blockContext _localctx = new Procedure_blockContext(_ctx, getState());
enterRule(_localctx, 10, RULE_procedure_block);
try {
int _alt;
setState(773);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(764);
begin_end_block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(766);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(765);
stmt();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(768);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(771);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(770);
match(GO);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Doris_statementContext extends ParserRuleContext {
public StatementBaseContext statementBase() {
return getRuleContext(StatementBaseContext.class,0);
}
public Doris_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doris_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDoris_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDoris_statement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDoris_statement(this);
else return visitor.visitChildren(this);
}
}
public final Doris_statementContext doris_statement() throws RecognitionException {
Doris_statementContext _localctx = new Doris_statementContext(_ctx, getState());
enterRule(_localctx, 12, RULE_doris_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(775);
statementBase();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StmtContext extends ParserRuleContext {
public Doris_statementContext doris_statement() {
return getRuleContext(Doris_statementContext.class,0);
}
public Assignment_stmtContext assignment_stmt() {
return getRuleContext(Assignment_stmtContext.class,0);
}
public Allocate_cursor_stmtContext allocate_cursor_stmt() {
return getRuleContext(Allocate_cursor_stmtContext.class,0);
}
public Associate_locator_stmtContext associate_locator_stmt() {
return getRuleContext(Associate_locator_stmtContext.class,0);
}
public Break_stmtContext break_stmt() {
return getRuleContext(Break_stmtContext.class,0);
}
public Call_stmtContext call_stmt() {
return getRuleContext(Call_stmtContext.class,0);
}
public Close_stmtContext close_stmt() {
return getRuleContext(Close_stmtContext.class,0);
}
public Create_function_stmtContext create_function_stmt() {
return getRuleContext(Create_function_stmtContext.class,0);
}
public Create_package_stmtContext create_package_stmt() {
return getRuleContext(Create_package_stmtContext.class,0);
}
public Create_package_body_stmtContext create_package_body_stmt() {
return getRuleContext(Create_package_body_stmtContext.class,0);
}
public Create_procedure_stmtContext create_procedure_stmt() {
return getRuleContext(Create_procedure_stmtContext.class,0);
}
public Declare_stmtContext declare_stmt() {
return getRuleContext(Declare_stmtContext.class,0);
}
public Drop_procedure_stmtContext drop_procedure_stmt() {
return getRuleContext(Drop_procedure_stmtContext.class,0);
}
public Show_procedure_stmtContext show_procedure_stmt() {
return getRuleContext(Show_procedure_stmtContext.class,0);
}
public Show_create_procedure_stmtContext show_create_procedure_stmt() {
return getRuleContext(Show_create_procedure_stmtContext.class,0);
}
public Show_config_stmtContext show_config_stmt() {
return getRuleContext(Show_config_stmtContext.class,0);
}
public Exec_stmtContext exec_stmt() {
return getRuleContext(Exec_stmtContext.class,0);
}
public Exit_stmtContext exit_stmt() {
return getRuleContext(Exit_stmtContext.class,0);
}
public Fetch_stmtContext fetch_stmt() {
return getRuleContext(Fetch_stmtContext.class,0);
}
public For_cursor_stmtContext for_cursor_stmt() {
return getRuleContext(For_cursor_stmtContext.class,0);
}
public For_range_stmtContext for_range_stmt() {
return getRuleContext(For_range_stmtContext.class,0);
}
public If_stmtContext if_stmt() {
return getRuleContext(If_stmtContext.class,0);
}
public Include_stmtContext include_stmt() {
return getRuleContext(Include_stmtContext.class,0);
}
public Get_diag_stmtContext get_diag_stmt() {
return getRuleContext(Get_diag_stmtContext.class,0);
}
public Leave_stmtContext leave_stmt() {
return getRuleContext(Leave_stmtContext.class,0);
}
public Map_object_stmtContext map_object_stmt() {
return getRuleContext(Map_object_stmtContext.class,0);
}
public Open_stmtContext open_stmt() {
return getRuleContext(Open_stmtContext.class,0);
}
public Print_stmtContext print_stmt() {
return getRuleContext(Print_stmtContext.class,0);
}
public Quit_stmtContext quit_stmt() {
return getRuleContext(Quit_stmtContext.class,0);
}
public Raise_stmtContext raise_stmt() {
return getRuleContext(Raise_stmtContext.class,0);
}
public Resignal_stmtContext resignal_stmt() {
return getRuleContext(Resignal_stmtContext.class,0);
}
public Return_stmtContext return_stmt() {
return getRuleContext(Return_stmtContext.class,0);
}
public Signal_stmtContext signal_stmt() {
return getRuleContext(Signal_stmtContext.class,0);
}
public Values_into_stmtContext values_into_stmt() {
return getRuleContext(Values_into_stmtContext.class,0);
}
public While_stmtContext while_stmt() {
return getRuleContext(While_stmtContext.class,0);
}
public Unconditional_loop_stmtContext unconditional_loop_stmt() {
return getRuleContext(Unconditional_loop_stmtContext.class,0);
}
public Label_stmtContext label_stmt() {
return getRuleContext(Label_stmtContext.class,0);
}
public Host_plContext host_pl() {
return getRuleContext(Host_plContext.class,0);
}
public Null_stmtContext null_stmt() {
return getRuleContext(Null_stmtContext.class,0);
}
public Expr_stmtContext expr_stmt() {
return getRuleContext(Expr_stmtContext.class,0);
}
public Semicolon_stmtContext semicolon_stmt() {
return getRuleContext(Semicolon_stmtContext.class,0);
}
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStmt(this);
else return visitor.visitChildren(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 14, RULE_stmt);
try {
setState(818);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(777);
doris_statement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(778);
assignment_stmt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(779);
allocate_cursor_stmt();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(780);
associate_locator_stmt();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(781);
break_stmt();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(782);
call_stmt();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(783);
close_stmt();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(784);
create_function_stmt();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(785);
create_package_stmt();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(786);
create_package_body_stmt();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(787);
create_procedure_stmt();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(788);
declare_stmt();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(789);
drop_procedure_stmt();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(790);
show_procedure_stmt();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(791);
show_create_procedure_stmt();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(792);
show_config_stmt();
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(793);
exec_stmt();
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(794);
exit_stmt();
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(795);
fetch_stmt();
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(796);
for_cursor_stmt();
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(797);
for_range_stmt();
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(798);
if_stmt();
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(799);
include_stmt();
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(800);
get_diag_stmt();
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(801);
leave_stmt();
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(802);
map_object_stmt();
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(803);
open_stmt();
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(804);
print_stmt();
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(805);
quit_stmt();
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(806);
raise_stmt();
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(807);
resignal_stmt();
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(808);
return_stmt();
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(809);
signal_stmt();
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(810);
values_into_stmt();
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(811);
while_stmt();
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(812);
unconditional_loop_stmt();
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(813);
label_stmt();
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(814);
host_pl();
}
break;
case 39:
enterOuterAlt(_localctx, 39);
{
setState(815);
null_stmt();
}
break;
case 40:
enterOuterAlt(_localctx, 40);
{
setState(816);
expr_stmt();
}
break;
case 41:
enterOuterAlt(_localctx, 41);
{
setState(817);
semicolon_stmt();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Semicolon_stmtContext extends ParserRuleContext {
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public TerminalNode SLASH() { return getToken(PLParser.SLASH, 0); }
public Semicolon_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_semicolon_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSemicolon_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSemicolon_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSemicolon_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Semicolon_stmtContext semicolon_stmt() throws RecognitionException {
Semicolon_stmtContext _localctx = new Semicolon_stmtContext(_ctx, getState());
enterRule(_localctx, 16, RULE_semicolon_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(820);
_la = _input.LA(1);
if ( !(_la==SEMICOLON || _la==SLASH || _la==ATSIGN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Exception_blockContext extends ParserRuleContext {
public TerminalNode EXCEPTION() { return getToken(PLParser.EXCEPTION, 0); }
public List<Exception_block_itemContext> exception_block_item() {
return getRuleContexts(Exception_block_itemContext.class);
}
public Exception_block_itemContext exception_block_item(int i) {
return getRuleContext(Exception_block_itemContext.class,i);
}
public Exception_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exception_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterException_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitException_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitException_block(this);
else return visitor.visitChildren(this);
}
}
public final Exception_blockContext exception_block() throws RecognitionException {
Exception_blockContext _localctx = new Exception_blockContext(_ctx, getState());
enterRule(_localctx, 18, RULE_exception_block);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(822);
match(EXCEPTION);
setState(824);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(823);
exception_block_item();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(826);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Exception_block_itemContext extends ParserRuleContext {
public List<TerminalNode> WHEN() { return getTokens(PLParser.WHEN); }
public TerminalNode WHEN(int i) {
return getToken(PLParser.WHEN, i);
}
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public Exception_block_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exception_block_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterException_block_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitException_block_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitException_block_item(this);
else return visitor.visitChildren(this);
}
}
public final Exception_block_itemContext exception_block_item() throws RecognitionException {
Exception_block_itemContext _localctx = new Exception_block_itemContext(_ctx, getState());
enterRule(_localctx, 20, RULE_exception_block_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(828);
match(WHEN);
setState(829);
match(IDENTIFIER);
setState(830);
match(THEN);
setState(831);
block();
setState(832);
_la = _input.LA(1);
if ( _la <= 0 || (_la==END || _la==WHEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Null_stmtContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public Null_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_null_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNull_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNull_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNull_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Null_stmtContext null_stmt() throws RecognitionException {
Null_stmtContext _localctx = new Null_stmtContext(_ctx, getState());
enterRule(_localctx, 22, RULE_null_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(834);
match(NULL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_stmtContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Expr_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Expr_stmtContext expr_stmt() throws RecognitionException {
Expr_stmtContext _localctx = new Expr_stmtContext(_ctx, getState());
enterRule(_localctx, 24, RULE_expr_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(836);
if (!(!_input.LT(1).getText().equalsIgnoreCase("GO"))) throw new FailedPredicateException(this, "!_input.LT(1).getText().equalsIgnoreCase(\"GO\")");
setState(837);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmtContext extends ParserRuleContext {
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public Set_session_optionContext set_session_option() {
return getRuleContext(Set_session_optionContext.class,0);
}
public List<Assignment_stmt_itemContext> assignment_stmt_item() {
return getRuleContexts(Assignment_stmt_itemContext.class);
}
public Assignment_stmt_itemContext assignment_stmt_item(int i) {
return getRuleContext(Assignment_stmt_itemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Assignment_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmtContext assignment_stmt() throws RecognitionException {
Assignment_stmtContext _localctx = new Assignment_stmtContext(_ctx, getState());
enterRule(_localctx, 26, RULE_assignment_stmt);
int _la;
try {
int _alt;
setState(852);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(839);
match(SET);
setState(840);
set_session_option();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SET) {
{
setState(841);
match(SET);
}
}
setState(844);
assignment_stmt_item();
setState(849);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(845);
match(COMMA);
setState(846);
assignment_stmt_item();
}
}
}
setState(851);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmt_itemContext extends ParserRuleContext {
public Assignment_stmt_single_itemContext assignment_stmt_single_item() {
return getRuleContext(Assignment_stmt_single_itemContext.class,0);
}
public Assignment_stmt_multiple_itemContext assignment_stmt_multiple_item() {
return getRuleContext(Assignment_stmt_multiple_itemContext.class,0);
}
public Assignment_stmt_select_itemContext assignment_stmt_select_item() {
return getRuleContext(Assignment_stmt_select_itemContext.class,0);
}
public Assignment_stmt_collection_itemContext assignment_stmt_collection_item() {
return getRuleContext(Assignment_stmt_collection_itemContext.class,0);
}
public Assignment_stmt_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt_item(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmt_itemContext assignment_stmt_item() throws RecognitionException {
Assignment_stmt_itemContext _localctx = new Assignment_stmt_itemContext(_ctx, getState());
enterRule(_localctx, 28, RULE_assignment_stmt_item);
try {
setState(858);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(854);
assignment_stmt_single_item();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(855);
assignment_stmt_multiple_item();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(856);
assignment_stmt_select_item();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(857);
assignment_stmt_collection_item();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmt_single_itemContext extends ParserRuleContext {
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Assignment_stmt_single_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt_single_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt_single_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt_single_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt_single_item(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmt_single_itemContext assignment_stmt_single_item() throws RecognitionException {
Assignment_stmt_single_itemContext _localctx = new Assignment_stmt_single_itemContext(_ctx, getState());
enterRule(_localctx, 30, RULE_assignment_stmt_single_item);
int _la;
try {
setState(876);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(860);
ident_pl();
setState(862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(861);
match(COLON);
}
}
setState(864);
match(EQ);
setState(865);
expr(0);
}
break;
case LEFT_PAREN:
enterOuterAlt(_localctx, 2);
{
setState(867);
match(LEFT_PAREN);
setState(868);
ident_pl();
setState(869);
match(RIGHT_PAREN);
setState(871);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(870);
match(COLON);
}
}
setState(873);
match(EQ);
setState(874);
expr(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmt_collection_itemContext extends ParserRuleContext {
public Expr_funcContext expr_func() {
return getRuleContext(Expr_funcContext.class,0);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Assignment_stmt_collection_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt_collection_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt_collection_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt_collection_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt_collection_item(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmt_collection_itemContext assignment_stmt_collection_item() throws RecognitionException {
Assignment_stmt_collection_itemContext _localctx = new Assignment_stmt_collection_itemContext(_ctx, getState());
enterRule(_localctx, 32, RULE_assignment_stmt_collection_item);
try {
enterOuterAlt(_localctx, 1);
{
setState(878);
expr_func();
setState(879);
match(COLON);
setState(880);
match(EQ);
setState(881);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmt_multiple_itemContext extends ParserRuleContext {
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public Assignment_stmt_multiple_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt_multiple_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt_multiple_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt_multiple_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt_multiple_item(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmt_multiple_itemContext assignment_stmt_multiple_item() throws RecognitionException {
Assignment_stmt_multiple_itemContext _localctx = new Assignment_stmt_multiple_itemContext(_ctx, getState());
enterRule(_localctx, 34, RULE_assignment_stmt_multiple_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(883);
match(LEFT_PAREN);
setState(884);
ident_pl();
setState(889);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(885);
match(COMMA);
setState(886);
ident_pl();
}
}
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(892);
match(RIGHT_PAREN);
setState(894);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(893);
match(COLON);
}
}
setState(896);
match(EQ);
setState(897);
match(LEFT_PAREN);
setState(898);
expr(0);
setState(903);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(899);
match(COMMA);
setState(900);
expr(0);
}
}
setState(905);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(906);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assignment_stmt_select_itemContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Assignment_stmt_select_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_stmt_select_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssignment_stmt_select_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssignment_stmt_select_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssignment_stmt_select_item(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_stmt_select_itemContext assignment_stmt_select_item() throws RecognitionException {
Assignment_stmt_select_itemContext _localctx = new Assignment_stmt_select_itemContext(_ctx, getState());
enterRule(_localctx, 36, RULE_assignment_stmt_select_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(920);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
{
setState(908);
ident_pl();
}
break;
case LEFT_PAREN:
{
{
setState(909);
match(LEFT_PAREN);
setState(910);
ident_pl();
setState(915);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(911);
match(COMMA);
setState(912);
ident_pl();
}
}
setState(917);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(918);
match(RIGHT_PAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(923);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(922);
match(COLON);
}
}
setState(925);
match(EQ);
setState(926);
match(LEFT_PAREN);
setState(927);
query();
setState(928);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Allocate_cursor_stmtContext extends ParserRuleContext {
public TerminalNode ALLOCATE() { return getToken(PLParser.ALLOCATE, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode CURSOR() { return getToken(PLParser.CURSOR, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode RESULT() { return getToken(PLParser.RESULT, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public Allocate_cursor_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_allocate_cursor_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAllocate_cursor_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAllocate_cursor_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAllocate_cursor_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Allocate_cursor_stmtContext allocate_cursor_stmt() throws RecognitionException {
Allocate_cursor_stmtContext _localctx = new Allocate_cursor_stmtContext(_ctx, getState());
enterRule(_localctx, 38, RULE_allocate_cursor_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(930);
match(ALLOCATE);
setState(931);
ident_pl();
setState(932);
match(CURSOR);
setState(933);
match(FOR);
setState(937);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RESULT:
{
{
setState(934);
match(RESULT);
setState(935);
match(SET);
}
}
break;
case PROCEDURE:
{
setState(936);
match(PROCEDURE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(939);
ident_pl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Associate_locator_stmtContext extends ParserRuleContext {
public TerminalNode ASSOCIATE() { return getToken(PLParser.ASSOCIATE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode LOCATOR() { return getToken(PLParser.LOCATOR, 0); }
public TerminalNode LOCATORS() { return getToken(PLParser.LOCATORS, 0); }
public TerminalNode RESULT() { return getToken(PLParser.RESULT, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Associate_locator_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_associate_locator_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAssociate_locator_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAssociate_locator_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAssociate_locator_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Associate_locator_stmtContext associate_locator_stmt() throws RecognitionException {
Associate_locator_stmtContext _localctx = new Associate_locator_stmtContext(_ctx, getState());
enterRule(_localctx, 40, RULE_associate_locator_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(941);
match(ASSOCIATE);
setState(944);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RESULT) {
{
setState(942);
match(RESULT);
setState(943);
match(SET);
}
}
setState(946);
_la = _input.LA(1);
if ( !(_la==LOCATOR || _la==LOCATORS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(947);
match(LEFT_PAREN);
setState(948);
ident_pl();
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(949);
match(COMMA);
setState(950);
ident_pl();
}
}
setState(955);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(956);
match(RIGHT_PAREN);
setState(957);
match(WITH);
setState(958);
match(PROCEDURE);
setState(959);
ident_pl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Break_stmtContext extends ParserRuleContext {
public TerminalNode BREAK() { return getToken(PLParser.BREAK, 0); }
public Break_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_break_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBreak_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBreak_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBreak_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Break_stmtContext break_stmt() throws RecognitionException {
Break_stmtContext _localctx = new Break_stmtContext(_ctx, getState());
enterRule(_localctx, 42, RULE_break_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(961);
match(BREAK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Call_stmtContext extends ParserRuleContext {
public TerminalNode CALL() { return getToken(PLParser.CALL, 0); }
public Expr_dotContext expr_dot() {
return getRuleContext(Expr_dotContext.class,0);
}
public Expr_funcContext expr_func() {
return getRuleContext(Expr_funcContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Call_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_call_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCall_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCall_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCall_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Call_stmtContext call_stmt() throws RecognitionException {
Call_stmtContext _localctx = new Call_stmtContext(_ctx, getState());
enterRule(_localctx, 44, RULE_call_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(963);
match(CALL);
setState(967);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(964);
expr_dot();
}
break;
case 2:
{
setState(965);
expr_func();
}
break;
case 3:
{
setState(966);
multipartIdentifier();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_stmtContext extends ParserRuleContext {
public TerminalNode DECLARE() { return getToken(PLParser.DECLARE, 0); }
public List<Declare_stmt_itemContext> declare_stmt_item() {
return getRuleContexts(Declare_stmt_itemContext.class);
}
public Declare_stmt_itemContext declare_stmt_item(int i) {
return getRuleContext(Declare_stmt_itemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Declare_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Declare_stmtContext declare_stmt() throws RecognitionException {
Declare_stmtContext _localctx = new Declare_stmtContext(_ctx, getState());
enterRule(_localctx, 46, RULE_declare_stmt);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(969);
match(DECLARE);
setState(970);
declare_stmt_item();
setState(975);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(971);
match(COMMA);
setState(972);
declare_stmt_item();
}
}
}
setState(977);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_blockContext extends ParserRuleContext {
public TerminalNode DECLARE() { return getToken(PLParser.DECLARE, 0); }
public List<Declare_stmt_itemContext> declare_stmt_item() {
return getRuleContexts(Declare_stmt_itemContext.class);
}
public Declare_stmt_itemContext declare_stmt_item(int i) {
return getRuleContext(Declare_stmt_itemContext.class,i);
}
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public Declare_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_block(this);
else return visitor.visitChildren(this);
}
}
public final Declare_blockContext declare_block() throws RecognitionException {
Declare_blockContext _localctx = new Declare_blockContext(_ctx, getState());
enterRule(_localctx, 48, RULE_declare_block);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(978);
match(DECLARE);
setState(979);
declare_stmt_item();
setState(980);
match(SEMICOLON);
setState(986);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(981);
declare_stmt_item();
setState(982);
match(SEMICOLON);
}
}
}
setState(988);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_block_inplaceContext extends ParserRuleContext {
public List<Declare_stmt_itemContext> declare_stmt_item() {
return getRuleContexts(Declare_stmt_itemContext.class);
}
public Declare_stmt_itemContext declare_stmt_item(int i) {
return getRuleContext(Declare_stmt_itemContext.class,i);
}
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public Declare_block_inplaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_block_inplace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_block_inplace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_block_inplace(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_block_inplace(this);
else return visitor.visitChildren(this);
}
}
public final Declare_block_inplaceContext declare_block_inplace() throws RecognitionException {
Declare_block_inplaceContext _localctx = new Declare_block_inplaceContext(_ctx, getState());
enterRule(_localctx, 50, RULE_declare_block_inplace);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(989);
declare_stmt_item();
setState(990);
match(SEMICOLON);
setState(996);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(991);
declare_stmt_item();
setState(992);
match(SEMICOLON);
}
}
}
setState(998);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_stmt_itemContext extends ParserRuleContext {
public Declare_cursor_itemContext declare_cursor_item() {
return getRuleContext(Declare_cursor_itemContext.class,0);
}
public Declare_condition_itemContext declare_condition_item() {
return getRuleContext(Declare_condition_itemContext.class,0);
}
public Declare_handler_itemContext declare_handler_item() {
return getRuleContext(Declare_handler_itemContext.class,0);
}
public Declare_var_itemContext declare_var_item() {
return getRuleContext(Declare_var_itemContext.class,0);
}
public Declare_stmt_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_stmt_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_stmt_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_stmt_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_stmt_item(this);
else return visitor.visitChildren(this);
}
}
public final Declare_stmt_itemContext declare_stmt_item() throws RecognitionException {
Declare_stmt_itemContext _localctx = new Declare_stmt_itemContext(_ctx, getState());
enterRule(_localctx, 52, RULE_declare_stmt_item);
try {
setState(1003);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(999);
declare_cursor_item();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1000);
declare_condition_item();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1001);
declare_handler_item();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1002);
declare_var_item();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_var_itemContext extends ParserRuleContext {
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public DtypeContext dtype() {
return getRuleContext(DtypeContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public Dtype_lenContext dtype_len() {
return getRuleContext(Dtype_lenContext.class,0);
}
public List<Dtype_attrContext> dtype_attr() {
return getRuleContexts(Dtype_attrContext.class);
}
public Dtype_attrContext dtype_attr(int i) {
return getRuleContext(Dtype_attrContext.class,i);
}
public Dtype_defaultContext dtype_default() {
return getRuleContext(Dtype_defaultContext.class,0);
}
public TerminalNode CONSTANT() { return getToken(PLParser.CONSTANT, 0); }
public Declare_var_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_var_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_var_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_var_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_var_item(this);
else return visitor.visitChildren(this);
}
}
public final Declare_var_itemContext declare_var_item() throws RecognitionException {
Declare_var_itemContext _localctx = new Declare_var_itemContext(_ctx, getState());
enterRule(_localctx, 54, RULE_declare_var_item);
int _la;
try {
int _alt;
setState(1040);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1005);
ident_pl();
setState(1010);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1006);
match(COMMA);
setState(1007);
ident_pl();
}
}
setState(1012);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1014);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1013);
match(AS);
}
}
setState(1016);
dtype();
setState(1018);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(1017);
dtype_len();
}
break;
}
setState(1023);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1020);
dtype_attr();
}
}
}
setState(1025);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
}
setState(1027);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(1026);
dtype_default();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1029);
ident_pl();
setState(1030);
match(CONSTANT);
setState(1032);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1031);
match(AS);
}
}
setState(1034);
dtype();
setState(1036);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(1035);
dtype_len();
}
}
setState(1038);
dtype_default();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_condition_itemContext extends ParserRuleContext {
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode CONDITION() { return getToken(PLParser.CONDITION, 0); }
public Declare_condition_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_condition_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_condition_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_condition_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_condition_item(this);
else return visitor.visitChildren(this);
}
}
public final Declare_condition_itemContext declare_condition_item() throws RecognitionException {
Declare_condition_itemContext _localctx = new Declare_condition_itemContext(_ctx, getState());
enterRule(_localctx, 56, RULE_declare_condition_item);
try {
enterOuterAlt(_localctx, 1);
{
setState(1042);
ident_pl();
setState(1043);
match(CONDITION);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_cursor_itemContext extends ParserRuleContext {
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode CURSOR() { return getToken(PLParser.CURSOR, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Cursor_with_returnContext cursor_with_return() {
return getRuleContext(Cursor_with_returnContext.class,0);
}
public Cursor_without_returnContext cursor_without_return() {
return getRuleContext(Cursor_without_returnContext.class,0);
}
public Declare_cursor_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_cursor_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_cursor_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_cursor_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_cursor_item(this);
else return visitor.visitChildren(this);
}
}
public final Declare_cursor_itemContext declare_cursor_item() throws RecognitionException {
Declare_cursor_itemContext _localctx = new Declare_cursor_itemContext(_ctx, getState());
enterRule(_localctx, 58, RULE_declare_cursor_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1050);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(1045);
match(CURSOR);
setState(1046);
ident_pl();
}
break;
case 2:
{
setState(1047);
ident_pl();
setState(1048);
match(CURSOR);
}
break;
}
setState(1054);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WITH:
{
setState(1052);
cursor_with_return();
}
break;
case WITHOUT:
{
setState(1053);
cursor_without_return();
}
break;
case AS:
case FOR:
case IS:
break;
default:
break;
}
setState(1056);
_la = _input.LA(1);
if ( !(_la==AS || _la==FOR || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1059);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(1057);
query();
}
break;
case 2:
{
setState(1058);
expr(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Cursor_with_returnContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode RETURN() { return getToken(PLParser.RETURN, 0); }
public TerminalNode ONLY() { return getToken(PLParser.ONLY, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode CALLER() { return getToken(PLParser.CALLER, 0); }
public TerminalNode CLIENT() { return getToken(PLParser.CLIENT, 0); }
public Cursor_with_returnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cursor_with_return; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCursor_with_return(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCursor_with_return(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCursor_with_return(this);
else return visitor.visitChildren(this);
}
}
public final Cursor_with_returnContext cursor_with_return() throws RecognitionException {
Cursor_with_returnContext _localctx = new Cursor_with_returnContext(_ctx, getState());
enterRule(_localctx, 60, RULE_cursor_with_return);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1061);
match(WITH);
setState(1062);
match(RETURN);
setState(1064);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ONLY) {
{
setState(1063);
match(ONLY);
}
}
setState(1068);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TO) {
{
setState(1066);
match(TO);
setState(1067);
_la = _input.LA(1);
if ( !(_la==CALLER || _la==CLIENT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Cursor_without_returnContext extends ParserRuleContext {
public TerminalNode WITHOUT() { return getToken(PLParser.WITHOUT, 0); }
public TerminalNode RETURN() { return getToken(PLParser.RETURN, 0); }
public Cursor_without_returnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cursor_without_return; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCursor_without_return(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCursor_without_return(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCursor_without_return(this);
else return visitor.visitChildren(this);
}
}
public final Cursor_without_returnContext cursor_without_return() throws RecognitionException {
Cursor_without_returnContext _localctx = new Cursor_without_returnContext(_ctx, getState());
enterRule(_localctx, 62, RULE_cursor_without_return);
try {
enterOuterAlt(_localctx, 1);
{
setState(1070);
match(WITHOUT);
setState(1071);
match(RETURN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Declare_handler_itemContext extends ParserRuleContext {
public TerminalNode HANDLER() { return getToken(PLParser.HANDLER, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public Single_block_stmtContext single_block_stmt() {
return getRuleContext(Single_block_stmtContext.class,0);
}
public TerminalNode CONTINUE() { return getToken(PLParser.CONTINUE, 0); }
public TerminalNode EXIT() { return getToken(PLParser.EXIT, 0); }
public TerminalNode SQLEXCEPTION() { return getToken(PLParser.SQLEXCEPTION, 0); }
public TerminalNode SQLWARNING() { return getToken(PLParser.SQLWARNING, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode FOUND() { return getToken(PLParser.FOUND, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public Declare_handler_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declare_handler_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeclare_handler_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeclare_handler_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeclare_handler_item(this);
else return visitor.visitChildren(this);
}
}
public final Declare_handler_itemContext declare_handler_item() throws RecognitionException {
Declare_handler_itemContext _localctx = new Declare_handler_itemContext(_ctx, getState());
enterRule(_localctx, 64, RULE_declare_handler_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1073);
_la = _input.LA(1);
if ( !(_la==CONTINUE || _la==EXIT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1074);
match(HANDLER);
setState(1075);
match(FOR);
setState(1081);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
{
setState(1076);
match(SQLEXCEPTION);
}
break;
case 2:
{
setState(1077);
match(SQLWARNING);
}
break;
case 3:
{
setState(1078);
match(NOT);
setState(1079);
match(FOUND);
}
break;
case 4:
{
setState(1080);
ident_pl();
}
break;
}
setState(1083);
single_block_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DtypeContext extends ParserRuleContext {
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode BIGINT() { return getToken(PLParser.BIGINT, 0); }
public TerminalNode BINARY_DOUBLE() { return getToken(PLParser.BINARY_DOUBLE, 0); }
public TerminalNode BINARY_FLOAT() { return getToken(PLParser.BINARY_FLOAT, 0); }
public TerminalNode BINARY_INTEGER() { return getToken(PLParser.BINARY_INTEGER, 0); }
public TerminalNode BIT() { return getToken(PLParser.BIT, 0); }
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode DATETIME() { return getToken(PLParser.DATETIME, 0); }
public TerminalNode DEC() { return getToken(PLParser.DEC, 0); }
public TerminalNode DECIMAL() { return getToken(PLParser.DECIMAL, 0); }
public TerminalNode DOUBLE() { return getToken(PLParser.DOUBLE, 0); }
public TerminalNode PRECISION() { return getToken(PLParser.PRECISION, 0); }
public TerminalNode FLOAT() { return getToken(PLParser.FLOAT, 0); }
public TerminalNode INT() { return getToken(PLParser.INT, 0); }
public TerminalNode INT2() { return getToken(PLParser.INT2, 0); }
public TerminalNode INT4() { return getToken(PLParser.INT4, 0); }
public TerminalNode INT8() { return getToken(PLParser.INT8, 0); }
public TerminalNode INTEGER() { return getToken(PLParser.INTEGER, 0); }
public TerminalNode NCHAR() { return getToken(PLParser.NCHAR, 0); }
public TerminalNode NVARCHAR() { return getToken(PLParser.NVARCHAR, 0); }
public TerminalNode NUMBER() { return getToken(PLParser.NUMBER, 0); }
public TerminalNode NUMERIC() { return getToken(PLParser.NUMERIC, 0); }
public TerminalNode PLS_INTEGER() { return getToken(PLParser.PLS_INTEGER, 0); }
public TerminalNode REAL() { return getToken(PLParser.REAL, 0); }
public TerminalNode RESULT_SET_LOCATOR() { return getToken(PLParser.RESULT_SET_LOCATOR, 0); }
public TerminalNode VARYING() { return getToken(PLParser.VARYING, 0); }
public TerminalNode SIMPLE_FLOAT() { return getToken(PLParser.SIMPLE_FLOAT, 0); }
public TerminalNode SIMPLE_DOUBLE() { return getToken(PLParser.SIMPLE_DOUBLE, 0); }
public TerminalNode SIMPLE_INTEGER() { return getToken(PLParser.SIMPLE_INTEGER, 0); }
public TerminalNode SMALLINT() { return getToken(PLParser.SMALLINT, 0); }
public TerminalNode SMALLDATETIME() { return getToken(PLParser.SMALLDATETIME, 0); }
public TerminalNode STRING() { return getToken(PLParser.STRING, 0); }
public TerminalNode SYS_REFCURSOR() { return getToken(PLParser.SYS_REFCURSOR, 0); }
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public TerminalNode TINYINT() { return getToken(PLParser.TINYINT, 0); }
public TerminalNode VARCHAR() { return getToken(PLParser.VARCHAR, 0); }
public TerminalNode VARCHAR2() { return getToken(PLParser.VARCHAR2, 0); }
public TerminalNode XML() { return getToken(PLParser.XML, 0); }
public QidentContext qident() {
return getRuleContext(QidentContext.class,0);
}
public TerminalNode MOD() { return getToken(PLParser.MOD, 0); }
public TerminalNode TYPE() { return getToken(PLParser.TYPE, 0); }
public TerminalNode ROWTYPE() { return getToken(PLParser.ROWTYPE, 0); }
public DtypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dtype; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDtype(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDtype(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDtype(this);
else return visitor.visitChildren(this);
}
}
public final DtypeContext dtype() throws RecognitionException {
DtypeContext _localctx = new DtypeContext(_ctx, getState());
enterRule(_localctx, 66, RULE_dtype);
int _la;
try {
setState(1130);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1085);
match(CHAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1086);
match(BIGINT);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1087);
match(BINARY_DOUBLE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1088);
match(BINARY_FLOAT);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1089);
match(BINARY_INTEGER);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1090);
match(BIT);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1091);
match(DATE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1092);
match(DATETIME);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1093);
match(DEC);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1094);
match(DECIMAL);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1095);
match(DOUBLE);
setState(1097);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(1096);
match(PRECISION);
}
break;
}
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1099);
match(FLOAT);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(1100);
match(INT);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(1101);
match(INT2);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(1102);
match(INT4);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(1103);
match(INT8);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(1104);
match(INTEGER);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(1105);
match(NCHAR);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(1106);
match(NVARCHAR);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(1107);
match(NUMBER);
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(1108);
match(NUMERIC);
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(1109);
match(PLS_INTEGER);
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(1110);
match(REAL);
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(1111);
match(RESULT_SET_LOCATOR);
setState(1112);
match(VARYING);
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(1113);
match(SIMPLE_FLOAT);
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(1114);
match(SIMPLE_DOUBLE);
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(1115);
match(SIMPLE_INTEGER);
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(1116);
match(SMALLINT);
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(1117);
match(SMALLDATETIME);
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(1118);
match(STRING);
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(1119);
match(SYS_REFCURSOR);
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(1120);
match(TIMESTAMP);
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(1121);
match(TINYINT);
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(1122);
match(VARCHAR);
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(1123);
match(VARCHAR2);
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(1124);
match(XML);
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(1125);
qident();
setState(1128);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(1126);
match(MOD);
setState(1127);
_la = _input.LA(1);
if ( !(_la==ROWTYPE || _la==TYPE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dtype_lenContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public TerminalNode MAX() { return getToken(PLParser.MAX, 0); }
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode BYTE() { return getToken(PLParser.BYTE, 0); }
public Dtype_lenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dtype_len; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDtype_len(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDtype_len(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDtype_len(this);
else return visitor.visitChildren(this);
}
}
public final Dtype_lenContext dtype_len() throws RecognitionException {
Dtype_lenContext _localctx = new Dtype_lenContext(_ctx, getState());
enterRule(_localctx, 68, RULE_dtype_len);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1132);
match(LEFT_PAREN);
setState(1133);
_la = _input.LA(1);
if ( !(_la==MAX || _la==INTEGER_VALUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1135);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BYTE || _la==CHAR) {
{
setState(1134);
_la = _input.LA(1);
if ( !(_la==BYTE || _la==CHAR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1139);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1137);
match(COMMA);
setState(1138);
match(INTEGER_VALUE);
}
}
setState(1141);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dtype_attrContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode CASESPECIFIC() { return getToken(PLParser.CASESPECIFIC, 0); }
public TerminalNode CS() { return getToken(PLParser.CS, 0); }
public Dtype_attrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dtype_attr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDtype_attr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDtype_attr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDtype_attr(this);
else return visitor.visitChildren(this);
}
}
public final Dtype_attrContext dtype_attr() throws RecognitionException {
Dtype_attrContext _localctx = new Dtype_attrContext(_ctx, getState());
enterRule(_localctx, 70, RULE_dtype_attr);
int _la;
try {
setState(1154);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1144);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1143);
match(NOT);
}
}
setState(1146);
match(NULL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1147);
match(CHAR);
setState(1148);
match(SET);
setState(1149);
ident_pl();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1151);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1150);
match(NOT);
}
}
setState(1153);
_la = _input.LA(1);
if ( !(_la==CASESPECIFIC || _la==CS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dtype_defaultContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public Dtype_defaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dtype_default; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDtype_default(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDtype_default(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDtype_default(this);
else return visitor.visitChildren(this);
}
}
public final Dtype_defaultContext dtype_default() throws RecognitionException {
Dtype_defaultContext _localctx = new Dtype_defaultContext(_ctx, getState());
enterRule(_localctx, 72, RULE_dtype_default);
int _la;
try {
setState(1168);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EQ:
case COLON:
enterOuterAlt(_localctx, 1);
{
setState(1157);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1156);
match(COLON);
}
}
setState(1159);
match(EQ);
setState(1160);
expr(0);
}
break;
case DEFAULT:
case WITH:
enterOuterAlt(_localctx, 2);
{
setState(1162);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1161);
match(WITH);
}
}
setState(1164);
match(DEFAULT);
setState(1166);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
{
setState(1165);
expr(0);
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_function_stmtContext extends ParserRuleContext {
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Create_function_returnContext create_function_return() {
return getRuleContext(Create_function_returnContext.class,0);
}
public Single_block_stmtContext single_block_stmt() {
return getRuleContext(Single_block_stmtContext.class,0);
}
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public Create_routine_paramsContext create_routine_params() {
return getRuleContext(Create_routine_paramsContext.class,0);
}
public Declare_block_inplaceContext declare_block_inplace() {
return getRuleContext(Declare_block_inplaceContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public Create_function_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_function_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_function_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_function_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_function_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_function_stmtContext create_function_stmt() throws RecognitionException {
Create_function_stmtContext _localctx = new Create_function_stmtContext(_ctx, getState());
enterRule(_localctx, 74, RULE_create_function_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1177);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
{
setState(1170);
match(ALTER);
}
break;
case CREATE:
{
setState(1171);
match(CREATE);
setState(1174);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1172);
match(OR);
setState(1173);
match(REPLACE);
}
}
}
break;
case REPLACE:
{
setState(1176);
match(REPLACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1179);
match(FUNCTION);
setState(1180);
multipartIdentifier();
setState(1182);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(1181);
create_routine_params();
}
break;
}
setState(1184);
create_function_return();
setState(1186);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
setState(1185);
_la = _input.LA(1);
if ( !(_la==AS || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1189);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(1188);
declare_block_inplace();
}
break;
}
setState(1191);
single_block_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_function_returnContext extends ParserRuleContext {
public DtypeContext dtype() {
return getRuleContext(DtypeContext.class,0);
}
public TerminalNode RETURN() { return getToken(PLParser.RETURN, 0); }
public TerminalNode RETURNS() { return getToken(PLParser.RETURNS, 0); }
public Dtype_lenContext dtype_len() {
return getRuleContext(Dtype_lenContext.class,0);
}
public Create_function_returnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_function_return; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_function_return(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_function_return(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_function_return(this);
else return visitor.visitChildren(this);
}
}
public final Create_function_returnContext create_function_return() throws RecognitionException {
Create_function_returnContext _localctx = new Create_function_returnContext(_ctx, getState());
enterRule(_localctx, 76, RULE_create_function_return);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1193);
_la = _input.LA(1);
if ( !(_la==RETURN || _la==RETURNS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1194);
dtype();
setState(1196);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(1195);
dtype_len();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_package_stmtContext extends ParserRuleContext {
public TerminalNode PACKAGE() { return getToken(PLParser.PACKAGE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Package_specContext package_spec() {
return getRuleContext(Package_specContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public Create_package_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_package_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_package_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_package_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_package_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_package_stmtContext create_package_stmt() throws RecognitionException {
Create_package_stmtContext _localctx = new Create_package_stmtContext(_ctx, getState());
enterRule(_localctx, 78, RULE_create_package_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1205);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
{
setState(1198);
match(ALTER);
}
break;
case CREATE:
{
setState(1199);
match(CREATE);
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1200);
match(OR);
setState(1201);
match(REPLACE);
}
}
}
break;
case REPLACE:
{
setState(1204);
match(REPLACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1207);
match(PACKAGE);
setState(1208);
multipartIdentifier();
setState(1209);
_la = _input.LA(1);
if ( !(_la==AS || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1210);
package_spec();
setState(1211);
match(END);
setState(1215);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(1212);
ident_pl();
setState(1213);
match(SEMICOLON);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Package_specContext extends ParserRuleContext {
public List<Package_spec_itemContext> package_spec_item() {
return getRuleContexts(Package_spec_itemContext.class);
}
public Package_spec_itemContext package_spec_item(int i) {
return getRuleContext(Package_spec_itemContext.class,i);
}
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public Package_specContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_package_spec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPackage_spec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPackage_spec(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPackage_spec(this);
else return visitor.visitChildren(this);
}
}
public final Package_specContext package_spec() throws RecognitionException {
Package_specContext _localctx = new Package_specContext(_ctx, getState());
enterRule(_localctx, 80, RULE_package_spec);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1217);
package_spec_item();
setState(1218);
match(SEMICOLON);
setState(1224);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1219);
package_spec_item();
setState(1220);
match(SEMICOLON);
}
}
}
setState(1226);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Package_spec_itemContext extends ParserRuleContext {
public Declare_stmt_itemContext declare_stmt_item() {
return getRuleContext(Declare_stmt_itemContext.class,0);
}
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public Create_function_returnContext create_function_return() {
return getRuleContext(Create_function_returnContext.class,0);
}
public Create_routine_paramsContext create_routine_params() {
return getRuleContext(Create_routine_paramsContext.class,0);
}
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public Package_spec_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_package_spec_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPackage_spec_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPackage_spec_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPackage_spec_item(this);
else return visitor.visitChildren(this);
}
}
public final Package_spec_itemContext package_spec_item() throws RecognitionException {
Package_spec_itemContext _localctx = new Package_spec_itemContext(_ctx, getState());
enterRule(_localctx, 82, RULE_package_spec_item);
int _la;
try {
setState(1240);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1227);
declare_stmt_item();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1228);
match(FUNCTION);
setState(1229);
ident_pl();
setState(1231);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(1230);
create_routine_params();
}
break;
}
setState(1233);
create_function_return();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1235);
_la = _input.LA(1);
if ( !(_la==PROC || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1236);
ident_pl();
setState(1238);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(1237);
create_routine_params();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_package_body_stmtContext extends ParserRuleContext {
public TerminalNode PACKAGE() { return getToken(PLParser.PACKAGE, 0); }
public TerminalNode BODY() { return getToken(PLParser.BODY, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Package_bodyContext package_body() {
return getRuleContext(Package_bodyContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public Create_package_body_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_package_body_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_package_body_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_package_body_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_package_body_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_package_body_stmtContext create_package_body_stmt() throws RecognitionException {
Create_package_body_stmtContext _localctx = new Create_package_body_stmtContext(_ctx, getState());
enterRule(_localctx, 84, RULE_create_package_body_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1249);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
{
setState(1242);
match(ALTER);
}
break;
case CREATE:
{
setState(1243);
match(CREATE);
setState(1246);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1244);
match(OR);
setState(1245);
match(REPLACE);
}
}
}
break;
case REPLACE:
{
setState(1248);
match(REPLACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1251);
match(PACKAGE);
setState(1252);
match(BODY);
setState(1253);
multipartIdentifier();
setState(1254);
_la = _input.LA(1);
if ( !(_la==AS || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1255);
package_body();
setState(1256);
match(END);
setState(1260);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(1257);
ident_pl();
setState(1258);
match(SEMICOLON);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Package_bodyContext extends ParserRuleContext {
public List<Package_body_itemContext> package_body_item() {
return getRuleContexts(Package_body_itemContext.class);
}
public Package_body_itemContext package_body_item(int i) {
return getRuleContext(Package_body_itemContext.class,i);
}
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public Package_bodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_package_body; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPackage_body(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPackage_body(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPackage_body(this);
else return visitor.visitChildren(this);
}
}
public final Package_bodyContext package_body() throws RecognitionException {
Package_bodyContext _localctx = new Package_bodyContext(_ctx, getState());
enterRule(_localctx, 86, RULE_package_body);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1262);
package_body_item();
setState(1263);
match(SEMICOLON);
setState(1269);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1264);
package_body_item();
setState(1265);
match(SEMICOLON);
}
}
}
setState(1271);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Package_body_itemContext extends ParserRuleContext {
public Declare_stmt_itemContext declare_stmt_item() {
return getRuleContext(Declare_stmt_itemContext.class,0);
}
public Create_function_stmtContext create_function_stmt() {
return getRuleContext(Create_function_stmtContext.class,0);
}
public Create_procedure_stmtContext create_procedure_stmt() {
return getRuleContext(Create_procedure_stmtContext.class,0);
}
public Package_body_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_package_body_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPackage_body_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPackage_body_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPackage_body_item(this);
else return visitor.visitChildren(this);
}
}
public final Package_body_itemContext package_body_item() throws RecognitionException {
Package_body_itemContext _localctx = new Package_body_itemContext(_ctx, getState());
enterRule(_localctx, 88, RULE_package_body_item);
try {
setState(1275);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1272);
declare_stmt_item();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1273);
create_function_stmt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1274);
create_procedure_stmt();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_procedure_stmtContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Procedure_blockContext procedure_block() {
return getRuleContext(Procedure_blockContext.class,0);
}
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public Create_routine_paramsContext create_routine_params() {
return getRuleContext(Create_routine_paramsContext.class,0);
}
public Create_routine_optionsContext create_routine_options() {
return getRuleContext(Create_routine_optionsContext.class,0);
}
public Declare_block_inplaceContext declare_block_inplace() {
return getRuleContext(Declare_block_inplaceContext.class,0);
}
public Label_stmtContext label_stmt() {
return getRuleContext(Label_stmtContext.class,0);
}
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public Create_procedure_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_procedure_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_procedure_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_procedure_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_procedure_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_procedure_stmtContext create_procedure_stmt() throws RecognitionException {
Create_procedure_stmtContext _localctx = new Create_procedure_stmtContext(_ctx, getState());
enterRule(_localctx, 90, RULE_create_procedure_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1284);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
{
setState(1277);
match(ALTER);
}
break;
case CREATE:
{
setState(1278);
match(CREATE);
setState(1281);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1279);
match(OR);
setState(1280);
match(REPLACE);
}
}
}
break;
case REPLACE:
{
setState(1283);
match(REPLACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1286);
_la = _input.LA(1);
if ( !(_la==PROC || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1287);
multipartIdentifier();
setState(1289);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(1288);
create_routine_params();
}
break;
}
setState(1292);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
{
setState(1291);
create_routine_options();
}
break;
}
setState(1295);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(1294);
_la = _input.LA(1);
if ( !(_la==AS || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1298);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(1297);
declare_block_inplace();
}
break;
}
setState(1301);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(1300);
label_stmt();
}
break;
}
setState(1303);
procedure_block();
setState(1307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
{
setState(1304);
ident_pl();
setState(1305);
match(SEMICOLON);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Drop_procedure_stmtContext extends ParserRuleContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public Drop_procedure_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_procedure_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDrop_procedure_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDrop_procedure_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDrop_procedure_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_procedure_stmtContext drop_procedure_stmt() throws RecognitionException {
Drop_procedure_stmtContext _localctx = new Drop_procedure_stmtContext(_ctx, getState());
enterRule(_localctx, 92, RULE_drop_procedure_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1309);
match(DROP);
setState(1310);
_la = _input.LA(1);
if ( !(_la==PROC || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1313);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(1311);
match(IF);
setState(1312);
match(EXISTS);
}
}
setState(1315);
((Drop_procedure_stmtContext)_localctx).name = multipartIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Show_procedure_stmtContext extends ParserRuleContext {
public ValueExpressionContext pattern;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public Show_procedure_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_show_procedure_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShow_procedure_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShow_procedure_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShow_procedure_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Show_procedure_stmtContext show_procedure_stmt() throws RecognitionException {
Show_procedure_stmtContext _localctx = new Show_procedure_stmtContext(_ctx, getState());
enterRule(_localctx, 94, RULE_show_procedure_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1317);
match(SHOW);
setState(1318);
match(PROCEDURE);
setState(1319);
match(STATUS);
setState(1323);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(1320);
match(LIKE);
setState(1321);
((Show_procedure_stmtContext)_localctx).pattern = valueExpression(0);
}
break;
case 2:
{
setState(1322);
whereClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Show_create_procedure_stmtContext extends ParserRuleContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public Show_create_procedure_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_show_create_procedure_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShow_create_procedure_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShow_create_procedure_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShow_create_procedure_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Show_create_procedure_stmtContext show_create_procedure_stmt() throws RecognitionException {
Show_create_procedure_stmtContext _localctx = new Show_create_procedure_stmtContext(_ctx, getState());
enterRule(_localctx, 96, RULE_show_create_procedure_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1325);
match(SHOW);
setState(1326);
match(CREATE);
setState(1327);
match(PROCEDURE);
setState(1328);
((Show_create_procedure_stmtContext)_localctx).name = multipartIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Show_config_stmtContext extends ParserRuleContext {
public Token type;
public ValueExpressionContext pattern;
public Token backendId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CONFIG() { return getToken(PLParser.CONFIG, 0); }
public TerminalNode FRONTEND() { return getToken(PLParser.FRONTEND, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public Show_config_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_show_config_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShow_config_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShow_config_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShow_config_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Show_config_stmtContext show_config_stmt() throws RecognitionException {
Show_config_stmtContext _localctx = new Show_config_stmtContext(_ctx, getState());
enterRule(_localctx, 98, RULE_show_config_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1330);
match(SHOW);
setState(1331);
((Show_config_stmtContext)_localctx).type = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BACKEND || _la==FRONTEND) ) {
((Show_config_stmtContext)_localctx).type = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1332);
match(CONFIG);
setState(1335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(1333);
match(LIKE);
setState(1334);
((Show_config_stmtContext)_localctx).pattern = valueExpression(0);
}
break;
}
setState(1339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(1337);
match(FROM);
setState(1338);
((Show_config_stmtContext)_localctx).backendId = match(INTEGER_VALUE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_routine_paramsContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<Create_routine_param_itemContext> create_routine_param_item() {
return getRuleContexts(Create_routine_param_itemContext.class);
}
public Create_routine_param_itemContext create_routine_param_item(int i) {
return getRuleContext(Create_routine_param_itemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Create_routine_paramsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_routine_params; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_routine_params(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_routine_params(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_routine_params(this);
else return visitor.visitChildren(this);
}
}
public final Create_routine_paramsContext create_routine_params() throws RecognitionException {
Create_routine_paramsContext _localctx = new Create_routine_paramsContext(_ctx, getState());
enterRule(_localctx, 100, RULE_create_routine_params);
int _la;
try {
int _alt;
setState(1363);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1341);
match(LEFT_PAREN);
setState(1342);
match(RIGHT_PAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1343);
match(LEFT_PAREN);
setState(1344);
create_routine_param_item();
setState(1349);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1345);
match(COMMA);
setState(1346);
create_routine_param_item();
}
}
setState(1351);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1352);
match(RIGHT_PAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1354);
if (!(!_input.LT(1).getText().equalsIgnoreCase("IS") &&
!_input.LT(1).getText().equalsIgnoreCase("AS") &&
!(_input.LT(1).getText().equalsIgnoreCase("DYNAMIC") && _input.LT(2).getText().equalsIgnoreCase("RESULT"))
)) throw new FailedPredicateException(this, "!_input.LT(1).getText().equalsIgnoreCase(\"IS\") &&\n !_input.LT(1).getText().equalsIgnoreCase(\"AS\") &&\n !(_input.LT(1).getText().equalsIgnoreCase(\"DYNAMIC\") && _input.LT(2).getText().equalsIgnoreCase(\"RESULT\"))\n ");
setState(1355);
create_routine_param_item();
setState(1360);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,91,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1356);
match(COMMA);
setState(1357);
create_routine_param_item();
}
}
}
setState(1362);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,91,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_routine_param_itemContext extends ParserRuleContext {
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public DtypeContext dtype() {
return getRuleContext(DtypeContext.class,0);
}
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public TerminalNode OUT() { return getToken(PLParser.OUT, 0); }
public TerminalNode INOUT() { return getToken(PLParser.INOUT, 0); }
public Dtype_lenContext dtype_len() {
return getRuleContext(Dtype_lenContext.class,0);
}
public List<Dtype_attrContext> dtype_attr() {
return getRuleContexts(Dtype_attrContext.class);
}
public Dtype_attrContext dtype_attr(int i) {
return getRuleContext(Dtype_attrContext.class,i);
}
public Dtype_defaultContext dtype_default() {
return getRuleContext(Dtype_defaultContext.class,0);
}
public Create_routine_param_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_routine_param_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_routine_param_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_routine_param_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_routine_param_item(this);
else return visitor.visitChildren(this);
}
}
public final Create_routine_param_itemContext create_routine_param_item() throws RecognitionException {
Create_routine_param_itemContext _localctx = new Create_routine_param_itemContext(_ctx, getState());
enterRule(_localctx, 102, RULE_create_routine_param_item);
try {
int _alt;
setState(1407);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1370);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
case 1:
{
setState(1365);
match(IN);
}
break;
case 2:
{
setState(1366);
match(OUT);
}
break;
case 3:
{
setState(1367);
match(INOUT);
}
break;
case 4:
{
setState(1368);
match(IN);
setState(1369);
match(OUT);
}
break;
}
setState(1372);
ident_pl();
setState(1373);
dtype();
setState(1375);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(1374);
dtype_len();
}
break;
}
setState(1380);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1377);
dtype_attr();
}
}
}
setState(1382);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
}
setState(1384);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(1383);
dtype_default();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1386);
ident_pl();
setState(1392);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(1387);
match(IN);
}
break;
case 2:
{
setState(1388);
match(OUT);
}
break;
case 3:
{
setState(1389);
match(INOUT);
}
break;
case 4:
{
setState(1390);
match(IN);
setState(1391);
match(OUT);
}
break;
}
setState(1394);
dtype();
setState(1396);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1395);
dtype_len();
}
break;
}
setState(1401);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1398);
dtype_attr();
}
}
}
setState(1403);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
}
setState(1405);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
setState(1404);
dtype_default();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_routine_optionsContext extends ParserRuleContext {
public List<Create_routine_optionContext> create_routine_option() {
return getRuleContexts(Create_routine_optionContext.class);
}
public Create_routine_optionContext create_routine_option(int i) {
return getRuleContext(Create_routine_optionContext.class,i);
}
public Create_routine_optionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_routine_options; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_routine_options(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_routine_options(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_routine_options(this);
else return visitor.visitChildren(this);
}
}
public final Create_routine_optionsContext create_routine_options() throws RecognitionException {
Create_routine_optionsContext _localctx = new Create_routine_optionsContext(_ctx, getState());
enterRule(_localctx, 104, RULE_create_routine_options);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1410);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1409);
create_routine_option();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1412);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,102,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_routine_optionContext extends ParserRuleContext {
public TerminalNode LANGUAGE() { return getToken(PLParser.LANGUAGE, 0); }
public TerminalNode SQL() { return getToken(PLParser.SQL, 0); }
public TerminalNode SECURITY() { return getToken(PLParser.SECURITY, 0); }
public TerminalNode CREATOR() { return getToken(PLParser.CREATOR, 0); }
public TerminalNode DEFINER() { return getToken(PLParser.DEFINER, 0); }
public TerminalNode INVOKER() { return getToken(PLParser.INVOKER, 0); }
public TerminalNode OWNER() { return getToken(PLParser.OWNER, 0); }
public TerminalNode RESULT() { return getToken(PLParser.RESULT, 0); }
public TerminalNode SETS() { return getToken(PLParser.SETS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode DYNAMIC() { return getToken(PLParser.DYNAMIC, 0); }
public Create_routine_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_routine_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreate_routine_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreate_routine_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreate_routine_option(this);
else return visitor.visitChildren(this);
}
}
public final Create_routine_optionContext create_routine_option() throws RecognitionException {
Create_routine_optionContext _localctx = new Create_routine_optionContext(_ctx, getState());
enterRule(_localctx, 106, RULE_create_routine_option);
int _la;
try {
setState(1425);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LANGUAGE:
enterOuterAlt(_localctx, 1);
{
setState(1414);
match(LANGUAGE);
setState(1415);
match(SQL);
}
break;
case SQL:
enterOuterAlt(_localctx, 2);
{
setState(1416);
match(SQL);
setState(1417);
match(SECURITY);
setState(1418);
_la = _input.LA(1);
if ( !(_la==CREATOR || _la==DEFINER || _la==INVOKER || _la==OWNER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case RESULT:
case DYNAMIC:
enterOuterAlt(_localctx, 3);
{
setState(1420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DYNAMIC) {
{
setState(1419);
match(DYNAMIC);
}
}
setState(1422);
match(RESULT);
setState(1423);
match(SETS);
setState(1424);
match(INTEGER_VALUE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Exec_stmtContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode EXEC() { return getToken(PLParser.EXEC, 0); }
public TerminalNode EXECUTE() { return getToken(PLParser.EXECUTE, 0); }
public TerminalNode IMMEDIATE() { return getToken(PLParser.IMMEDIATE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public Expr_func_paramsContext expr_func_params() {
return getRuleContext(Expr_func_paramsContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public List<TerminalNode> IDENTIFIER() { return getTokens(PLParser.IDENTIFIER); }
public TerminalNode IDENTIFIER(int i) {
return getToken(PLParser.IDENTIFIER, i);
}
public Using_clauseContext using_clause() {
return getRuleContext(Using_clauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Exec_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exec_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExec_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExec_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExec_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Exec_stmtContext exec_stmt() throws RecognitionException {
Exec_stmtContext _localctx = new Exec_stmtContext(_ctx, getState());
enterRule(_localctx, 108, RULE_exec_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1427);
_la = _input.LA(1);
if ( !(_la==EXEC || _la==EXECUTE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1429);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
{
setState(1428);
match(IMMEDIATE);
}
break;
}
setState(1431);
expr(0);
setState(1437);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(1432);
match(LEFT_PAREN);
setState(1433);
expr_func_params();
setState(1434);
match(RIGHT_PAREN);
}
break;
case 2:
{
setState(1436);
expr_func_params();
}
break;
}
setState(1448);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
case 1:
{
setState(1439);
match(INTO);
setState(1440);
match(IDENTIFIER);
setState(1445);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1441);
match(COMMA);
setState(1442);
match(IDENTIFIER);
}
}
}
setState(1447);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
}
}
break;
}
setState(1451);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
{
setState(1450);
using_clause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class If_stmtContext extends ParserRuleContext {
public If_plsql_stmtContext if_plsql_stmt() {
return getRuleContext(If_plsql_stmtContext.class,0);
}
public If_tsql_stmtContext if_tsql_stmt() {
return getRuleContext(If_tsql_stmtContext.class,0);
}
public If_bteq_stmtContext if_bteq_stmt() {
return getRuleContext(If_bteq_stmtContext.class,0);
}
public If_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIf_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIf_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIf_stmt(this);
else return visitor.visitChildren(this);
}
}
public final If_stmtContext if_stmt() throws RecognitionException {
If_stmtContext _localctx = new If_stmtContext(_ctx, getState());
enterRule(_localctx, 110, RULE_if_stmt);
try {
setState(1456);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1453);
if_plsql_stmt();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1454);
if_tsql_stmt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1455);
if_bteq_stmt();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class If_plsql_stmtContext extends ParserRuleContext {
public List<TerminalNode> IF() { return getTokens(PLParser.IF); }
public TerminalNode IF(int i) {
return getToken(PLParser.IF, i);
}
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public List<Elseif_blockContext> elseif_block() {
return getRuleContexts(Elseif_blockContext.class);
}
public Elseif_blockContext elseif_block(int i) {
return getRuleContext(Elseif_blockContext.class,i);
}
public Else_blockContext else_block() {
return getRuleContext(Else_blockContext.class,0);
}
public If_plsql_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_plsql_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIf_plsql_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIf_plsql_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIf_plsql_stmt(this);
else return visitor.visitChildren(this);
}
}
public final If_plsql_stmtContext if_plsql_stmt() throws RecognitionException {
If_plsql_stmtContext _localctx = new If_plsql_stmtContext(_ctx, getState());
enterRule(_localctx, 112, RULE_if_plsql_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1458);
match(IF);
setState(1459);
bool_expr(0);
setState(1460);
match(THEN);
setState(1461);
block();
setState(1465);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ELSEIF || _la==ELSIF) {
{
{
setState(1462);
elseif_block();
}
}
setState(1467);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1468);
else_block();
}
}
setState(1471);
match(END);
setState(1472);
match(IF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class If_tsql_stmtContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public List<Single_block_stmtContext> single_block_stmt() {
return getRuleContexts(Single_block_stmtContext.class);
}
public Single_block_stmtContext single_block_stmt(int i) {
return getRuleContext(Single_block_stmtContext.class,i);
}
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public If_tsql_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_tsql_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIf_tsql_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIf_tsql_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIf_tsql_stmt(this);
else return visitor.visitChildren(this);
}
}
public final If_tsql_stmtContext if_tsql_stmt() throws RecognitionException {
If_tsql_stmtContext _localctx = new If_tsql_stmtContext(_ctx, getState());
enterRule(_localctx, 114, RULE_if_tsql_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1474);
match(IF);
setState(1475);
bool_expr(0);
setState(1476);
single_block_stmt();
setState(1479);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
{
setState(1477);
match(ELSE);
setState(1478);
single_block_stmt();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class If_bteq_stmtContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public Single_block_stmtContext single_block_stmt() {
return getRuleContext(Single_block_stmtContext.class,0);
}
public If_bteq_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_bteq_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIf_bteq_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIf_bteq_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIf_bteq_stmt(this);
else return visitor.visitChildren(this);
}
}
public final If_bteq_stmtContext if_bteq_stmt() throws RecognitionException {
If_bteq_stmtContext _localctx = new If_bteq_stmtContext(_ctx, getState());
enterRule(_localctx, 116, RULE_if_bteq_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1481);
match(DOT);
setState(1482);
match(IF);
setState(1483);
bool_expr(0);
setState(1484);
match(THEN);
setState(1485);
single_block_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Elseif_blockContext extends ParserRuleContext {
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode ELSIF() { return getToken(PLParser.ELSIF, 0); }
public TerminalNode ELSEIF() { return getToken(PLParser.ELSEIF, 0); }
public Elseif_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elseif_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterElseif_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitElseif_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitElseif_block(this);
else return visitor.visitChildren(this);
}
}
public final Elseif_blockContext elseif_block() throws RecognitionException {
Elseif_blockContext _localctx = new Elseif_blockContext(_ctx, getState());
enterRule(_localctx, 118, RULE_elseif_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1487);
_la = _input.LA(1);
if ( !(_la==ELSEIF || _la==ELSIF) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1488);
bool_expr(0);
setState(1489);
match(THEN);
setState(1490);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Else_blockContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public Else_blockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_else_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterElse_block(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitElse_block(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitElse_block(this);
else return visitor.visitChildren(this);
}
}
public final Else_blockContext else_block() throws RecognitionException {
Else_blockContext _localctx = new Else_blockContext(_ctx, getState());
enterRule(_localctx, 120, RULE_else_block);
try {
enterOuterAlt(_localctx, 1);
{
setState(1492);
match(ELSE);
setState(1493);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Include_stmtContext extends ParserRuleContext {
public TerminalNode INCLUDE() { return getToken(PLParser.INCLUDE, 0); }
public File_nameContext file_name() {
return getRuleContext(File_nameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Include_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_include_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInclude_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInclude_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInclude_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Include_stmtContext include_stmt() throws RecognitionException {
Include_stmtContext _localctx = new Include_stmtContext(_ctx, getState());
enterRule(_localctx, 122, RULE_include_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1495);
match(INCLUDE);
setState(1498);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(1496);
file_name();
}
break;
case 2:
{
setState(1497);
expr(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Exit_stmtContext extends ParserRuleContext {
public TerminalNode EXIT() { return getToken(PLParser.EXIT, 0); }
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public TerminalNode WHEN() { return getToken(PLParser.WHEN, 0); }
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public Exit_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exit_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExit_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExit_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExit_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Exit_stmtContext exit_stmt() throws RecognitionException {
Exit_stmtContext _localctx = new Exit_stmtContext(_ctx, getState());
enterRule(_localctx, 124, RULE_exit_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1500);
match(EXIT);
setState(1502);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(1501);
match(IDENTIFIER);
}
break;
}
setState(1506);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
setState(1504);
match(WHEN);
setState(1505);
bool_expr(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Get_diag_stmtContext extends ParserRuleContext {
public TerminalNode GET() { return getToken(PLParser.GET, 0); }
public TerminalNode DIAGNOSTICS() { return getToken(PLParser.DIAGNOSTICS, 0); }
public Get_diag_stmt_itemContext get_diag_stmt_item() {
return getRuleContext(Get_diag_stmt_itemContext.class,0);
}
public Get_diag_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_diag_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGet_diag_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGet_diag_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGet_diag_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Get_diag_stmtContext get_diag_stmt() throws RecognitionException {
Get_diag_stmtContext _localctx = new Get_diag_stmtContext(_ctx, getState());
enterRule(_localctx, 126, RULE_get_diag_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1508);
match(GET);
setState(1509);
match(DIAGNOSTICS);
setState(1510);
get_diag_stmt_item();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Get_diag_stmt_itemContext extends ParserRuleContext {
public Get_diag_stmt_exception_itemContext get_diag_stmt_exception_item() {
return getRuleContext(Get_diag_stmt_exception_itemContext.class,0);
}
public Get_diag_stmt_rowcount_itemContext get_diag_stmt_rowcount_item() {
return getRuleContext(Get_diag_stmt_rowcount_itemContext.class,0);
}
public Get_diag_stmt_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_diag_stmt_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGet_diag_stmt_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGet_diag_stmt_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGet_diag_stmt_item(this);
else return visitor.visitChildren(this);
}
}
public final Get_diag_stmt_itemContext get_diag_stmt_item() throws RecognitionException {
Get_diag_stmt_itemContext _localctx = new Get_diag_stmt_itemContext(_ctx, getState());
enterRule(_localctx, 128, RULE_get_diag_stmt_item);
try {
setState(1514);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1512);
get_diag_stmt_exception_item();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1513);
get_diag_stmt_rowcount_item();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Get_diag_stmt_exception_itemContext extends ParserRuleContext {
public TerminalNode EXCEPTION() { return getToken(PLParser.EXCEPTION, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public QidentContext qident() {
return getRuleContext(QidentContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode MESSAGE_TEXT() { return getToken(PLParser.MESSAGE_TEXT, 0); }
public Get_diag_stmt_exception_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_diag_stmt_exception_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGet_diag_stmt_exception_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGet_diag_stmt_exception_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGet_diag_stmt_exception_item(this);
else return visitor.visitChildren(this);
}
}
public final Get_diag_stmt_exception_itemContext get_diag_stmt_exception_item() throws RecognitionException {
Get_diag_stmt_exception_itemContext _localctx = new Get_diag_stmt_exception_itemContext(_ctx, getState());
enterRule(_localctx, 130, RULE_get_diag_stmt_exception_item);
try {
enterOuterAlt(_localctx, 1);
{
setState(1516);
match(EXCEPTION);
setState(1517);
match(INTEGER_VALUE);
setState(1518);
qident();
setState(1519);
match(EQ);
setState(1520);
match(MESSAGE_TEXT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Get_diag_stmt_rowcount_itemContext extends ParserRuleContext {
public QidentContext qident() {
return getRuleContext(QidentContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode ROW_COUNT() { return getToken(PLParser.ROW_COUNT, 0); }
public Get_diag_stmt_rowcount_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_diag_stmt_rowcount_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGet_diag_stmt_rowcount_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGet_diag_stmt_rowcount_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGet_diag_stmt_rowcount_item(this);
else return visitor.visitChildren(this);
}
}
public final Get_diag_stmt_rowcount_itemContext get_diag_stmt_rowcount_item() throws RecognitionException {
Get_diag_stmt_rowcount_itemContext _localctx = new Get_diag_stmt_rowcount_itemContext(_ctx, getState());
enterRule(_localctx, 132, RULE_get_diag_stmt_rowcount_item);
try {
enterOuterAlt(_localctx, 1);
{
setState(1522);
qident();
setState(1523);
match(EQ);
setState(1524);
match(ROW_COUNT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Leave_stmtContext extends ParserRuleContext {
public TerminalNode LEAVE() { return getToken(PLParser.LEAVE, 0); }
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public Leave_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_leave_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLeave_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLeave_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLeave_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Leave_stmtContext leave_stmt() throws RecognitionException {
Leave_stmtContext _localctx = new Leave_stmtContext(_ctx, getState());
enterRule(_localctx, 134, RULE_leave_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1526);
match(LEAVE);
setState(1528);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
{
setState(1527);
match(IDENTIFIER);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Map_object_stmtContext extends ParserRuleContext {
public TerminalNode MAP() { return getToken(PLParser.MAP, 0); }
public TerminalNode OBJECT() { return getToken(PLParser.OBJECT, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode AT() { return getToken(PLParser.AT, 0); }
public Map_object_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_map_object_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMap_object_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMap_object_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMap_object_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Map_object_stmtContext map_object_stmt() throws RecognitionException {
Map_object_stmtContext _localctx = new Map_object_stmtContext(_ctx, getState());
enterRule(_localctx, 136, RULE_map_object_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1530);
match(MAP);
setState(1531);
match(OBJECT);
setState(1532);
ident_pl();
setState(1535);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
{
setState(1533);
match(TO);
setState(1534);
ident_pl();
}
break;
}
setState(1539);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
case 1:
{
setState(1537);
match(AT);
setState(1538);
ident_pl();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Open_stmtContext extends ParserRuleContext {
public TerminalNode OPEN() { return getToken(PLParser.OPEN, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Open_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_open_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOpen_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOpen_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOpen_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Open_stmtContext open_stmt() throws RecognitionException {
Open_stmtContext _localctx = new Open_stmtContext(_ctx, getState());
enterRule(_localctx, 138, RULE_open_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1541);
match(OPEN);
setState(1542);
ident_pl();
setState(1548);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1543);
match(FOR);
setState(1546);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(1544);
query();
}
break;
case 2:
{
setState(1545);
expr(0);
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Fetch_stmtContext extends ParserRuleContext {
public TerminalNode FETCH() { return getToken(PLParser.FETCH, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BulkCollectClauseContext bulkCollectClause() {
return getRuleContext(BulkCollectClauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Fetch_limitContext fetch_limit() {
return getRuleContext(Fetch_limitContext.class,0);
}
public Fetch_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fetch_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFetch_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFetch_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFetch_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Fetch_stmtContext fetch_stmt() throws RecognitionException {
Fetch_stmtContext _localctx = new Fetch_stmtContext(_ctx, getState());
enterRule(_localctx, 140, RULE_fetch_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1550);
match(FETCH);
setState(1552);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(1551);
match(FROM);
}
}
setState(1554);
ident_pl();
setState(1556);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BULK) {
{
setState(1555);
bulkCollectClause();
}
}
setState(1558);
match(INTO);
setState(1559);
ident_pl();
setState(1564);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1560);
match(COMMA);
setState(1561);
ident_pl();
}
}
}
setState(1566);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
}
setState(1568);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(1567);
fetch_limit();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Fetch_limitContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(PLParser.LIMIT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Fetch_limitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fetch_limit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFetch_limit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFetch_limit(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFetch_limit(this);
else return visitor.visitChildren(this);
}
}
public final Fetch_limitContext fetch_limit() throws RecognitionException {
Fetch_limitContext _localctx = new Fetch_limitContext(_ctx, getState());
enterRule(_localctx, 142, RULE_fetch_limit);
try {
enterOuterAlt(_localctx, 1);
{
setState(1570);
match(LIMIT);
setState(1571);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Close_stmtContext extends ParserRuleContext {
public TerminalNode CLOSE() { return getToken(PLParser.CLOSE, 0); }
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public Close_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_close_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterClose_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitClose_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitClose_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Close_stmtContext close_stmt() throws RecognitionException {
Close_stmtContext _localctx = new Close_stmtContext(_ctx, getState());
enterRule(_localctx, 144, RULE_close_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1573);
match(CLOSE);
setState(1574);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Print_stmtContext extends ParserRuleContext {
public TerminalNode PRINT() { return getToken(PLParser.PRINT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Print_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_print_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPrint_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPrint_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPrint_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Print_stmtContext print_stmt() throws RecognitionException {
Print_stmtContext _localctx = new Print_stmtContext(_ctx, getState());
enterRule(_localctx, 146, RULE_print_stmt);
try {
setState(1583);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1576);
match(PRINT);
setState(1577);
expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1578);
match(PRINT);
setState(1579);
match(LEFT_PAREN);
setState(1580);
expr(0);
setState(1581);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Quit_stmtContext extends ParserRuleContext {
public TerminalNode QUIT() { return getToken(PLParser.QUIT, 0); }
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Quit_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quit_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQuit_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQuit_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQuit_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Quit_stmtContext quit_stmt() throws RecognitionException {
Quit_stmtContext _localctx = new Quit_stmtContext(_ctx, getState());
enterRule(_localctx, 148, RULE_quit_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1586);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(1585);
match(DOT);
}
}
setState(1588);
match(QUIT);
setState(1590);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1589);
expr(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Raise_stmtContext extends ParserRuleContext {
public TerminalNode RAISE() { return getToken(PLParser.RAISE, 0); }
public Raise_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_raise_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRaise_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRaise_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRaise_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Raise_stmtContext raise_stmt() throws RecognitionException {
Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState());
enterRule(_localctx, 150, RULE_raise_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1592);
match(RAISE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Resignal_stmtContext extends ParserRuleContext {
public TerminalNode RESIGNAL() { return getToken(PLParser.RESIGNAL, 0); }
public TerminalNode SQLSTATE() { return getToken(PLParser.SQLSTATE, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode VALUE() { return getToken(PLParser.VALUE, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode MESSAGE_TEXT() { return getToken(PLParser.MESSAGE_TEXT, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public Resignal_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resignal_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResignal_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResignal_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResignal_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Resignal_stmtContext resignal_stmt() throws RecognitionException {
Resignal_stmtContext _localctx = new Resignal_stmtContext(_ctx, getState());
enterRule(_localctx, 152, RULE_resignal_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1594);
match(RESIGNAL);
setState(1606);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(1595);
match(SQLSTATE);
setState(1597);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(1596);
match(VALUE);
}
break;
}
setState(1599);
expr(0);
setState(1604);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1600);
match(SET);
setState(1601);
match(MESSAGE_TEXT);
setState(1602);
match(EQ);
setState(1603);
expr(0);
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Return_stmtContext extends ParserRuleContext {
public TerminalNode RETURN() { return getToken(PLParser.RETURN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Return_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_return_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReturn_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReturn_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReturn_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Return_stmtContext return_stmt() throws RecognitionException {
Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState());
enterRule(_localctx, 154, RULE_return_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1608);
match(RETURN);
setState(1610);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1609);
expr(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Set_session_optionContext extends ParserRuleContext {
public Set_doris_session_optionContext set_doris_session_option() {
return getRuleContext(Set_doris_session_optionContext.class,0);
}
public Set_current_schema_optionContext set_current_schema_option() {
return getRuleContext(Set_current_schema_optionContext.class,0);
}
public Set_mssql_session_optionContext set_mssql_session_option() {
return getRuleContext(Set_mssql_session_optionContext.class,0);
}
public Set_teradata_session_optionContext set_teradata_session_option() {
return getRuleContext(Set_teradata_session_optionContext.class,0);
}
public Set_session_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_set_session_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSet_session_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSet_session_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSet_session_option(this);
else return visitor.visitChildren(this);
}
}
public final Set_session_optionContext set_session_option() throws RecognitionException {
Set_session_optionContext _localctx = new Set_session_optionContext(_ctx, getState());
enterRule(_localctx, 156, RULE_set_session_option);
try {
setState(1616);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1612);
set_doris_session_option();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1613);
set_current_schema_option();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1614);
set_mssql_session_option();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1615);
set_teradata_session_option();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Set_doris_session_optionContext extends ParserRuleContext {
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public Set_doris_session_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_set_doris_session_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSet_doris_session_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSet_doris_session_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSet_doris_session_option(this);
else return visitor.visitChildren(this);
}
}
public final Set_doris_session_optionContext set_doris_session_option() throws RecognitionException {
Set_doris_session_optionContext _localctx = new Set_doris_session_optionContext(_ctx, getState());
enterRule(_localctx, 158, RULE_set_doris_session_option);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1619);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
{
setState(1618);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1621);
ident_pl();
setState(1622);
match(EQ);
setState(1623);
ident_pl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Set_current_schema_optionContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode CURRENT_SCHEMA() { return getToken(PLParser.CURRENT_SCHEMA, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public TerminalNode CURRENT() { return getToken(PLParser.CURRENT, 0); }
public Set_current_schema_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_set_current_schema_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSet_current_schema_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSet_current_schema_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSet_current_schema_option(this);
else return visitor.visitChildren(this);
}
}
public final Set_current_schema_optionContext set_current_schema_option() throws RecognitionException {
Set_current_schema_optionContext _localctx = new Set_current_schema_optionContext(_ctx, getState());
enterRule(_localctx, 160, RULE_set_current_schema_option);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1630);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CURRENT:
case SCHEMA:
{
{
setState(1626);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CURRENT) {
{
setState(1625);
match(CURRENT);
}
}
setState(1628);
match(SCHEMA);
}
}
break;
case CURRENT_SCHEMA:
{
setState(1629);
match(CURRENT_SCHEMA);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1632);
match(EQ);
}
}
setState(1635);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Set_mssql_session_optionContext extends ParserRuleContext {
public TerminalNode ANSI_NULLS() { return getToken(PLParser.ANSI_NULLS, 0); }
public TerminalNode ANSI_PADDING() { return getToken(PLParser.ANSI_PADDING, 0); }
public TerminalNode NOCOUNT() { return getToken(PLParser.NOCOUNT, 0); }
public TerminalNode QUOTED_IDENTIFIER() { return getToken(PLParser.QUOTED_IDENTIFIER, 0); }
public TerminalNode XACT_ABORT() { return getToken(PLParser.XACT_ABORT, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode OFF() { return getToken(PLParser.OFF, 0); }
public Set_mssql_session_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_set_mssql_session_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSet_mssql_session_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSet_mssql_session_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSet_mssql_session_option(this);
else return visitor.visitChildren(this);
}
}
public final Set_mssql_session_optionContext set_mssql_session_option() throws RecognitionException {
Set_mssql_session_optionContext _localctx = new Set_mssql_session_optionContext(_ctx, getState());
enterRule(_localctx, 162, RULE_set_mssql_session_option);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1637);
_la = _input.LA(1);
if ( !(_la==ANSI_NULLS || _la==ANSI_PADDING || _la==NOCOUNT || _la==QUOTED_IDENTIFIER || _la==XACT_ABORT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1638);
_la = _input.LA(1);
if ( !(_la==OFF || _la==ON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Set_teradata_session_optionContext extends ParserRuleContext {
public TerminalNode QUERY_BAND() { return getToken(PLParser.QUERY_BAND, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode NONE() { return getToken(PLParser.NONE, 0); }
public TerminalNode UPDATE() { return getToken(PLParser.UPDATE, 0); }
public Set_teradata_session_optionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_set_teradata_session_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSet_teradata_session_option(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSet_teradata_session_option(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSet_teradata_session_option(this);
else return visitor.visitChildren(this);
}
}
public final Set_teradata_session_optionContext set_teradata_session_option() throws RecognitionException {
Set_teradata_session_optionContext _localctx = new Set_teradata_session_optionContext(_ctx, getState());
enterRule(_localctx, 164, RULE_set_teradata_session_option);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1640);
match(QUERY_BAND);
setState(1641);
match(EQ);
setState(1644);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1642);
expr(0);
}
break;
case 2:
{
setState(1643);
match(NONE);
}
break;
}
setState(1647);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UPDATE) {
{
setState(1646);
match(UPDATE);
}
}
setState(1649);
match(FOR);
setState(1650);
_la = _input.LA(1);
if ( !(_la==SESSION || _la==TRANSACTION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Signal_stmtContext extends ParserRuleContext {
public TerminalNode SIGNAL() { return getToken(PLParser.SIGNAL, 0); }
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public Signal_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_signal_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSignal_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSignal_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSignal_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Signal_stmtContext signal_stmt() throws RecognitionException {
Signal_stmtContext _localctx = new Signal_stmtContext(_ctx, getState());
enterRule(_localctx, 166, RULE_signal_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1652);
match(SIGNAL);
setState(1653);
ident_pl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Values_into_stmtContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(PLParser.VALUES, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public Values_into_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_values_into_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterValues_into_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitValues_into_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitValues_into_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Values_into_stmtContext values_into_stmt() throws RecognitionException {
Values_into_stmtContext _localctx = new Values_into_stmtContext(_ctx, getState());
enterRule(_localctx, 168, RULE_values_into_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1655);
match(VALUES);
setState(1657);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
{
setState(1656);
match(LEFT_PAREN);
}
break;
}
setState(1659);
expr(0);
setState(1664);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1660);
match(COMMA);
setState(1661);
expr(0);
}
}
setState(1666);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1668);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RIGHT_PAREN) {
{
setState(1667);
match(RIGHT_PAREN);
}
}
setState(1670);
match(INTO);
setState(1672);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(1671);
match(LEFT_PAREN);
}
}
setState(1674);
ident_pl();
setState(1679);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1675);
match(COMMA);
setState(1676);
ident_pl();
}
}
}
setState(1681);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
}
setState(1683);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1682);
match(RIGHT_PAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class While_stmtContext extends ParserRuleContext {
public List<TerminalNode> WHILE() { return getTokens(PLParser.WHILE); }
public TerminalNode WHILE(int i) {
return getToken(PLParser.WHILE, i);
}
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode DO() { return getToken(PLParser.DO, 0); }
public List<TerminalNode> LOOP() { return getTokens(PLParser.LOOP); }
public TerminalNode LOOP(int i) {
return getToken(PLParser.LOOP, i);
}
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public TerminalNode BEGIN() { return getToken(PLParser.BEGIN, 0); }
public While_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_while_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWhile_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWhile_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWhile_stmt(this);
else return visitor.visitChildren(this);
}
}
public final While_stmtContext while_stmt() throws RecognitionException {
While_stmtContext _localctx = new While_stmtContext(_ctx, getState());
enterRule(_localctx, 170, RULE_while_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1685);
match(WHILE);
setState(1686);
bool_expr(0);
setState(1687);
_la = _input.LA(1);
if ( !(_la==LOOP || _la==BEGIN || _la==DO || _la==THEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1688);
block();
setState(1689);
match(END);
setState(1691);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
{
setState(1690);
_la = _input.LA(1);
if ( !(_la==LOOP || _la==WHILE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Unconditional_loop_stmtContext extends ParserRuleContext {
public List<TerminalNode> LOOP() { return getTokens(PLParser.LOOP); }
public TerminalNode LOOP(int i) {
return getToken(PLParser.LOOP, i);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public Unconditional_loop_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unconditional_loop_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnconditional_loop_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnconditional_loop_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnconditional_loop_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Unconditional_loop_stmtContext unconditional_loop_stmt() throws RecognitionException {
Unconditional_loop_stmtContext _localctx = new Unconditional_loop_stmtContext(_ctx, getState());
enterRule(_localctx, 172, RULE_unconditional_loop_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1693);
match(LOOP);
setState(1694);
block();
setState(1695);
match(END);
setState(1696);
match(LOOP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class For_cursor_stmtContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public List<TerminalNode> LOOP() { return getTokens(PLParser.LOOP); }
public TerminalNode LOOP(int i) {
return getToken(PLParser.LOOP, i);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public For_cursor_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_for_cursor_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFor_cursor_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFor_cursor_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFor_cursor_stmt(this);
else return visitor.visitChildren(this);
}
}
public final For_cursor_stmtContext for_cursor_stmt() throws RecognitionException {
For_cursor_stmtContext _localctx = new For_cursor_stmtContext(_ctx, getState());
enterRule(_localctx, 174, RULE_for_cursor_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1698);
match(FOR);
setState(1699);
match(IDENTIFIER);
setState(1700);
match(IN);
setState(1702);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
{
setState(1701);
match(LEFT_PAREN);
}
break;
}
setState(1704);
query();
setState(1706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RIGHT_PAREN) {
{
setState(1705);
match(RIGHT_PAREN);
}
}
setState(1708);
match(LOOP);
setState(1709);
block();
setState(1710);
match(END);
setState(1711);
match(LOOP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class For_range_stmtContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode DOT2() { return getToken(PLParser.DOT2, 0); }
public List<TerminalNode> LOOP() { return getTokens(PLParser.LOOP); }
public TerminalNode LOOP(int i) {
return getToken(PLParser.LOOP, i);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode REVERSE() { return getToken(PLParser.REVERSE, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public TerminalNode STEP() { return getToken(PLParser.STEP, 0); }
public For_range_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_for_range_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFor_range_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFor_range_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFor_range_stmt(this);
else return visitor.visitChildren(this);
}
}
public final For_range_stmtContext for_range_stmt() throws RecognitionException {
For_range_stmtContext _localctx = new For_range_stmtContext(_ctx, getState());
enterRule(_localctx, 176, RULE_for_range_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1713);
match(FOR);
setState(1714);
match(IDENTIFIER);
setState(1715);
match(IN);
setState(1717);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1716);
match(REVERSE);
}
break;
}
setState(1719);
expr(0);
setState(1720);
match(DOT2);
setState(1721);
expr(0);
setState(1724);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STEP || _la==BY) {
{
setState(1722);
_la = _input.LA(1);
if ( !(_la==STEP || _la==BY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1723);
expr(0);
}
}
setState(1726);
match(LOOP);
setState(1727);
block();
setState(1728);
match(END);
setState(1729);
match(LOOP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Label_stmtContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public List<TerminalNode> LT() { return getTokens(PLParser.LT); }
public TerminalNode LT(int i) {
return getToken(PLParser.LT, i);
}
public List<TerminalNode> GT() { return getTokens(PLParser.GT); }
public TerminalNode GT(int i) {
return getToken(PLParser.GT, i);
}
public Label_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_label_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLabel_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLabel_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLabel_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Label_stmtContext label_stmt() throws RecognitionException {
Label_stmtContext _localctx = new Label_stmtContext(_ctx, getState());
enterRule(_localctx, 178, RULE_label_stmt);
try {
setState(1738);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1731);
match(IDENTIFIER);
setState(1732);
match(COLON);
}
break;
case LT:
enterOuterAlt(_localctx, 2);
{
setState(1733);
match(LT);
setState(1734);
match(LT);
setState(1735);
match(IDENTIFIER);
setState(1736);
match(GT);
setState(1737);
match(GT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Using_clauseContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Using_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_using_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUsing_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUsing_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUsing_clause(this);
else return visitor.visitChildren(this);
}
}
public final Using_clauseContext using_clause() throws RecognitionException {
Using_clauseContext _localctx = new Using_clauseContext(_ctx, getState());
enterRule(_localctx, 180, RULE_using_clause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1740);
match(USING);
setState(1741);
expr(0);
setState(1746);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,153,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1742);
match(COMMA);
setState(1743);
expr(0);
}
}
}
setState(1748);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,153,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_exprContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<Bool_exprContext> bool_expr() {
return getRuleContexts(Bool_exprContext.class);
}
public Bool_exprContext bool_expr(int i) {
return getRuleContext(Bool_exprContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public Bool_expr_atomContext bool_expr_atom() {
return getRuleContext(Bool_expr_atomContext.class,0);
}
public Bool_expr_logical_operatorContext bool_expr_logical_operator() {
return getRuleContext(Bool_expr_logical_operatorContext.class,0);
}
public Bool_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr(this);
else return visitor.visitChildren(this);
}
}
public final Bool_exprContext bool_expr() throws RecognitionException {
return bool_expr(0);
}
private Bool_exprContext bool_expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
Bool_exprContext _localctx = new Bool_exprContext(_ctx, _parentState);
Bool_exprContext _prevctx = _localctx;
int _startState = 182;
enterRecursionRule(_localctx, 182, RULE_bool_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1758);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
{
setState(1751);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1750);
match(NOT);
}
}
setState(1753);
match(LEFT_PAREN);
setState(1754);
bool_expr(0);
setState(1755);
match(RIGHT_PAREN);
}
break;
case 2:
{
setState(1757);
bool_expr_atom();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1766);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new Bool_exprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bool_expr);
setState(1760);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1761);
bool_expr_logical_operator();
setState(1762);
bool_expr(3);
}
}
}
setState(1768);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_expr_atomContext extends ParserRuleContext {
public Bool_expr_unaryContext bool_expr_unary() {
return getRuleContext(Bool_expr_unaryContext.class,0);
}
public Bool_expr_binaryContext bool_expr_binary() {
return getRuleContext(Bool_expr_binaryContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Bool_expr_atomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr_atom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr_atom(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr_atom(this);
else return visitor.visitChildren(this);
}
}
public final Bool_expr_atomContext bool_expr_atom() throws RecognitionException {
Bool_expr_atomContext _localctx = new Bool_expr_atomContext(_ctx, getState());
enterRule(_localctx, 184, RULE_bool_expr_atom);
try {
setState(1772);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1769);
bool_expr_unary();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1770);
bool_expr_binary();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1771);
expr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_expr_unaryContext extends ParserRuleContext {
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode BETWEEN() { return getToken(PLParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public Bool_expr_unaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr_unary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr_unary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr_unary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr_unary(this);
else return visitor.visitChildren(this);
}
}
public final Bool_expr_unaryContext bool_expr_unary() throws RecognitionException {
Bool_expr_unaryContext _localctx = new Bool_expr_unaryContext(_ctx, getState());
enterRule(_localctx, 186, RULE_bool_expr_unary);
int _la;
try {
setState(1787);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1774);
expr(0);
setState(1775);
match(IS);
setState(1777);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1776);
match(NOT);
}
}
setState(1779);
match(NULL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1781);
expr(0);
setState(1782);
match(BETWEEN);
setState(1783);
expr(0);
setState(1784);
match(AND);
setState(1785);
expr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_expr_binaryContext extends ParserRuleContext {
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Bool_expr_binary_operatorContext bool_expr_binary_operator() {
return getRuleContext(Bool_expr_binary_operatorContext.class,0);
}
public Bool_expr_binaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr_binary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr_binary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr_binary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr_binary(this);
else return visitor.visitChildren(this);
}
}
public final Bool_expr_binaryContext bool_expr_binary() throws RecognitionException {
Bool_expr_binaryContext _localctx = new Bool_expr_binaryContext(_ctx, getState());
enterRule(_localctx, 188, RULE_bool_expr_binary);
try {
enterOuterAlt(_localctx, 1);
{
setState(1789);
expr(0);
setState(1790);
bool_expr_binary_operator();
setState(1791);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_expr_logical_operatorContext extends ParserRuleContext {
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public Bool_expr_logical_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr_logical_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr_logical_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr_logical_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr_logical_operator(this);
else return visitor.visitChildren(this);
}
}
public final Bool_expr_logical_operatorContext bool_expr_logical_operator() throws RecognitionException {
Bool_expr_logical_operatorContext _localctx = new Bool_expr_logical_operatorContext(_ctx, getState());
enterRule(_localctx, 190, RULE_bool_expr_logical_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1793);
_la = _input.LA(1);
if ( !(_la==AND || _la==OR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_expr_binary_operatorContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(PLParser.NEQ, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public TerminalNode LTE() { return getToken(PLParser.LTE, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public TerminalNode GTE() { return getToken(PLParser.GTE, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode RLIKE() { return getToken(PLParser.RLIKE, 0); }
public TerminalNode REGEXP() { return getToken(PLParser.REGEXP, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public Bool_expr_binary_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr_binary_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_expr_binary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_expr_binary_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_expr_binary_operator(this);
else return visitor.visitChildren(this);
}
}
public final Bool_expr_binary_operatorContext bool_expr_binary_operator() throws RecognitionException {
Bool_expr_binary_operatorContext _localctx = new Bool_expr_binary_operatorContext(_ctx, getState());
enterRule(_localctx, 192, RULE_bool_expr_binary_operator);
int _la;
try {
setState(1805);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EQ:
enterOuterAlt(_localctx, 1);
{
setState(1795);
match(EQ);
}
break;
case NEQ:
enterOuterAlt(_localctx, 2);
{
setState(1796);
match(NEQ);
}
break;
case LT:
enterOuterAlt(_localctx, 3);
{
setState(1797);
match(LT);
}
break;
case LTE:
enterOuterAlt(_localctx, 4);
{
setState(1798);
match(LTE);
}
break;
case GT:
enterOuterAlt(_localctx, 5);
{
setState(1799);
match(GT);
}
break;
case GTE:
enterOuterAlt(_localctx, 6);
{
setState(1800);
match(GTE);
}
break;
case LIKE:
case NOT:
case REGEXP:
case RLIKE:
enterOuterAlt(_localctx, 7);
{
setState(1802);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1801);
match(NOT);
}
}
setState(1804);
_la = _input.LA(1);
if ( !(_la==LIKE || _la==REGEXP || _la==RLIKE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Expr_intervalContext expr_interval() {
return getRuleContext(Expr_intervalContext.class,0);
}
public Expr_concatContext expr_concat() {
return getRuleContext(Expr_concatContext.class,0);
}
public Expr_dotContext expr_dot() {
return getRuleContext(Expr_dotContext.class,0);
}
public Expr_caseContext expr_case() {
return getRuleContext(Expr_caseContext.class,0);
}
public Expr_cursor_attributeContext expr_cursor_attribute() {
return getRuleContext(Expr_cursor_attributeContext.class,0);
}
public Expr_agg_window_funcContext expr_agg_window_func() {
return getRuleContext(Expr_agg_window_funcContext.class,0);
}
public Expr_spec_funcContext expr_spec_func() {
return getRuleContext(Expr_spec_funcContext.class,0);
}
public Expr_funcContext expr_func() {
return getRuleContext(Expr_funcContext.class,0);
}
public Expr_atomContext expr_atom() {
return getRuleContext(Expr_atomContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(PLParser.SLASH, 0); }
public TerminalNode PLUS() { return getToken(PLParser.PLUS, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public Interval_itemContext interval_item() {
return getRuleContext(Interval_itemContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 194;
enterRecursionRule(_localctx, 194, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1825);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1808);
match(LEFT_PAREN);
setState(1809);
query();
setState(1810);
match(RIGHT_PAREN);
}
break;
case 2:
{
setState(1812);
match(LEFT_PAREN);
setState(1813);
expr(0);
setState(1814);
match(RIGHT_PAREN);
}
break;
case 3:
{
setState(1816);
expr_interval();
}
break;
case 4:
{
setState(1817);
expr_concat();
}
break;
case 5:
{
setState(1818);
expr_dot();
}
break;
case 6:
{
setState(1819);
expr_case();
}
break;
case 7:
{
setState(1820);
expr_cursor_attribute();
}
break;
case 8:
{
setState(1821);
expr_agg_window_func();
}
break;
case 9:
{
setState(1822);
expr_spec_func();
}
break;
case 10:
{
setState(1823);
expr_func();
}
break;
case 11:
{
setState(1824);
expr_atom();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1837);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,164,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1835);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1827);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1828);
_la = _input.LA(1);
if ( !(_la==ASTERISK || _la==SLASH) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1829);
expr(14);
}
break;
case 2:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1830);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(1831);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==SUBTRACT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1832);
expr(13);
}
break;
case 3:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1833);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(1834);
interval_item();
}
break;
}
}
}
setState(1839);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,164,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_atomContext extends ParserRuleContext {
public Date_literalContext date_literal() {
return getRuleContext(Date_literalContext.class,0);
}
public Timestamp_literalContext timestamp_literal() {
return getRuleContext(Timestamp_literalContext.class,0);
}
public Bool_literalContext bool_literal() {
return getRuleContext(Bool_literalContext.class,0);
}
public QidentContext qident() {
return getRuleContext(QidentContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public Dec_numberContext dec_number() {
return getRuleContext(Dec_numberContext.class,0);
}
public Int_numberContext int_number() {
return getRuleContext(Int_numberContext.class,0);
}
public Null_constContext null_const() {
return getRuleContext(Null_constContext.class,0);
}
public Expr_atomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_atom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_atom(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_atom(this);
else return visitor.visitChildren(this);
}
}
public final Expr_atomContext expr_atom() throws RecognitionException {
Expr_atomContext _localctx = new Expr_atomContext(_ctx, getState());
enterRule(_localctx, 196, RULE_expr_atom);
try {
setState(1848);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1840);
date_literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1841);
timestamp_literal();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1842);
bool_literal();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1843);
qident();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1844);
string();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1845);
dec_number();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1846);
int_number();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1847);
null_const();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_intervalContext extends ParserRuleContext {
public TerminalNode INTERVAL() { return getToken(PLParser.INTERVAL, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Interval_itemContext interval_item() {
return getRuleContext(Interval_itemContext.class,0);
}
public Expr_intervalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_interval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_interval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_interval(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_interval(this);
else return visitor.visitChildren(this);
}
}
public final Expr_intervalContext expr_interval() throws RecognitionException {
Expr_intervalContext _localctx = new Expr_intervalContext(_ctx, getState());
enterRule(_localctx, 198, RULE_expr_interval);
try {
enterOuterAlt(_localctx, 1);
{
setState(1850);
match(INTERVAL);
setState(1851);
expr(0);
setState(1852);
interval_item();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Interval_itemContext extends ParserRuleContext {
public TerminalNode DAY() { return getToken(PLParser.DAY, 0); }
public TerminalNode DAYS() { return getToken(PLParser.DAYS, 0); }
public TerminalNode MICROSECOND() { return getToken(PLParser.MICROSECOND, 0); }
public TerminalNode MICROSECONDS() { return getToken(PLParser.MICROSECONDS, 0); }
public TerminalNode SECOND() { return getToken(PLParser.SECOND, 0); }
public TerminalNode SECONDS() { return getToken(PLParser.SECONDS, 0); }
public Interval_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interval_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInterval_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInterval_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInterval_item(this);
else return visitor.visitChildren(this);
}
}
public final Interval_itemContext interval_item() throws RecognitionException {
Interval_itemContext _localctx = new Interval_itemContext(_ctx, getState());
enterRule(_localctx, 200, RULE_interval_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1854);
_la = _input.LA(1);
if ( !(_la==DAYS || ((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & 1099511627779L) != 0) || _la==DAY || _la==SECOND) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_concatContext extends ParserRuleContext {
public List<Expr_concat_itemContext> expr_concat_item() {
return getRuleContexts(Expr_concat_itemContext.class);
}
public Expr_concat_itemContext expr_concat_item(int i) {
return getRuleContext(Expr_concat_itemContext.class,i);
}
public List<TerminalNode> DOUBLEPIPES() { return getTokens(PLParser.DOUBLEPIPES); }
public TerminalNode DOUBLEPIPES(int i) {
return getToken(PLParser.DOUBLEPIPES, i);
}
public List<TerminalNode> CONCAT() { return getTokens(PLParser.CONCAT); }
public TerminalNode CONCAT(int i) {
return getToken(PLParser.CONCAT, i);
}
public Expr_concatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_concat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_concat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_concat(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_concat(this);
else return visitor.visitChildren(this);
}
}
public final Expr_concatContext expr_concat() throws RecognitionException {
Expr_concatContext _localctx = new Expr_concatContext(_ctx, getState());
enterRule(_localctx, 202, RULE_expr_concat);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1856);
expr_concat_item();
setState(1857);
_la = _input.LA(1);
if ( !(_la==CONCAT || _la==DOUBLEPIPES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1858);
expr_concat_item();
setState(1863);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,166,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1859);
_la = _input.LA(1);
if ( !(_la==CONCAT || _la==DOUBLEPIPES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1860);
expr_concat_item();
}
}
}
setState(1865);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,166,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_concat_itemContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Expr_caseContext expr_case() {
return getRuleContext(Expr_caseContext.class,0);
}
public Expr_agg_window_funcContext expr_agg_window_func() {
return getRuleContext(Expr_agg_window_funcContext.class,0);
}
public Expr_spec_funcContext expr_spec_func() {
return getRuleContext(Expr_spec_funcContext.class,0);
}
public Expr_dotContext expr_dot() {
return getRuleContext(Expr_dotContext.class,0);
}
public Expr_funcContext expr_func() {
return getRuleContext(Expr_funcContext.class,0);
}
public Expr_atomContext expr_atom() {
return getRuleContext(Expr_atomContext.class,0);
}
public Expr_concat_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_concat_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_concat_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_concat_item(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_concat_item(this);
else return visitor.visitChildren(this);
}
}
public final Expr_concat_itemContext expr_concat_item() throws RecognitionException {
Expr_concat_itemContext _localctx = new Expr_concat_itemContext(_ctx, getState());
enterRule(_localctx, 204, RULE_expr_concat_item);
try {
setState(1876);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1866);
match(LEFT_PAREN);
setState(1867);
expr(0);
setState(1868);
match(RIGHT_PAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1870);
expr_case();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1871);
expr_agg_window_func();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1872);
expr_spec_func();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1873);
expr_dot();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1874);
expr_func();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1875);
expr_atom();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_caseContext extends ParserRuleContext {
public Expr_case_simpleContext expr_case_simple() {
return getRuleContext(Expr_case_simpleContext.class,0);
}
public Expr_case_searchedContext expr_case_searched() {
return getRuleContext(Expr_case_searchedContext.class,0);
}
public Expr_caseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_case; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_case(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_case(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_case(this);
else return visitor.visitChildren(this);
}
}
public final Expr_caseContext expr_case() throws RecognitionException {
Expr_caseContext _localctx = new Expr_caseContext(_ctx, getState());
enterRule(_localctx, 206, RULE_expr_case);
try {
setState(1880);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1878);
expr_case_simple();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1879);
expr_case_searched();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_case_simpleContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(PLParser.CASE, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode END() { return getToken(PLParser.END, 0); }
public List<TerminalNode> WHEN() { return getTokens(PLParser.WHEN); }
public TerminalNode WHEN(int i) {
return getToken(PLParser.WHEN, i);
}
public List<TerminalNode> THEN() { return getTokens(PLParser.THEN); }
public TerminalNode THEN(int i) {
return getToken(PLParser.THEN, i);
}
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public Expr_case_simpleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_case_simple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_case_simple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_case_simple(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_case_simple(this);
else return visitor.visitChildren(this);
}
}
public final Expr_case_simpleContext expr_case_simple() throws RecognitionException {
Expr_case_simpleContext _localctx = new Expr_case_simpleContext(_ctx, getState());
enterRule(_localctx, 208, RULE_expr_case_simple);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1882);
match(CASE);
setState(1883);
expr(0);
setState(1889);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1884);
match(WHEN);
setState(1885);
expr(0);
setState(1886);
match(THEN);
setState(1887);
expr(0);
}
}
setState(1891);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(1895);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1893);
match(ELSE);
setState(1894);
expr(0);
}
}
setState(1897);
match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_case_searchedContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(PLParser.CASE, 0); }
public TerminalNode END() { return getToken(PLParser.END, 0); }
public List<TerminalNode> WHEN() { return getTokens(PLParser.WHEN); }
public TerminalNode WHEN(int i) {
return getToken(PLParser.WHEN, i);
}
public List<Bool_exprContext> bool_expr() {
return getRuleContexts(Bool_exprContext.class);
}
public Bool_exprContext bool_expr(int i) {
return getRuleContext(Bool_exprContext.class,i);
}
public List<TerminalNode> THEN() { return getTokens(PLParser.THEN); }
public TerminalNode THEN(int i) {
return getToken(PLParser.THEN, i);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public Expr_case_searchedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_case_searched; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_case_searched(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_case_searched(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_case_searched(this);
else return visitor.visitChildren(this);
}
}
public final Expr_case_searchedContext expr_case_searched() throws RecognitionException {
Expr_case_searchedContext _localctx = new Expr_case_searchedContext(_ctx, getState());
enterRule(_localctx, 210, RULE_expr_case_searched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1899);
match(CASE);
setState(1905);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1900);
match(WHEN);
setState(1901);
bool_expr(0);
setState(1902);
match(THEN);
setState(1903);
expr(0);
}
}
setState(1907);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(1911);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1909);
match(ELSE);
setState(1910);
expr(0);
}
}
setState(1913);
match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_cursor_attributeContext extends ParserRuleContext {
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode MOD() { return getToken(PLParser.MOD, 0); }
public TerminalNode ISOPEN() { return getToken(PLParser.ISOPEN, 0); }
public TerminalNode FOUND() { return getToken(PLParser.FOUND, 0); }
public TerminalNode NOTFOUND() { return getToken(PLParser.NOTFOUND, 0); }
public Expr_cursor_attributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_cursor_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_cursor_attribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_cursor_attribute(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_cursor_attribute(this);
else return visitor.visitChildren(this);
}
}
public final Expr_cursor_attributeContext expr_cursor_attribute() throws RecognitionException {
Expr_cursor_attributeContext _localctx = new Expr_cursor_attributeContext(_ctx, getState());
enterRule(_localctx, 212, RULE_expr_cursor_attribute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1915);
ident_pl();
setState(1916);
match(MOD);
setState(1917);
_la = _input.LA(1);
if ( !(((((_la - 55)) & ~0x3f) == 0 && ((1L << (_la - 55)) & 274877915137L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_agg_window_funcContext extends ParserRuleContext {
public TerminalNode AVG() { return getToken(PLParser.AVG, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Expr_func_all_distinctContext expr_func_all_distinct() {
return getRuleContext(Expr_func_all_distinctContext.class,0);
}
public Expr_func_over_clauseContext expr_func_over_clause() {
return getRuleContext(Expr_func_over_clauseContext.class,0);
}
public TerminalNode COUNT() { return getToken(PLParser.COUNT, 0); }
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode COUNT_BIG() { return getToken(PLParser.COUNT_BIG, 0); }
public TerminalNode CUME_DIST() { return getToken(PLParser.CUME_DIST, 0); }
public TerminalNode DENSE_RANK() { return getToken(PLParser.DENSE_RANK, 0); }
public TerminalNode FIRST_VALUE() { return getToken(PLParser.FIRST_VALUE, 0); }
public TerminalNode LAG() { return getToken(PLParser.LAG, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode LAST_VALUE() { return getToken(PLParser.LAST_VALUE, 0); }
public TerminalNode LEAD() { return getToken(PLParser.LEAD, 0); }
public TerminalNode MAX() { return getToken(PLParser.MAX, 0); }
public TerminalNode MIN() { return getToken(PLParser.MIN, 0); }
public TerminalNode RANK() { return getToken(PLParser.RANK, 0); }
public TerminalNode ROW_NUMBER() { return getToken(PLParser.ROW_NUMBER, 0); }
public TerminalNode STDEV() { return getToken(PLParser.STDEV, 0); }
public TerminalNode SUM() { return getToken(PLParser.SUM, 0); }
public TerminalNode VAR() { return getToken(PLParser.VAR, 0); }
public TerminalNode VARIANCE() { return getToken(PLParser.VARIANCE, 0); }
public Expr_agg_window_funcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_agg_window_func; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_agg_window_func(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_agg_window_func(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_agg_window_func(this);
else return visitor.visitChildren(this);
}
}
public final Expr_agg_window_funcContext expr_agg_window_func() throws RecognitionException {
Expr_agg_window_funcContext _localctx = new Expr_agg_window_funcContext(_ctx, getState());
enterRule(_localctx, 214, RULE_expr_agg_window_func);
int _la;
try {
setState(2071);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AVG:
enterOuterAlt(_localctx, 1);
{
setState(1919);
match(AVG);
setState(1920);
match(LEFT_PAREN);
setState(1922);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1921);
expr_func_all_distinct();
}
}
setState(1924);
expr(0);
setState(1925);
match(RIGHT_PAREN);
setState(1927);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
{
setState(1926);
expr_func_over_clause();
}
break;
}
}
break;
case COUNT:
enterOuterAlt(_localctx, 2);
{
setState(1929);
match(COUNT);
setState(1930);
match(LEFT_PAREN);
setState(1936);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case MAX_PART_STRING:
case MIN_PART_STRING:
case MAX_PART_INT:
case MIN_PART_INT:
case MAX_PART_DATE:
case MIN_PART_DATE:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_PAREN:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ALL:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCT:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
{
setState(1932);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1931);
expr_func_all_distinct();
}
}
setState(1934);
expr(0);
}
}
break;
case ASTERISK:
{
setState(1935);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1938);
match(RIGHT_PAREN);
setState(1940);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
{
setState(1939);
expr_func_over_clause();
}
break;
}
}
break;
case COUNT_BIG:
enterOuterAlt(_localctx, 3);
{
setState(1942);
match(COUNT_BIG);
setState(1943);
match(LEFT_PAREN);
setState(1949);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case MAX_PART_STRING:
case MIN_PART_STRING:
case MAX_PART_INT:
case MIN_PART_INT:
case MAX_PART_DATE:
case MIN_PART_DATE:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_PAREN:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ALL:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCT:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
{
setState(1945);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1944);
expr_func_all_distinct();
}
}
setState(1947);
expr(0);
}
}
break;
case ASTERISK:
{
setState(1948);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1951);
match(RIGHT_PAREN);
setState(1953);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
{
setState(1952);
expr_func_over_clause();
}
break;
}
}
break;
case CUME_DIST:
enterOuterAlt(_localctx, 4);
{
setState(1955);
match(CUME_DIST);
setState(1956);
match(LEFT_PAREN);
setState(1957);
match(RIGHT_PAREN);
setState(1958);
expr_func_over_clause();
}
break;
case DENSE_RANK:
enterOuterAlt(_localctx, 5);
{
setState(1959);
match(DENSE_RANK);
setState(1960);
match(LEFT_PAREN);
setState(1961);
match(RIGHT_PAREN);
setState(1962);
expr_func_over_clause();
}
break;
case FIRST_VALUE:
enterOuterAlt(_localctx, 6);
{
setState(1963);
match(FIRST_VALUE);
setState(1964);
match(LEFT_PAREN);
setState(1965);
expr(0);
setState(1966);
match(RIGHT_PAREN);
setState(1967);
expr_func_over_clause();
}
break;
case LAG:
enterOuterAlt(_localctx, 7);
{
setState(1969);
match(LAG);
setState(1970);
match(LEFT_PAREN);
setState(1971);
expr(0);
setState(1978);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1972);
match(COMMA);
setState(1973);
expr(0);
setState(1976);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1974);
match(COMMA);
setState(1975);
expr(0);
}
}
}
}
setState(1980);
match(RIGHT_PAREN);
setState(1981);
expr_func_over_clause();
}
break;
case LAST_VALUE:
enterOuterAlt(_localctx, 8);
{
setState(1983);
match(LAST_VALUE);
setState(1984);
match(LEFT_PAREN);
setState(1985);
expr(0);
setState(1986);
match(RIGHT_PAREN);
setState(1987);
expr_func_over_clause();
}
break;
case LEAD:
enterOuterAlt(_localctx, 9);
{
setState(1989);
match(LEAD);
setState(1990);
match(LEFT_PAREN);
setState(1991);
expr(0);
setState(1998);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1992);
match(COMMA);
setState(1993);
expr(0);
setState(1996);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1994);
match(COMMA);
setState(1995);
expr(0);
}
}
}
}
setState(2000);
match(RIGHT_PAREN);
setState(2001);
expr_func_over_clause();
}
break;
case MAX:
enterOuterAlt(_localctx, 10);
{
setState(2003);
match(MAX);
setState(2004);
match(LEFT_PAREN);
setState(2006);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2005);
expr_func_all_distinct();
}
}
setState(2008);
expr(0);
setState(2009);
match(RIGHT_PAREN);
setState(2011);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(2010);
expr_func_over_clause();
}
break;
}
}
break;
case MIN:
enterOuterAlt(_localctx, 11);
{
setState(2013);
match(MIN);
setState(2014);
match(LEFT_PAREN);
setState(2016);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2015);
expr_func_all_distinct();
}
}
setState(2018);
expr(0);
setState(2019);
match(RIGHT_PAREN);
setState(2021);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
{
setState(2020);
expr_func_over_clause();
}
break;
}
}
break;
case RANK:
enterOuterAlt(_localctx, 12);
{
setState(2023);
match(RANK);
setState(2024);
match(LEFT_PAREN);
setState(2025);
match(RIGHT_PAREN);
setState(2026);
expr_func_over_clause();
}
break;
case ROW_NUMBER:
enterOuterAlt(_localctx, 13);
{
setState(2027);
match(ROW_NUMBER);
setState(2028);
match(LEFT_PAREN);
setState(2029);
match(RIGHT_PAREN);
setState(2030);
expr_func_over_clause();
}
break;
case STDEV:
enterOuterAlt(_localctx, 14);
{
setState(2031);
match(STDEV);
setState(2032);
match(LEFT_PAREN);
setState(2034);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2033);
expr_func_all_distinct();
}
}
setState(2036);
expr(0);
setState(2037);
match(RIGHT_PAREN);
setState(2039);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(2038);
expr_func_over_clause();
}
break;
}
}
break;
case SUM:
enterOuterAlt(_localctx, 15);
{
setState(2041);
match(SUM);
setState(2042);
match(LEFT_PAREN);
setState(2044);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2043);
expr_func_all_distinct();
}
}
setState(2046);
expr(0);
setState(2047);
match(RIGHT_PAREN);
setState(2049);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(2048);
expr_func_over_clause();
}
break;
}
}
break;
case VAR:
enterOuterAlt(_localctx, 16);
{
setState(2051);
match(VAR);
setState(2052);
match(LEFT_PAREN);
setState(2054);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2053);
expr_func_all_distinct();
}
}
setState(2056);
expr(0);
setState(2057);
match(RIGHT_PAREN);
setState(2059);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
{
setState(2058);
expr_func_over_clause();
}
break;
}
}
break;
case VARIANCE:
enterOuterAlt(_localctx, 17);
{
setState(2061);
match(VARIANCE);
setState(2062);
match(LEFT_PAREN);
setState(2064);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(2063);
expr_func_all_distinct();
}
}
setState(2066);
expr(0);
setState(2067);
match(RIGHT_PAREN);
setState(2069);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
case 1:
{
setState(2068);
expr_func_over_clause();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_func_all_distinctContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(PLParser.DISTINCT, 0); }
public Expr_func_all_distinctContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_func_all_distinct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_func_all_distinct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_func_all_distinct(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_func_all_distinct(this);
else return visitor.visitChildren(this);
}
}
public final Expr_func_all_distinctContext expr_func_all_distinct() throws RecognitionException {
Expr_func_all_distinctContext _localctx = new Expr_func_all_distinctContext(_ctx, getState());
enterRule(_localctx, 216, RULE_expr_func_all_distinct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2073);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Order_by_clauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public List<TerminalNode> ASC() { return getTokens(PLParser.ASC); }
public TerminalNode ASC(int i) {
return getToken(PLParser.ASC, i);
}
public List<TerminalNode> DESC() { return getTokens(PLParser.DESC); }
public TerminalNode DESC(int i) {
return getToken(PLParser.DESC, i);
}
public Order_by_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOrder_by_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOrder_by_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOrder_by_clause(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_clauseContext order_by_clause() throws RecognitionException {
Order_by_clauseContext _localctx = new Order_by_clauseContext(_ctx, getState());
enterRule(_localctx, 218, RULE_order_by_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2075);
match(ORDER);
setState(2076);
match(BY);
setState(2077);
expr(0);
setState(2079);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(2078);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2088);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2081);
match(COMMA);
setState(2082);
expr(0);
setState(2084);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(2083);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
setState(2090);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_func_over_clauseContext extends ParserRuleContext {
public TerminalNode OVER() { return getToken(PLParser.OVER, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Expr_func_partition_by_clauseContext expr_func_partition_by_clause() {
return getRuleContext(Expr_func_partition_by_clauseContext.class,0);
}
public Order_by_clauseContext order_by_clause() {
return getRuleContext(Order_by_clauseContext.class,0);
}
public Expr_func_over_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_func_over_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_func_over_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_func_over_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_func_over_clause(this);
else return visitor.visitChildren(this);
}
}
public final Expr_func_over_clauseContext expr_func_over_clause() throws RecognitionException {
Expr_func_over_clauseContext _localctx = new Expr_func_over_clauseContext(_ctx, getState());
enterRule(_localctx, 220, RULE_expr_func_over_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2091);
match(OVER);
setState(2092);
match(LEFT_PAREN);
setState(2094);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(2093);
expr_func_partition_by_clause();
}
}
setState(2097);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(2096);
order_by_clause();
}
}
setState(2099);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_func_partition_by_clauseContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Expr_func_partition_by_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_func_partition_by_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_func_partition_by_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_func_partition_by_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_func_partition_by_clause(this);
else return visitor.visitChildren(this);
}
}
public final Expr_func_partition_by_clauseContext expr_func_partition_by_clause() throws RecognitionException {
Expr_func_partition_by_clauseContext _localctx = new Expr_func_partition_by_clauseContext(_ctx, getState());
enterRule(_localctx, 222, RULE_expr_func_partition_by_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2101);
match(PARTITION);
setState(2102);
match(BY);
setState(2103);
expr(0);
setState(2108);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2104);
match(COMMA);
setState(2105);
expr(0);
}
}
setState(2110);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_spec_funcContext extends ParserRuleContext {
public TerminalNode ACTIVITY_COUNT() { return getToken(PLParser.ACTIVITY_COUNT, 0); }
public TerminalNode CAST() { return getToken(PLParser.CAST, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public DtypeContext dtype() {
return getRuleContext(DtypeContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Dtype_lenContext dtype_len() {
return getRuleContext(Dtype_lenContext.class,0);
}
public TerminalNode COUNT() { return getToken(PLParser.COUNT, 0); }
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode CURRENT_DATE() { return getToken(PLParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT() { return getToken(PLParser.CURRENT, 0); }
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(PLParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public TerminalNode CURRENT_USER() { return getToken(PLParser.CURRENT_USER, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public TerminalNode MAX_PART_STRING() { return getToken(PLParser.MAX_PART_STRING, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public List<TerminalNode> EQ() { return getTokens(PLParser.EQ); }
public TerminalNode EQ(int i) {
return getToken(PLParser.EQ, i);
}
public TerminalNode MIN_PART_STRING() { return getToken(PLParser.MIN_PART_STRING, 0); }
public TerminalNode MAX_PART_INT() { return getToken(PLParser.MAX_PART_INT, 0); }
public TerminalNode MIN_PART_INT() { return getToken(PLParser.MIN_PART_INT, 0); }
public TerminalNode MAX_PART_DATE() { return getToken(PLParser.MAX_PART_DATE, 0); }
public TerminalNode MIN_PART_DATE() { return getToken(PLParser.MIN_PART_DATE, 0); }
public TerminalNode PART_COUNT() { return getToken(PLParser.PART_COUNT, 0); }
public TerminalNode PART_LOC() { return getToken(PLParser.PART_LOC, 0); }
public TerminalNode TRIM() { return getToken(PLParser.TRIM, 0); }
public TerminalNode SUBSTRING() { return getToken(PLParser.SUBSTRING, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode SYSDATE() { return getToken(PLParser.SYSDATE, 0); }
public Expr_spec_funcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_spec_func; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_spec_func(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_spec_func(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_spec_func(this);
else return visitor.visitChildren(this);
}
}
public final Expr_spec_funcContext expr_spec_func() throws RecognitionException {
Expr_spec_funcContext _localctx = new Expr_spec_funcContext(_ctx, getState());
enterRule(_localctx, 224, RULE_expr_spec_func);
int _la;
try {
int _alt;
setState(2311);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2111);
match(ACTIVITY_COUNT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2112);
match(CAST);
setState(2113);
match(LEFT_PAREN);
setState(2114);
expr(0);
setState(2115);
match(AS);
setState(2116);
dtype();
setState(2118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(2117);
dtype_len();
}
}
setState(2120);
match(RIGHT_PAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2122);
match(COUNT);
setState(2123);
match(LEFT_PAREN);
setState(2126);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case MAX_PART_STRING:
case MIN_PART_STRING:
case MAX_PART_INT:
case MIN_PART_INT:
case MAX_PART_DATE:
case MIN_PART_DATE:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_PAREN:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(2124);
expr(0);
}
break;
case ASTERISK:
{
setState(2125);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2128);
match(RIGHT_PAREN);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2129);
match(CURRENT_DATE);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2130);
match(CURRENT);
setState(2131);
match(DATE);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2135);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CURRENT_TIMESTAMP:
{
setState(2132);
match(CURRENT_TIMESTAMP);
}
break;
case CURRENT:
{
setState(2133);
match(CURRENT);
setState(2134);
match(TIMESTAMP);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2141);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
{
setState(2137);
match(LEFT_PAREN);
setState(2138);
expr(0);
setState(2139);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2143);
match(CURRENT_USER);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2144);
match(CURRENT);
setState(2145);
match(USER);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2146);
match(MAX_PART_STRING);
setState(2147);
match(LEFT_PAREN);
setState(2148);
expr(0);
setState(2161);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2149);
match(COMMA);
setState(2150);
expr(0);
setState(2158);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2151);
match(COMMA);
setState(2152);
expr(0);
setState(2153);
match(EQ);
setState(2154);
expr(0);
}
}
setState(2160);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2163);
match(RIGHT_PAREN);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2165);
match(MIN_PART_STRING);
setState(2166);
match(LEFT_PAREN);
setState(2167);
expr(0);
setState(2180);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2168);
match(COMMA);
setState(2169);
expr(0);
setState(2177);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2170);
match(COMMA);
setState(2171);
expr(0);
setState(2172);
match(EQ);
setState(2173);
expr(0);
}
}
setState(2179);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2182);
match(RIGHT_PAREN);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2184);
match(MAX_PART_INT);
setState(2185);
match(LEFT_PAREN);
setState(2186);
expr(0);
setState(2199);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2187);
match(COMMA);
setState(2188);
expr(0);
setState(2196);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2189);
match(COMMA);
setState(2190);
expr(0);
setState(2191);
match(EQ);
setState(2192);
expr(0);
}
}
setState(2198);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2201);
match(RIGHT_PAREN);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2203);
match(MIN_PART_INT);
setState(2204);
match(LEFT_PAREN);
setState(2205);
expr(0);
setState(2218);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2206);
match(COMMA);
setState(2207);
expr(0);
setState(2215);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2208);
match(COMMA);
setState(2209);
expr(0);
setState(2210);
match(EQ);
setState(2211);
expr(0);
}
}
setState(2217);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2220);
match(RIGHT_PAREN);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2222);
match(MAX_PART_DATE);
setState(2223);
match(LEFT_PAREN);
setState(2224);
expr(0);
setState(2237);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2225);
match(COMMA);
setState(2226);
expr(0);
setState(2234);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2227);
match(COMMA);
setState(2228);
expr(0);
setState(2229);
match(EQ);
setState(2230);
expr(0);
}
}
setState(2236);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2239);
match(RIGHT_PAREN);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2241);
match(MIN_PART_DATE);
setState(2242);
match(LEFT_PAREN);
setState(2243);
expr(0);
setState(2256);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2244);
match(COMMA);
setState(2245);
expr(0);
setState(2253);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2246);
match(COMMA);
setState(2247);
expr(0);
setState(2248);
match(EQ);
setState(2249);
expr(0);
}
}
setState(2255);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2258);
match(RIGHT_PAREN);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(2260);
match(PART_COUNT);
setState(2261);
match(LEFT_PAREN);
setState(2262);
expr(0);
setState(2270);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2263);
match(COMMA);
setState(2264);
expr(0);
setState(2265);
match(EQ);
setState(2266);
expr(0);
}
}
setState(2272);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2273);
match(RIGHT_PAREN);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(2275);
match(PART_LOC);
setState(2276);
match(LEFT_PAREN);
setState(2277);
expr(0);
setState(2283);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(2278);
match(COMMA);
setState(2279);
expr(0);
setState(2280);
match(EQ);
setState(2281);
expr(0);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2285);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,221,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(2289);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2287);
match(COMMA);
setState(2288);
expr(0);
}
}
setState(2291);
match(RIGHT_PAREN);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(2293);
match(TRIM);
setState(2294);
match(LEFT_PAREN);
setState(2295);
expr(0);
setState(2296);
match(RIGHT_PAREN);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(2298);
match(SUBSTRING);
setState(2299);
match(LEFT_PAREN);
setState(2300);
expr(0);
setState(2301);
match(FROM);
setState(2302);
expr(0);
setState(2305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(2303);
match(FOR);
setState(2304);
expr(0);
}
}
setState(2307);
match(RIGHT_PAREN);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(2309);
match(SYSDATE);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(2310);
match(USER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_funcContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Expr_func_paramsContext expr_func_params() {
return getRuleContext(Expr_func_paramsContext.class,0);
}
public Expr_funcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_func; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_func(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_func(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_func(this);
else return visitor.visitChildren(this);
}
}
public final Expr_funcContext expr_func() throws RecognitionException {
Expr_funcContext _localctx = new Expr_funcContext(_ctx, getState());
enterRule(_localctx, 226, RULE_expr_func);
try {
enterOuterAlt(_localctx, 1);
{
setState(2313);
multipartIdentifier();
setState(2314);
match(LEFT_PAREN);
setState(2316);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
case 1:
{
setState(2315);
expr_func_params();
}
break;
}
setState(2318);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_dotContext extends ParserRuleContext {
public Expr_dot_method_callContext expr_dot_method_call() {
return getRuleContext(Expr_dot_method_callContext.class,0);
}
public Expr_dot_property_accessContext expr_dot_property_access() {
return getRuleContext(Expr_dot_property_accessContext.class,0);
}
public Expr_dotContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_dot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_dot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_dot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_dot(this);
else return visitor.visitChildren(this);
}
}
public final Expr_dotContext expr_dot() throws RecognitionException {
Expr_dotContext _localctx = new Expr_dotContext(_ctx, getState());
enterRule(_localctx, 228, RULE_expr_dot);
try {
setState(2322);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2320);
expr_dot_method_call();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2321);
expr_dot_property_access();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_dot_method_callContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public List<Expr_funcContext> expr_func() {
return getRuleContexts(Expr_funcContext.class);
}
public Expr_funcContext expr_func(int i) {
return getRuleContext(Expr_funcContext.class,i);
}
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public Expr_dot_method_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_dot_method_call; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_dot_method_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_dot_method_call(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_dot_method_call(this);
else return visitor.visitChildren(this);
}
}
public final Expr_dot_method_callContext expr_dot_method_call() throws RecognitionException {
Expr_dot_method_callContext _localctx = new Expr_dot_method_callContext(_ctx, getState());
enterRule(_localctx, 230, RULE_expr_dot_method_call);
try {
enterOuterAlt(_localctx, 1);
{
setState(2326);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
{
setState(2324);
ident_pl();
}
break;
case 2:
{
setState(2325);
expr_func();
}
break;
}
setState(2328);
match(DOT);
setState(2329);
expr_func();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_dot_property_accessContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public Expr_funcContext expr_func() {
return getRuleContext(Expr_funcContext.class,0);
}
public Expr_dot_property_accessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_dot_property_access; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_dot_property_access(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_dot_property_access(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_dot_property_access(this);
else return visitor.visitChildren(this);
}
}
public final Expr_dot_property_accessContext expr_dot_property_access() throws RecognitionException {
Expr_dot_property_accessContext _localctx = new Expr_dot_property_accessContext(_ctx, getState());
enterRule(_localctx, 232, RULE_expr_dot_property_access);
try {
enterOuterAlt(_localctx, 1);
{
setState(2333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(2331);
ident_pl();
}
break;
case 2:
{
setState(2332);
expr_func();
}
break;
}
setState(2335);
match(DOT);
setState(2336);
ident_pl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_func_paramsContext extends ParserRuleContext {
public List<Func_paramContext> func_param() {
return getRuleContexts(Func_paramContext.class);
}
public Func_paramContext func_param(int i) {
return getRuleContext(Func_paramContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public Expr_func_paramsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_func_params; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpr_func_params(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpr_func_params(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpr_func_params(this);
else return visitor.visitChildren(this);
}
}
public final Expr_func_paramsContext expr_func_params() throws RecognitionException {
Expr_func_paramsContext _localctx = new Expr_func_paramsContext(_ctx, getState());
enterRule(_localctx, 234, RULE_expr_func_params);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2338);
func_param();
setState(2343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,229,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2339);
match(COMMA);
setState(2340);
func_param();
}
}
}
setState(2345);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,229,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Func_paramContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Ident_plContext ident_pl() {
return getRuleContext(Ident_plContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public Func_paramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_func_param; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunc_param(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunc_param(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunc_param(this);
else return visitor.visitChildren(this);
}
}
public final Func_paramContext func_param() throws RecognitionException {
Func_paramContext _localctx = new Func_paramContext(_ctx, getState());
enterRule(_localctx, 236, RULE_func_param);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2346);
if (!(!_input.LT(1).getText().equalsIgnoreCase("INTO"))) throw new FailedPredicateException(this, "!_input.LT(1).getText().equalsIgnoreCase(\"INTO\")");
setState(2352);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) {
case 1:
{
setState(2347);
ident_pl();
setState(2348);
match(EQ);
setState(2350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GT) {
{
setState(2349);
match(GT);
}
}
}
break;
}
setState(2354);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Host_plContext extends ParserRuleContext {
public TerminalNode LOGICALNOT() { return getToken(PLParser.LOGICALNOT, 0); }
public Host_cmdContext host_cmd() {
return getRuleContext(Host_cmdContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(PLParser.SEMICOLON, 0); }
public Host_stmtContext host_stmt() {
return getRuleContext(Host_stmtContext.class,0);
}
public Host_plContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_host_pl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHost_pl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHost_pl(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHost_pl(this);
else return visitor.visitChildren(this);
}
}
public final Host_plContext host_pl() throws RecognitionException {
Host_plContext _localctx = new Host_plContext(_ctx, getState());
enterRule(_localctx, 238, RULE_host_pl);
try {
setState(2361);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LOGICALNOT:
enterOuterAlt(_localctx, 1);
{
setState(2356);
match(LOGICALNOT);
setState(2357);
host_cmd();
setState(2358);
match(SEMICOLON);
}
break;
case HOST:
enterOuterAlt(_localctx, 2);
{
setState(2360);
host_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Host_cmdContext extends ParserRuleContext {
public Host_cmdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_host_cmd; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHost_cmd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHost_cmd(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHost_cmd(this);
else return visitor.visitChildren(this);
}
}
public final Host_cmdContext host_cmd() throws RecognitionException {
Host_cmdContext _localctx = new Host_cmdContext(_ctx, getState());
enterRule(_localctx, 240, RULE_host_cmd);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2366);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(2363);
matchWildcard();
}
}
}
setState(2368);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Host_stmtContext extends ParserRuleContext {
public TerminalNode HOST() { return getToken(PLParser.HOST, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Host_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_host_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHost_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHost_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHost_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Host_stmtContext host_stmt() throws RecognitionException {
Host_stmtContext _localctx = new Host_stmtContext(_ctx, getState());
enterRule(_localctx, 242, RULE_host_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(2369);
match(HOST);
setState(2370);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class File_nameContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public List<QidentContext> qident() {
return getRuleContexts(QidentContext.class);
}
public QidentContext qident(int i) {
return getRuleContext(QidentContext.class,i);
}
public List<TerminalNode> SLASH() { return getTokens(PLParser.SLASH); }
public TerminalNode SLASH(int i) {
return getToken(PLParser.SLASH, i);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public File_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFile_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFile_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFile_name(this);
else return visitor.visitChildren(this);
}
}
public final File_nameContext file_name() throws RecognitionException {
File_nameContext _localctx = new File_nameContext(_ctx, getState());
enterRule(_localctx, 244, RULE_file_name);
try {
int _alt;
setState(2386);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(2372);
match(STRING_LITERAL);
}
break;
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case DOT:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case SUBTRACT:
case SLASH:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(2376);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SLASH:
{
setState(2373);
match(SLASH);
}
break;
case DOT:
{
setState(2374);
match(DOT);
setState(2375);
match(SLASH);
}
break;
case ACTION:
case ALLOCATE:
case ANSI_NULLS:
case ANSI_PADDING:
case ASSOCIATE:
case AVG:
case BATCHSIZE:
case BINARY_DOUBLE:
case BINARY_FLOAT:
case BIT:
case BODY:
case BREAK:
case BYTE:
case CALLER:
case CASCADE:
case CASESPECIFIC:
case CLIENT:
case CLOSE:
case CLUSTERED:
case CMP:
case COLLECTION:
case COMPRESS:
case CONCAT:
case CONDITION:
case CONSTANT:
case COUNT_BIG:
case CREATOR:
case CS:
case CURSOR:
case DAYS:
case DEC:
case DECLARE:
case DEFINED:
case DEFINER:
case DEFINITION:
case DELIMITED:
case DELIMITER:
case DIAGNOSTICS:
case DIR:
case DIRECTORY:
case DISTRIBUTE:
case ESCAPED:
case EXEC:
case EXCEPTION:
case EXCLUSIVE:
case EXIT:
case FALLBACK:
case FETCH:
case FILES:
case FOUND:
case GET:
case GO:
case HANDLER:
case HOST:
case IDENTITY:
case INCLUDE:
case INITRANS:
case INOUT:
case INT2:
case INT4:
case INT8:
case INVOKER:
case ISOPEN:
case ITEMS:
case KEEP:
case LANGUAGE:
case LEAVE:
case LOCATOR:
case LOCATORS:
case LOCKS:
case LOG:
case LOGGED:
case LOGGING:
case LOOP:
case MATCHED:
case MAXTRANS:
case MESSAGE_TEXT:
case MICROSECOND:
case MICROSECONDS:
case MULTISET:
case NCHAR:
case NEW:
case NVARCHAR:
case NOCOUNT:
case NOCOMPRESS:
case NOLOGGING:
case NONE:
case NOTFOUND:
case NUMERIC:
case NUMBER:
case OBJECT:
case OFF:
case OUT:
case OWNER:
case PACKAGE:
case PCTFREE:
case PCTUSED:
case PRECISION:
case PRESERVE:
case PRINT:
case QUALIFY:
case QUERY_BAND:
case QUIT:
case QUOTED_IDENTIFIER:
case RAISE:
case RESIGNAL:
case RESTRICT:
case RESULT:
case RESULT_SET_LOCATOR:
case RETURN:
case REVERSE:
case ROW_COUNT:
case RR:
case RS:
case PWD:
case SECONDS:
case SECURITY:
case SEGMENT:
case SEL:
case SESSIONS:
case SHARE:
case SIGNAL:
case SIMPLE_DOUBLE:
case SIMPLE_FLOAT:
case SMALLDATETIME:
case SQL:
case SQLEXCEPTION:
case SQLINSERT:
case SQLSTATE:
case SQLWARNING:
case STATISTICS:
case STEP:
case STORED:
case SUBDIR:
case SUBSTRING:
case SUMMARY:
case SYS_REFCURSOR:
case TABLESPACE:
case TEXTIMAGE_ON:
case TITLE:
case TOP:
case UR:
case VAR:
case VARCHAR2:
case VARYING:
case VOLATILE:
case WHILE:
case WITHOUT:
case XML:
case YES:
case ACTIVITY_COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case LAG:
case LAST_VALUE:
case LEAD:
case PART_COUNT:
case PART_LOC:
case RANK:
case ROW_NUMBER:
case STDEV:
case SYSDATE:
case VARIANCE:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEYS:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case SUBTRACT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
break;
default:
break;
}
setState(2378);
qident();
setState(2383);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2379);
match(SLASH);
setState(2380);
qident();
}
}
}
setState(2385);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Date_literalContext extends ParserRuleContext {
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public Date_literalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_date_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDate_literal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDate_literal(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDate_literal(this);
else return visitor.visitChildren(this);
}
}
public final Date_literalContext date_literal() throws RecognitionException {
Date_literalContext _localctx = new Date_literalContext(_ctx, getState());
enterRule(_localctx, 246, RULE_date_literal);
try {
enterOuterAlt(_localctx, 1);
{
setState(2388);
match(DATE);
setState(2389);
string();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Timestamp_literalContext extends ParserRuleContext {
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public Timestamp_literalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timestamp_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTimestamp_literal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTimestamp_literal(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTimestamp_literal(this);
else return visitor.visitChildren(this);
}
}
public final Timestamp_literalContext timestamp_literal() throws RecognitionException {
Timestamp_literalContext _localctx = new Timestamp_literalContext(_ctx, getState());
enterRule(_localctx, 248, RULE_timestamp_literal);
try {
enterOuterAlt(_localctx, 1);
{
setState(2391);
match(TIMESTAMP);
setState(2392);
string();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Ident_plContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public Non_reserved_wordsContext non_reserved_words() {
return getRuleContext(Non_reserved_wordsContext.class,0);
}
public NonReservedContext nonReserved() {
return getRuleContext(NonReservedContext.class,0);
}
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public Ident_plContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ident_pl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdent_pl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdent_pl(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdent_pl(this);
else return visitor.visitChildren(this);
}
}
public final Ident_plContext ident_pl() throws RecognitionException {
Ident_plContext _localctx = new Ident_plContext(_ctx, getState());
enterRule(_localctx, 250, RULE_ident_pl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(2394);
match(SUBTRACT);
}
}
setState(2400);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
case 1:
{
setState(2397);
match(IDENTIFIER);
}
break;
case 2:
{
setState(2398);
non_reserved_words();
}
break;
case 3:
{
setState(2399);
nonReserved();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QidentContext extends ParserRuleContext {
public List<Ident_plContext> ident_pl() {
return getRuleContexts(Ident_plContext.class);
}
public Ident_plContext ident_pl(int i) {
return getRuleContext(Ident_plContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(PLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(PLParser.DOT, i);
}
public QidentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qident; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQident(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQident(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQident(this);
else return visitor.visitChildren(this);
}
}
public final QidentContext qident() throws RecognitionException {
QidentContext _localctx = new QidentContext(_ctx, getState());
enterRule(_localctx, 252, RULE_qident);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2402);
ident_pl();
setState(2407);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,239,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2403);
match(DOT);
setState(2404);
ident_pl();
}
}
}
setState(2409);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,239,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitString(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitString(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 254, RULE_string);
try {
enterOuterAlt(_localctx, 1);
{
setState(2410);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Int_numberContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public TerminalNode PLUS() { return getToken(PLParser.PLUS, 0); }
public Int_numberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_int_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInt_number(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInt_number(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInt_number(this);
else return visitor.visitChildren(this);
}
}
public final Int_numberContext int_number() throws RecognitionException {
Int_numberContext _localctx = new Int_numberContext(_ctx, getState());
enterRule(_localctx, 256, RULE_int_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==SUBTRACT) {
{
setState(2412);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==SUBTRACT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2415);
match(INTEGER_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dec_numberContext extends ParserRuleContext {
public TerminalNode DECIMAL_VALUE() { return getToken(PLParser.DECIMAL_VALUE, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public TerminalNode PLUS() { return getToken(PLParser.PLUS, 0); }
public Dec_numberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dec_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDec_number(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDec_number(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDec_number(this);
else return visitor.visitChildren(this);
}
}
public final Dec_numberContext dec_number() throws RecognitionException {
Dec_numberContext _localctx = new Dec_numberContext(_ctx, getState());
enterRule(_localctx, 258, RULE_dec_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==SUBTRACT) {
{
setState(2417);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==SUBTRACT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2420);
match(DECIMAL_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_literalContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(PLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(PLParser.FALSE, 0); }
public Bool_literalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBool_literal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBool_literal(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBool_literal(this);
else return visitor.visitChildren(this);
}
}
public final Bool_literalContext bool_literal() throws RecognitionException {
Bool_literalContext _localctx = new Bool_literalContext(_ctx, getState());
enterRule(_localctx, 260, RULE_bool_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2422);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Null_constContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public Null_constContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_null_const; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNull_const(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNull_const(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNull_const(this);
else return visitor.visitChildren(this);
}
}
public final Null_constContext null_const() throws RecognitionException {
Null_constContext _localctx = new Null_constContext(_ctx, getState());
enterRule(_localctx, 262, RULE_null_const);
try {
enterOuterAlt(_localctx, 1);
{
setState(2424);
match(NULL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Non_reserved_wordsContext extends ParserRuleContext {
public TerminalNode ACTION() { return getToken(PLParser.ACTION, 0); }
public TerminalNode ACTIVITY_COUNT() { return getToken(PLParser.ACTIVITY_COUNT, 0); }
public TerminalNode ALLOCATE() { return getToken(PLParser.ALLOCATE, 0); }
public TerminalNode ANSI_NULLS() { return getToken(PLParser.ANSI_NULLS, 0); }
public TerminalNode ANSI_PADDING() { return getToken(PLParser.ANSI_PADDING, 0); }
public TerminalNode ASSOCIATE() { return getToken(PLParser.ASSOCIATE, 0); }
public TerminalNode AVG() { return getToken(PLParser.AVG, 0); }
public TerminalNode BATCHSIZE() { return getToken(PLParser.BATCHSIZE, 0); }
public TerminalNode BINARY_DOUBLE() { return getToken(PLParser.BINARY_DOUBLE, 0); }
public TerminalNode BINARY_FLOAT() { return getToken(PLParser.BINARY_FLOAT, 0); }
public TerminalNode BIT() { return getToken(PLParser.BIT, 0); }
public TerminalNode BODY() { return getToken(PLParser.BODY, 0); }
public TerminalNode BREAK() { return getToken(PLParser.BREAK, 0); }
public TerminalNode BYTE() { return getToken(PLParser.BYTE, 0); }
public TerminalNode CALLER() { return getToken(PLParser.CALLER, 0); }
public TerminalNode CASCADE() { return getToken(PLParser.CASCADE, 0); }
public TerminalNode CASESPECIFIC() { return getToken(PLParser.CASESPECIFIC, 0); }
public TerminalNode CLIENT() { return getToken(PLParser.CLIENT, 0); }
public TerminalNode CLOSE() { return getToken(PLParser.CLOSE, 0); }
public TerminalNode CLUSTERED() { return getToken(PLParser.CLUSTERED, 0); }
public TerminalNode CMP() { return getToken(PLParser.CMP, 0); }
public TerminalNode COLLECTION() { return getToken(PLParser.COLLECTION, 0); }
public TerminalNode COMPRESS() { return getToken(PLParser.COMPRESS, 0); }
public TerminalNode CONSTANT() { return getToken(PLParser.CONSTANT, 0); }
public TerminalNode CONCAT() { return getToken(PLParser.CONCAT, 0); }
public TerminalNode CONDITION() { return getToken(PLParser.CONDITION, 0); }
public TerminalNode COUNT_BIG() { return getToken(PLParser.COUNT_BIG, 0); }
public TerminalNode CREATOR() { return getToken(PLParser.CREATOR, 0); }
public TerminalNode CS() { return getToken(PLParser.CS, 0); }
public TerminalNode CUME_DIST() { return getToken(PLParser.CUME_DIST, 0); }
public TerminalNode CURRENT_DATE() { return getToken(PLParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(PLParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_USER() { return getToken(PLParser.CURRENT_USER, 0); }
public TerminalNode CURSOR() { return getToken(PLParser.CURSOR, 0); }
public TerminalNode DAYS() { return getToken(PLParser.DAYS, 0); }
public TerminalNode DEC() { return getToken(PLParser.DEC, 0); }
public TerminalNode DECLARE() { return getToken(PLParser.DECLARE, 0); }
public TerminalNode DEFINED() { return getToken(PLParser.DEFINED, 0); }
public TerminalNode DEFINER() { return getToken(PLParser.DEFINER, 0); }
public TerminalNode DEFINITION() { return getToken(PLParser.DEFINITION, 0); }
public TerminalNode DELIMITED() { return getToken(PLParser.DELIMITED, 0); }
public TerminalNode DELIMITER() { return getToken(PLParser.DELIMITER, 0); }
public TerminalNode DENSE_RANK() { return getToken(PLParser.DENSE_RANK, 0); }
public TerminalNode DIAGNOSTICS() { return getToken(PLParser.DIAGNOSTICS, 0); }
public TerminalNode DIR() { return getToken(PLParser.DIR, 0); }
public TerminalNode DIRECTORY() { return getToken(PLParser.DIRECTORY, 0); }
public TerminalNode DISTRIBUTE() { return getToken(PLParser.DISTRIBUTE, 0); }
public TerminalNode E() { return getToken(PLParser.E, 0); }
public TerminalNode ESCAPED() { return getToken(PLParser.ESCAPED, 0); }
public TerminalNode EXEC() { return getToken(PLParser.EXEC, 0); }
public TerminalNode EXCEPTION() { return getToken(PLParser.EXCEPTION, 0); }
public TerminalNode EXCLUSIVE() { return getToken(PLParser.EXCLUSIVE, 0); }
public TerminalNode EXIT() { return getToken(PLParser.EXIT, 0); }
public TerminalNode FALLBACK() { return getToken(PLParser.FALLBACK, 0); }
public TerminalNode FETCH() { return getToken(PLParser.FETCH, 0); }
public TerminalNode FILES() { return getToken(PLParser.FILES, 0); }
public TerminalNode FIRST_VALUE() { return getToken(PLParser.FIRST_VALUE, 0); }
public TerminalNode FOUND() { return getToken(PLParser.FOUND, 0); }
public TerminalNode GET() { return getToken(PLParser.GET, 0); }
public TerminalNode GO() { return getToken(PLParser.GO, 0); }
public TerminalNode HANDLER() { return getToken(PLParser.HANDLER, 0); }
public TerminalNode HOST() { return getToken(PLParser.HOST, 0); }
public TerminalNode IDENTITY() { return getToken(PLParser.IDENTITY, 0); }
public TerminalNode INCLUDE() { return getToken(PLParser.INCLUDE, 0); }
public TerminalNode INITRANS() { return getToken(PLParser.INITRANS, 0); }
public TerminalNode INOUT() { return getToken(PLParser.INOUT, 0); }
public TerminalNode INT2() { return getToken(PLParser.INT2, 0); }
public TerminalNode INT4() { return getToken(PLParser.INT4, 0); }
public TerminalNode INT8() { return getToken(PLParser.INT8, 0); }
public TerminalNode INVOKER() { return getToken(PLParser.INVOKER, 0); }
public TerminalNode ITEMS() { return getToken(PLParser.ITEMS, 0); }
public TerminalNode ISOPEN() { return getToken(PLParser.ISOPEN, 0); }
public TerminalNode KEEP() { return getToken(PLParser.KEEP, 0); }
public TerminalNode KEYS() { return getToken(PLParser.KEYS, 0); }
public TerminalNode LAG() { return getToken(PLParser.LAG, 0); }
public TerminalNode LANGUAGE() { return getToken(PLParser.LANGUAGE, 0); }
public TerminalNode LAST_VALUE() { return getToken(PLParser.LAST_VALUE, 0); }
public TerminalNode LEAD() { return getToken(PLParser.LEAD, 0); }
public TerminalNode LEAVE() { return getToken(PLParser.LEAVE, 0); }
public TerminalNode LOCATOR() { return getToken(PLParser.LOCATOR, 0); }
public TerminalNode LOCATORS() { return getToken(PLParser.LOCATORS, 0); }
public TerminalNode LOCKS() { return getToken(PLParser.LOCKS, 0); }
public TerminalNode LOG() { return getToken(PLParser.LOG, 0); }
public TerminalNode LOGGED() { return getToken(PLParser.LOGGED, 0); }
public TerminalNode LOGGING() { return getToken(PLParser.LOGGING, 0); }
public TerminalNode LOOP() { return getToken(PLParser.LOOP, 0); }
public TerminalNode MATCHED() { return getToken(PLParser.MATCHED, 0); }
public TerminalNode MAXTRANS() { return getToken(PLParser.MAXTRANS, 0); }
public TerminalNode MESSAGE_TEXT() { return getToken(PLParser.MESSAGE_TEXT, 0); }
public TerminalNode MICROSECOND() { return getToken(PLParser.MICROSECOND, 0); }
public TerminalNode MICROSECONDS() { return getToken(PLParser.MICROSECONDS, 0); }
public TerminalNode MULTISET() { return getToken(PLParser.MULTISET, 0); }
public TerminalNode NCHAR() { return getToken(PLParser.NCHAR, 0); }
public TerminalNode NEW() { return getToken(PLParser.NEW, 0); }
public TerminalNode NVARCHAR() { return getToken(PLParser.NVARCHAR, 0); }
public TerminalNode NOCOMPRESS() { return getToken(PLParser.NOCOMPRESS, 0); }
public TerminalNode NOCOUNT() { return getToken(PLParser.NOCOUNT, 0); }
public TerminalNode NOLOGGING() { return getToken(PLParser.NOLOGGING, 0); }
public TerminalNode NONE() { return getToken(PLParser.NONE, 0); }
public TerminalNode NOTFOUND() { return getToken(PLParser.NOTFOUND, 0); }
public TerminalNode NUMERIC() { return getToken(PLParser.NUMERIC, 0); }
public TerminalNode NUMBER() { return getToken(PLParser.NUMBER, 0); }
public TerminalNode OBJECT() { return getToken(PLParser.OBJECT, 0); }
public TerminalNode OFF() { return getToken(PLParser.OFF, 0); }
public TerminalNode OUT() { return getToken(PLParser.OUT, 0); }
public TerminalNode OWNER() { return getToken(PLParser.OWNER, 0); }
public TerminalNode PACKAGE() { return getToken(PLParser.PACKAGE, 0); }
public TerminalNode PART_COUNT() { return getToken(PLParser.PART_COUNT, 0); }
public TerminalNode PART_LOC() { return getToken(PLParser.PART_LOC, 0); }
public TerminalNode PCTFREE() { return getToken(PLParser.PCTFREE, 0); }
public TerminalNode PCTUSED() { return getToken(PLParser.PCTUSED, 0); }
public TerminalNode PI() { return getToken(PLParser.PI, 0); }
public TerminalNode PRECISION() { return getToken(PLParser.PRECISION, 0); }
public TerminalNode PRESERVE() { return getToken(PLParser.PRESERVE, 0); }
public TerminalNode PRINT() { return getToken(PLParser.PRINT, 0); }
public TerminalNode PWD() { return getToken(PLParser.PWD, 0); }
public TerminalNode QUALIFY() { return getToken(PLParser.QUALIFY, 0); }
public TerminalNode QUERY_BAND() { return getToken(PLParser.QUERY_BAND, 0); }
public TerminalNode QUIT() { return getToken(PLParser.QUIT, 0); }
public TerminalNode QUOTED_IDENTIFIER() { return getToken(PLParser.QUOTED_IDENTIFIER, 0); }
public TerminalNode RAISE() { return getToken(PLParser.RAISE, 0); }
public TerminalNode RANK() { return getToken(PLParser.RANK, 0); }
public TerminalNode RR() { return getToken(PLParser.RR, 0); }
public TerminalNode RESIGNAL() { return getToken(PLParser.RESIGNAL, 0); }
public TerminalNode RESTRICT() { return getToken(PLParser.RESTRICT, 0); }
public TerminalNode RESULT() { return getToken(PLParser.RESULT, 0); }
public TerminalNode RESULT_SET_LOCATOR() { return getToken(PLParser.RESULT_SET_LOCATOR, 0); }
public TerminalNode RETURN() { return getToken(PLParser.RETURN, 0); }
public TerminalNode REVERSE() { return getToken(PLParser.REVERSE, 0); }
public TerminalNode RS() { return getToken(PLParser.RS, 0); }
public TerminalNode ROW_COUNT() { return getToken(PLParser.ROW_COUNT, 0); }
public TerminalNode ROW_NUMBER() { return getToken(PLParser.ROW_NUMBER, 0); }
public TerminalNode SECONDS() { return getToken(PLParser.SECONDS, 0); }
public TerminalNode SECURITY() { return getToken(PLParser.SECURITY, 0); }
public TerminalNode SEGMENT() { return getToken(PLParser.SEGMENT, 0); }
public TerminalNode SEL() { return getToken(PLParser.SEL, 0); }
public TerminalNode SESSIONS() { return getToken(PLParser.SESSIONS, 0); }
public TerminalNode SHARE() { return getToken(PLParser.SHARE, 0); }
public TerminalNode SIGNAL() { return getToken(PLParser.SIGNAL, 0); }
public TerminalNode SIMPLE_DOUBLE() { return getToken(PLParser.SIMPLE_DOUBLE, 0); }
public TerminalNode SIMPLE_FLOAT() { return getToken(PLParser.SIMPLE_FLOAT, 0); }
public TerminalNode SMALLDATETIME() { return getToken(PLParser.SMALLDATETIME, 0); }
public TerminalNode SQL() { return getToken(PLParser.SQL, 0); }
public TerminalNode SQLEXCEPTION() { return getToken(PLParser.SQLEXCEPTION, 0); }
public TerminalNode SQLINSERT() { return getToken(PLParser.SQLINSERT, 0); }
public TerminalNode SQLSTATE() { return getToken(PLParser.SQLSTATE, 0); }
public TerminalNode SQLWARNING() { return getToken(PLParser.SQLWARNING, 0); }
public TerminalNode STATISTICS() { return getToken(PLParser.STATISTICS, 0); }
public TerminalNode STEP() { return getToken(PLParser.STEP, 0); }
public TerminalNode STDEV() { return getToken(PLParser.STDEV, 0); }
public TerminalNode STORED() { return getToken(PLParser.STORED, 0); }
public TerminalNode SUBDIR() { return getToken(PLParser.SUBDIR, 0); }
public TerminalNode SUBSTRING() { return getToken(PLParser.SUBSTRING, 0); }
public TerminalNode SUMMARY() { return getToken(PLParser.SUMMARY, 0); }
public TerminalNode SYSDATE() { return getToken(PLParser.SYSDATE, 0); }
public TerminalNode SYS_REFCURSOR() { return getToken(PLParser.SYS_REFCURSOR, 0); }
public TerminalNode TABLESPACE() { return getToken(PLParser.TABLESPACE, 0); }
public TerminalNode TEXTIMAGE_ON() { return getToken(PLParser.TEXTIMAGE_ON, 0); }
public TerminalNode TITLE() { return getToken(PLParser.TITLE, 0); }
public TerminalNode TOP() { return getToken(PLParser.TOP, 0); }
public TerminalNode UR() { return getToken(PLParser.UR, 0); }
public TerminalNode VAR() { return getToken(PLParser.VAR, 0); }
public TerminalNode VARCHAR2() { return getToken(PLParser.VARCHAR2, 0); }
public TerminalNode VARYING() { return getToken(PLParser.VARYING, 0); }
public TerminalNode VARIANCE() { return getToken(PLParser.VARIANCE, 0); }
public TerminalNode VOLATILE() { return getToken(PLParser.VOLATILE, 0); }
public TerminalNode WHILE() { return getToken(PLParser.WHILE, 0); }
public TerminalNode WITHOUT() { return getToken(PLParser.WITHOUT, 0); }
public TerminalNode XML() { return getToken(PLParser.XML, 0); }
public TerminalNode YES() { return getToken(PLParser.YES, 0); }
public Non_reserved_wordsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_non_reserved_words; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNon_reserved_words(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNon_reserved_words(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNon_reserved_words(this);
else return visitor.visitChildren(this);
}
}
public final Non_reserved_wordsContext non_reserved_words() throws RecognitionException {
Non_reserved_wordsContext _localctx = new Non_reserved_wordsContext(_ctx, getState());
enterRule(_localctx, 264, RULE_non_reserved_words);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2426);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -105555397968898L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -18014948265295873L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 4468964474224623L) != 0) || ((((_la - 288)) & ~0x3f) == 0 && ((1L << (_la - 288)) & 4398046511117L) != 0) || _la==KEYS || _la==PI) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiStatementsContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(PLParser.EOF, 0); }
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public List<StatementContext> statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public MultiStatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiStatements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMultiStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMultiStatements(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMultiStatements(this);
else return visitor.visitChildren(this);
}
}
public final MultiStatementsContext multiStatements() throws RecognitionException {
MultiStatementsContext _localctx = new MultiStatementsContext(_ctx, getState());
enterRule(_localctx, 266, RULE_multiStatements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2431);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2428);
match(SEMICOLON);
}
}
}
setState(2433);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
}
setState(2435);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 182)) & ~0x3f) == 0 && ((1L << (_la - 182)) & -4539628218229448703L) != 0) || ((((_la - 254)) & ~0x3f) == 0 && ((1L << (_la - 254)) & 234187180791039233L) != 0) || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & 36028797119627265L) != 0) || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & 4755805604551327745L) != 0) || ((((_la - 498)) & ~0x3f) == 0 && ((1L << (_la - 498)) & 145522563500507137L) != 0) || ((((_la - 563)) & ~0x3f) == 0 && ((1L << (_la - 563)) & 216471858420125765L) != 0) || ((((_la - 647)) & ~0x3f) == 0 && ((1L << (_la - 647)) & 43486832193L) != 0)) {
{
setState(2434);
statement();
}
}
setState(2445);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,245,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2438);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2437);
match(SEMICOLON);
}
}
setState(2440);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==SEMICOLON );
setState(2442);
statement();
}
}
}
setState(2447);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,245,_ctx);
}
setState(2451);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(2448);
match(SEMICOLON);
}
}
setState(2453);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2454);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SingleStatementContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(PLParser.EOF, 0); }
public List<TerminalNode> SEMICOLON() { return getTokens(PLParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(PLParser.SEMICOLON, i);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public SingleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSingleStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSingleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SingleStatementContext singleStatement() throws RecognitionException {
SingleStatementContext _localctx = new SingleStatementContext(_ctx, getState());
enterRule(_localctx, 268, RULE_singleStatement);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2459);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,247,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2456);
match(SEMICOLON);
}
}
}
setState(2461);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,247,_ctx);
}
setState(2463);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 182)) & ~0x3f) == 0 && ((1L << (_la - 182)) & -4539628218229448703L) != 0) || ((((_la - 254)) & ~0x3f) == 0 && ((1L << (_la - 254)) & 234187180791039233L) != 0) || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & 36028797119627265L) != 0) || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & 4755805604551327745L) != 0) || ((((_la - 498)) & ~0x3f) == 0 && ((1L << (_la - 498)) & 145522563500507137L) != 0) || ((((_la - 563)) & ~0x3f) == 0 && ((1L << (_la - 563)) & 216471858420125765L) != 0) || ((((_la - 647)) & ~0x3f) == 0 && ((1L << (_la - 647)) & 43486832193L) != 0)) {
{
setState(2462);
statement();
}
}
setState(2468);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(2465);
match(SEMICOLON);
}
}
setState(2470);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2471);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionWithEofContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(PLParser.EOF, 0); }
public ExpressionWithEofContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithEof; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpressionWithEof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpressionWithEof(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpressionWithEof(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionWithEofContext expressionWithEof() throws RecognitionException {
ExpressionWithEofContext _localctx = new ExpressionWithEofContext(_ctx, getState());
enterRule(_localctx, 270, RULE_expressionWithEof);
try {
enterOuterAlt(_localctx, 1);
{
setState(2473);
expression();
setState(2474);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementContext extends ParserRuleContext {
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateProcedureContext extends StatementContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateProcedureContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateProcedure(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateProcedure(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StatementBaseAliasContext extends StatementContext {
public StatementBaseContext statementBase() {
return getRuleContext(StatementBaseContext.class,0);
}
public StatementBaseAliasContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStatementBaseAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStatementBaseAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStatementBaseAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowProcedureStatusContext extends StatementContext {
public ValueExpressionContext pattern;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ShowProcedureStatusContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowProcedureStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowProcedureStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowProcedureStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateProcedureContext extends StatementContext {
public MultipartIdentifierContext name;
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public CreateProcedureContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateProcedure(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateProcedure(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowConfigContext extends StatementContext {
public Token type;
public ValueExpressionContext pattern;
public Token backendId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CONFIG() { return getToken(PLParser.CONFIG, 0); }
public TerminalNode FRONTEND() { return getToken(PLParser.FRONTEND, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowConfigContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowConfig(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowConfig(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowConfig(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CallProcedureContext extends StatementContext {
public MultipartIdentifierContext name;
public TerminalNode CALL() { return getToken(PLParser.CALL, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CallProcedureContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCallProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCallProcedure(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCallProcedure(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropProcedureContext extends StatementContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode PROCEDURE() { return getToken(PLParser.PROCEDURE, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropProcedureContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropProcedure(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropProcedure(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 272, RULE_statement);
int _la;
try {
int _alt;
setState(2550);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) {
case 1:
_localctx = new StatementBaseAliasContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2476);
statementBase();
}
break;
case 2:
_localctx = new CallProcedureContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2477);
match(CALL);
setState(2478);
((CallProcedureContext)_localctx).name = multipartIdentifier();
setState(2479);
match(LEFT_PAREN);
setState(2488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(2480);
expression();
setState(2485);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2481);
match(COMMA);
setState(2482);
expression();
}
}
setState(2487);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2490);
match(RIGHT_PAREN);
}
break;
case 3:
_localctx = new CreateProcedureContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2499);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
{
setState(2492);
match(ALTER);
}
break;
case CREATE:
{
setState(2493);
match(CREATE);
setState(2496);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(2494);
match(OR);
setState(2495);
match(REPLACE);
}
}
}
break;
case REPLACE:
{
setState(2498);
match(REPLACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2501);
_la = _input.LA(1);
if ( !(_la==PROC || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2502);
((CreateProcedureContext)_localctx).name = multipartIdentifier();
setState(2503);
match(LEFT_PAREN);
setState(2507);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,254,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(2504);
matchWildcard();
}
}
}
setState(2509);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,254,_ctx);
}
setState(2510);
match(RIGHT_PAREN);
setState(2514);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,255,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(2511);
matchWildcard();
}
}
}
setState(2516);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,255,_ctx);
}
}
break;
case 4:
_localctx = new DropProcedureContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2517);
match(DROP);
setState(2518);
_la = _input.LA(1);
if ( !(_la==PROC || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2521);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(2519);
match(IF);
setState(2520);
match(EXISTS);
}
}
setState(2523);
((DropProcedureContext)_localctx).name = multipartIdentifier();
}
break;
case 5:
_localctx = new ShowProcedureStatusContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2524);
match(SHOW);
setState(2525);
_la = _input.LA(1);
if ( !(_la==FUNCTION || _la==PROCEDURE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2526);
match(STATUS);
setState(2530);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIKE:
{
setState(2527);
match(LIKE);
setState(2528);
((ShowProcedureStatusContext)_localctx).pattern = valueExpression(0);
}
break;
case WHERE:
{
setState(2529);
whereClause();
}
break;
case EOF:
case SEMICOLON:
break;
default:
break;
}
}
break;
case 6:
_localctx = new ShowCreateProcedureContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2532);
match(SHOW);
setState(2533);
match(CREATE);
setState(2534);
match(PROCEDURE);
setState(2535);
((ShowCreateProcedureContext)_localctx).name = multipartIdentifier();
}
break;
case 7:
_localctx = new ShowConfigContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2537);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ADMIN) {
{
setState(2536);
match(ADMIN);
}
}
setState(2539);
match(SHOW);
setState(2540);
((ShowConfigContext)_localctx).type = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BACKEND || _la==FRONTEND) ) {
((ShowConfigContext)_localctx).type = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2541);
match(CONFIG);
setState(2544);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(2542);
match(LIKE);
setState(2543);
((ShowConfigContext)_localctx).pattern = valueExpression(0);
}
}
setState(2548);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(2546);
match(FROM);
setState(2547);
((ShowConfigContext)_localctx).backendId = match(INTEGER_VALUE);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementBaseContext extends ParserRuleContext {
public StatementBaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementBase; }
public StatementBaseContext() { }
public void copyFrom(StatementBaseContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedJobStatementAliasContext extends StatementBaseContext {
public SupportedJobStatementContext supportedJobStatement() {
return getRuleContext(SupportedJobStatementContext.class,0);
}
public SupportedJobStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedJobStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedJobStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedJobStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedDmlStatementAliasContext extends StatementBaseContext {
public SupportedDmlStatementContext supportedDmlStatement() {
return getRuleContext(SupportedDmlStatementContext.class,0);
}
public SupportedDmlStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedDmlStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedDmlStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedDmlStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedContext extends StatementBaseContext {
public UnsupportedStatementContext unsupportedStatement() {
return getRuleContext(UnsupportedStatementContext.class,0);
}
public UnsupportedContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnsupported(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnsupported(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnsupported(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MaterializedViewStatementAliasContext extends StatementBaseContext {
public MaterializedViewStatementContext materializedViewStatement() {
return getRuleContext(MaterializedViewStatementContext.class,0);
}
public MaterializedViewStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMaterializedViewStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMaterializedViewStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMaterializedViewStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConstraintStatementAliasContext extends StatementBaseContext {
public ConstraintStatementContext constraintStatement() {
return getRuleContext(ConstraintStatementContext.class,0);
}
public ConstraintStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterConstraintStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitConstraintStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitConstraintStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StatementDefaultContext extends StatementBaseContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public ExplainContext explain() {
return getRuleContext(ExplainContext.class,0);
}
public OutFileClauseContext outFileClause() {
return getRuleContext(OutFileClauseContext.class,0);
}
public StatementDefaultContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStatementDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStatementDefault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStatementDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedKillStatementAliasContext extends StatementBaseContext {
public SupportedKillStatementContext supportedKillStatement() {
return getRuleContext(SupportedKillStatementContext.class,0);
}
public SupportedKillStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedKillStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedKillStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedKillStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedAlterStatementAliasContext extends StatementBaseContext {
public SupportedAlterStatementContext supportedAlterStatement() {
return getRuleContext(SupportedAlterStatementContext.class,0);
}
public SupportedAlterStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedAlterStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedAlterStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedAlterStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedDropStatementAliasContext extends StatementBaseContext {
public SupportedDropStatementContext supportedDropStatement() {
return getRuleContext(SupportedDropStatementContext.class,0);
}
public SupportedDropStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedDropStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedDropStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedDropStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedCreateStatementAliasContext extends StatementBaseContext {
public SupportedCreateStatementContext supportedCreateStatement() {
return getRuleContext(SupportedCreateStatementContext.class,0);
}
public SupportedCreateStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedCreateStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedCreateStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedCreateStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedShowStatementAliasContext extends StatementBaseContext {
public SupportedShowStatementContext supportedShowStatement() {
return getRuleContext(SupportedShowStatementContext.class,0);
}
public SupportedShowStatementAliasContext(StatementBaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSupportedShowStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSupportedShowStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSupportedShowStatementAlias(this);
else return visitor.visitChildren(this);
}
}
public final StatementBaseContext statementBase() throws RecognitionException {
StatementBaseContext _localctx = new StatementBaseContext(_ctx, getState());
enterRule(_localctx, 274, RULE_statementBase);
int _la;
try {
setState(2569);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,264,_ctx) ) {
case 1:
_localctx = new StatementDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2553);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 310)) & ~0x3f) == 0 && ((1L << (_la - 310)) & 549755813891L) != 0)) {
{
setState(2552);
explain();
}
}
setState(2555);
query();
setState(2557);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) {
case 1:
{
setState(2556);
outFileClause();
}
break;
}
}
break;
case 2:
_localctx = new SupportedDmlStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2559);
supportedDmlStatement();
}
break;
case 3:
_localctx = new SupportedCreateStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2560);
supportedCreateStatement();
}
break;
case 4:
_localctx = new SupportedAlterStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2561);
supportedAlterStatement();
}
break;
case 5:
_localctx = new MaterializedViewStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2562);
materializedViewStatement();
}
break;
case 6:
_localctx = new SupportedJobStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2563);
supportedJobStatement();
}
break;
case 7:
_localctx = new ConstraintStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2564);
constraintStatement();
}
break;
case 8:
_localctx = new SupportedDropStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2565);
supportedDropStatement();
}
break;
case 9:
_localctx = new SupportedShowStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(2566);
supportedShowStatement();
}
break;
case 10:
_localctx = new SupportedKillStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(2567);
supportedKillStatement();
}
break;
case 11:
_localctx = new UnsupportedContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(2568);
unsupportedStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedStatementContext extends ParserRuleContext {
public UnsupportedSetStatementContext unsupportedSetStatement() {
return getRuleContext(UnsupportedSetStatementContext.class,0);
}
public UnsupoortedUnsetStatementContext unsupoortedUnsetStatement() {
return getRuleContext(UnsupoortedUnsetStatementContext.class,0);
}
public UnsupportedUseStatementContext unsupportedUseStatement() {
return getRuleContext(UnsupportedUseStatementContext.class,0);
}
public UnsupportedDmlStatementContext unsupportedDmlStatement() {
return getRuleContext(UnsupportedDmlStatementContext.class,0);
}
public UnsupportedDescribeStatementContext unsupportedDescribeStatement() {
return getRuleContext(UnsupportedDescribeStatementContext.class,0);
}
public UnsupportedCreateStatementContext unsupportedCreateStatement() {
return getRuleContext(UnsupportedCreateStatementContext.class,0);
}
public UnsupportedDropStatementContext unsupportedDropStatement() {
return getRuleContext(UnsupportedDropStatementContext.class,0);
}
public UnsupportedStatsStatementContext unsupportedStatsStatement() {
return getRuleContext(UnsupportedStatsStatementContext.class,0);
}
public UnsupportedAlterStatementContext unsupportedAlterStatement() {
return getRuleContext(UnsupportedAlterStatementContext.class,0);
}
public UnsupportedGrantRevokeStatementContext unsupportedGrantRevokeStatement() {
return getRuleContext(UnsupportedGrantRevokeStatementContext.class,0);
}
public UnsupportedAdminStatementContext unsupportedAdminStatement() {
return getRuleContext(UnsupportedAdminStatementContext.class,0);
}
public UnsupportedTransactionStatementContext unsupportedTransactionStatement() {
return getRuleContext(UnsupportedTransactionStatementContext.class,0);
}
public UnsupportedRecoverStatementContext unsupportedRecoverStatement() {
return getRuleContext(UnsupportedRecoverStatementContext.class,0);
}
public UnsupportedCancelStatementContext unsupportedCancelStatement() {
return getRuleContext(UnsupportedCancelStatementContext.class,0);
}
public UnsupportedJobStatementContext unsupportedJobStatement() {
return getRuleContext(UnsupportedJobStatementContext.class,0);
}
public UnsupportedCleanStatementContext unsupportedCleanStatement() {
return getRuleContext(UnsupportedCleanStatementContext.class,0);
}
public UnsupportedRefreshStatementContext unsupportedRefreshStatement() {
return getRuleContext(UnsupportedRefreshStatementContext.class,0);
}
public UnsupportedLoadStatementContext unsupportedLoadStatement() {
return getRuleContext(UnsupportedLoadStatementContext.class,0);
}
public UnsupportedShowStatementContext unsupportedShowStatement() {
return getRuleContext(UnsupportedShowStatementContext.class,0);
}
public UnsupportedOtherStatementContext unsupportedOtherStatement() {
return getRuleContext(UnsupportedOtherStatementContext.class,0);
}
public UnsupportedStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnsupportedStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnsupportedStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnsupportedStatement(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedStatementContext unsupportedStatement() throws RecognitionException {
UnsupportedStatementContext _localctx = new UnsupportedStatementContext(_ctx, getState());
enterRule(_localctx, 276, RULE_unsupportedStatement);
try {
setState(2591);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,265,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2571);
unsupportedSetStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2572);
unsupoortedUnsetStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2573);
unsupportedUseStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2574);
unsupportedDmlStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2575);
unsupportedDescribeStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2576);
unsupportedCreateStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2577);
unsupportedDropStatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2578);
unsupportedStatsStatement();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2579);
unsupportedAlterStatement();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2580);
unsupportedGrantRevokeStatement();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2581);
unsupportedAdminStatement();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2582);
unsupportedTransactionStatement();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2583);
unsupportedRecoverStatement();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2584);
unsupportedCancelStatement();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(2585);
unsupportedJobStatement();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(2586);
unsupportedCleanStatement();
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(2587);
unsupportedRefreshStatement();
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(2588);
unsupportedLoadStatement();
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(2589);
unsupportedShowStatement();
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(2590);
unsupportedOtherStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MaterializedViewStatementContext extends ParserRuleContext {
public MaterializedViewStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_materializedViewStatement; }
public MaterializedViewStatementContext() { }
public void copyFrom(MaterializedViewStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode COMPLETE() { return getToken(PLParser.COMPLETE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public RefreshMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public IdentifierContext newName;
public PropertyItemListContext fileProperties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public List<TerminalNode> MATERIALIZED() { return getTokens(PLParser.MATERIALIZED); }
public TerminalNode MATERIALIZED(int i) {
return getToken(PLParser.MATERIALIZED, i);
}
public List<TerminalNode> VIEW() { return getTokens(PLParser.VIEW); }
public TerminalNode VIEW(int i) {
return getToken(PLParser.VIEW, i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public RefreshMethodContext refreshMethod() {
return getRuleContext(RefreshMethodContext.class,0);
}
public RefreshTriggerContext refreshTrigger() {
return getRuleContext(RefreshTriggerContext.class,0);
}
public AlterMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public SimpleColumnDefsContext cols;
public IdentifierListContext keys;
public IdentifierListContext hashKeys;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public BuildModeContext buildMode() {
return getRuleContext(BuildModeContext.class,0);
}
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public List<TerminalNode> BY() { return getTokens(PLParser.BY); }
public TerminalNode BY(int i) {
return getToken(PLParser.BY, i);
}
public MvPartitionContext mvPartition() {
return getRuleContext(MvPartitionContext.class,0);
}
public TerminalNode DISTRIBUTED() { return getToken(PLParser.DISTRIBUTED, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public SimpleColumnDefsContext simpleColumnDefs() {
return getRuleContext(SimpleColumnDefsContext.class,0);
}
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public TerminalNode HASH() { return getToken(PLParser.HASH, 0); }
public TerminalNode RANDOM() { return getToken(PLParser.RANDOM, 0); }
public RefreshMethodContext refreshMethod() {
return getRuleContext(RefreshMethodContext.class,0);
}
public RefreshTriggerContext refreshTrigger() {
return getRuleContext(RefreshTriggerContext.class,0);
}
public TerminalNode DUPLICATE() { return getToken(PLParser.DUPLICATE, 0); }
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public CreateMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ResumeMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public TerminalNode RESUME() { return getToken(PLParser.RESUME, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ResumeMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResumeMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResumeMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResumeMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelMTMVTaskContext extends MaterializedViewStatementContext {
public Token taskId;
public MultipartIdentifierContext mvName;
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode TASK() { return getToken(PLParser.TASK, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public CancelMTMVTaskContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelMTMVTask(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelMTMVTask(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelMTMVTask(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PauseMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public TerminalNode PAUSE() { return getToken(PLParser.PAUSE, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PauseMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPauseMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPauseMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPauseMTMV(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropMTMVContext extends MaterializedViewStatementContext {
public MultipartIdentifierContext mvName;
public MultipartIdentifierContext tableName;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public List<MultipartIdentifierContext> multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public DropMTMVContext(MaterializedViewStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropMTMV(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropMTMV(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropMTMV(this);
else return visitor.visitChildren(this);
}
}
public final MaterializedViewStatementContext materializedViewStatement() throws RecognitionException {
MaterializedViewStatementContext _localctx = new MaterializedViewStatementContext(_ctx, getState());
enterRule(_localctx, 278, RULE_materializedViewStatement);
int _la;
try {
setState(2732);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CREATE:
_localctx = new CreateMTMVContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2593);
match(CREATE);
setState(2594);
match(MATERIALIZED);
setState(2595);
match(VIEW);
setState(2599);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(2596);
match(IF);
setState(2597);
match(NOT);
setState(2598);
match(EXISTS);
}
}
setState(2601);
((CreateMTMVContext)_localctx).mvName = multipartIdentifier();
setState(2606);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(2602);
match(LEFT_PAREN);
setState(2603);
((CreateMTMVContext)_localctx).cols = simpleColumnDefs();
setState(2604);
match(RIGHT_PAREN);
}
}
setState(2609);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BUILD) {
{
setState(2608);
buildMode();
}
}
setState(2618);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==REFRESH) {
{
setState(2611);
match(REFRESH);
setState(2613);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AUTO || _la==COMPLETE) {
{
setState(2612);
refreshMethod();
}
}
setState(2616);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(2615);
refreshTrigger();
}
}
}
}
setState(2625);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DUPLICATE || _la==KEY) {
{
setState(2621);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DUPLICATE) {
{
setState(2620);
match(DUPLICATE);
}
}
setState(2623);
match(KEY);
setState(2624);
((CreateMTMVContext)_localctx).keys = identifierList();
}
}
setState(2629);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(2627);
match(COMMENT);
setState(2628);
match(STRING_LITERAL);
}
}
setState(2637);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(2631);
match(PARTITION);
setState(2632);
match(BY);
setState(2633);
match(LEFT_PAREN);
setState(2634);
mvPartition();
setState(2635);
match(RIGHT_PAREN);
}
}
setState(2650);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTRIBUTED) {
{
setState(2639);
match(DISTRIBUTED);
setState(2640);
match(BY);
setState(2644);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HASH:
{
setState(2641);
match(HASH);
setState(2642);
((CreateMTMVContext)_localctx).hashKeys = identifierList();
}
break;
case RANDOM:
{
setState(2643);
match(RANDOM);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2648);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BUCKETS) {
{
setState(2646);
match(BUCKETS);
setState(2647);
_la = _input.LA(1);
if ( !(_la==AUTO || _la==INTEGER_VALUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
setState(2653);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROPERTIES) {
{
setState(2652);
propertyClause();
}
}
setState(2655);
match(AS);
setState(2656);
query();
}
break;
case REFRESH:
_localctx = new RefreshMTMVContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2658);
match(REFRESH);
setState(2659);
match(MATERIALIZED);
setState(2660);
match(VIEW);
setState(2661);
((RefreshMTMVContext)_localctx).mvName = multipartIdentifier();
setState(2665);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PARTITION:
case PARTITIONS:
case TEMPORARY:
{
setState(2662);
partitionSpec();
}
break;
case COMPLETE:
{
setState(2663);
match(COMPLETE);
}
break;
case AUTO:
{
setState(2664);
match(AUTO);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case ALTER:
_localctx = new AlterMTMVContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2667);
match(ALTER);
setState(2668);
match(MATERIALIZED);
setState(2669);
match(VIEW);
setState(2670);
((AlterMTMVContext)_localctx).mvName = multipartIdentifier();
setState(2694);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RENAME:
{
{
setState(2671);
match(RENAME);
setState(2672);
((AlterMTMVContext)_localctx).newName = identifier();
}
}
break;
case REFRESH:
{
{
setState(2673);
match(REFRESH);
setState(2679);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) {
case 1:
{
setState(2674);
refreshMethod();
}
break;
case 2:
{
setState(2675);
refreshTrigger();
}
break;
case 3:
{
setState(2676);
refreshMethod();
setState(2677);
refreshTrigger();
}
break;
}
}
}
break;
case REPLACE:
{
setState(2681);
match(REPLACE);
setState(2682);
match(WITH);
setState(2683);
match(MATERIALIZED);
setState(2684);
match(VIEW);
setState(2685);
((AlterMTMVContext)_localctx).newName = identifier();
setState(2687);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,282,_ctx) ) {
case 1:
{
setState(2686);
propertyClause();
}
break;
}
}
break;
case SET:
{
{
setState(2689);
match(SET);
setState(2690);
match(LEFT_PAREN);
setState(2691);
((AlterMTMVContext)_localctx).fileProperties = propertyItemList();
setState(2692);
match(RIGHT_PAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case DROP:
_localctx = new DropMTMVContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2696);
match(DROP);
setState(2697);
match(MATERIALIZED);
setState(2698);
match(VIEW);
setState(2701);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(2699);
match(IF);
setState(2700);
match(EXISTS);
}
}
setState(2703);
((DropMTMVContext)_localctx).mvName = multipartIdentifier();
setState(2706);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) {
case 1:
{
setState(2704);
match(ON);
setState(2705);
((DropMTMVContext)_localctx).tableName = multipartIdentifier();
}
break;
}
}
break;
case PAUSE:
_localctx = new PauseMTMVContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2708);
match(PAUSE);
setState(2709);
match(MATERIALIZED);
setState(2710);
match(VIEW);
setState(2711);
match(JOB);
setState(2712);
match(ON);
setState(2713);
((PauseMTMVContext)_localctx).mvName = multipartIdentifier();
}
break;
case RESUME:
_localctx = new ResumeMTMVContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2714);
match(RESUME);
setState(2715);
match(MATERIALIZED);
setState(2716);
match(VIEW);
setState(2717);
match(JOB);
setState(2718);
match(ON);
setState(2719);
((ResumeMTMVContext)_localctx).mvName = multipartIdentifier();
}
break;
case CANCEL:
_localctx = new CancelMTMVTaskContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2720);
match(CANCEL);
setState(2721);
match(MATERIALIZED);
setState(2722);
match(VIEW);
setState(2723);
match(TASK);
setState(2724);
((CancelMTMVTaskContext)_localctx).taskId = match(INTEGER_VALUE);
setState(2725);
match(ON);
setState(2726);
((CancelMTMVTaskContext)_localctx).mvName = multipartIdentifier();
}
break;
case SHOW:
_localctx = new ShowCreateMTMVContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2727);
match(SHOW);
setState(2728);
match(CREATE);
setState(2729);
match(MATERIALIZED);
setState(2730);
match(VIEW);
setState(2731);
((ShowCreateMTMVContext)_localctx).mvName = multipartIdentifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedJobStatementContext extends ParserRuleContext {
public SupportedJobStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedJobStatement; }
public SupportedJobStatementContext() { }
public void copyFrom(SupportedJobStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateScheduledJobContext extends SupportedJobStatementContext {
public MultipartIdentifierContext label;
public Token timeInterval;
public IdentifierContext timeUnit;
public Token startTime;
public Token endsTime;
public Token atTime;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode SCHEDULE() { return getToken(PLParser.SCHEDULE, 0); }
public TerminalNode DO() { return getToken(PLParser.DO, 0); }
public SupportedDmlStatementContext supportedDmlStatement() {
return getRuleContext(SupportedDmlStatementContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public TerminalNode EVERY() { return getToken(PLParser.EVERY, 0); }
public TerminalNode AT() { return getToken(PLParser.AT, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode CURRENT_TIMESTAMP() { return getToken(PLParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode STARTS() { return getToken(PLParser.STARTS, 0); }
public TerminalNode ENDS() { return getToken(PLParser.ENDS, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public CreateScheduledJobContext(SupportedJobStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateScheduledJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateScheduledJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateScheduledJob(this);
else return visitor.visitChildren(this);
}
}
public final SupportedJobStatementContext supportedJobStatement() throws RecognitionException {
SupportedJobStatementContext _localctx = new SupportedJobStatementContext(_ctx, getState());
enterRule(_localctx, 280, RULE_supportedJobStatement);
int _la;
try {
_localctx = new CreateScheduledJobContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2734);
match(CREATE);
setState(2735);
match(JOB);
setState(2736);
((CreateScheduledJobContext)_localctx).label = multipartIdentifier();
setState(2737);
match(ON);
setState(2738);
match(SCHEDULE);
setState(2758);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVERY:
{
{
setState(2739);
match(EVERY);
setState(2740);
((CreateScheduledJobContext)_localctx).timeInterval = match(INTEGER_VALUE);
setState(2741);
((CreateScheduledJobContext)_localctx).timeUnit = identifier();
setState(2747);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STARTS) {
{
setState(2742);
match(STARTS);
setState(2745);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(2743);
((CreateScheduledJobContext)_localctx).startTime = match(STRING_LITERAL);
}
break;
case CURRENT_TIMESTAMP:
{
setState(2744);
match(CURRENT_TIMESTAMP);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2751);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENDS) {
{
setState(2749);
match(ENDS);
setState(2750);
((CreateScheduledJobContext)_localctx).endsTime = match(STRING_LITERAL);
}
}
}
}
break;
case AT:
{
{
setState(2753);
match(AT);
setState(2756);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(2754);
((CreateScheduledJobContext)_localctx).atTime = match(STRING_LITERAL);
}
break;
case CURRENT_TIMESTAMP:
{
setState(2755);
match(CURRENT_TIMESTAMP);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2761);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(2760);
commentSpec();
}
}
setState(2763);
match(DO);
setState(2764);
supportedDmlStatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstraintStatementContext extends ParserRuleContext {
public ConstraintStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraintStatement; }
public ConstraintStatementContext() { }
public void copyFrom(ConstraintStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowConstraintContext extends ConstraintStatementContext {
public MultipartIdentifierContext table;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CONSTRAINTS() { return getToken(PLParser.CONSTRAINTS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowConstraintContext(ConstraintStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowConstraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropConstraintContext extends ConstraintStatementContext {
public MultipartIdentifierContext table;
public ErrorCapturingIdentifierContext constraintName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode CONSTRAINT() { return getToken(PLParser.CONSTRAINT, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public DropConstraintContext(ConstraintStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropConstraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddConstraintContext extends ConstraintStatementContext {
public MultipartIdentifierContext table;
public ErrorCapturingIdentifierContext constraintName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode CONSTRAINT() { return getToken(PLParser.CONSTRAINT, 0); }
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public AddConstraintContext(ConstraintStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddConstraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintStatementContext constraintStatement() throws RecognitionException {
ConstraintStatementContext _localctx = new ConstraintStatementContext(_ctx, getState());
enterRule(_localctx, 282, RULE_constraintStatement);
try {
setState(2785);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) {
case 1:
_localctx = new AddConstraintContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2766);
match(ALTER);
setState(2767);
match(TABLE);
setState(2768);
((AddConstraintContext)_localctx).table = multipartIdentifier();
setState(2769);
match(ADD);
setState(2770);
match(CONSTRAINT);
setState(2771);
((AddConstraintContext)_localctx).constraintName = errorCapturingIdentifier();
setState(2772);
constraint();
}
break;
case 2:
_localctx = new DropConstraintContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2774);
match(ALTER);
setState(2775);
match(TABLE);
setState(2776);
((DropConstraintContext)_localctx).table = multipartIdentifier();
setState(2777);
match(DROP);
setState(2778);
match(CONSTRAINT);
setState(2779);
((DropConstraintContext)_localctx).constraintName = errorCapturingIdentifier();
}
break;
case 3:
_localctx = new ShowConstraintContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2781);
match(SHOW);
setState(2782);
match(CONSTRAINTS);
setState(2783);
match(FROM);
setState(2784);
((ShowConstraintContext)_localctx).table = multipartIdentifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OptSpecBranchContext extends ParserRuleContext {
public IdentifierContext name;
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public TerminalNode BRANCH() { return getToken(PLParser.BRANCH, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OptSpecBranchContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optSpecBranch; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOptSpecBranch(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOptSpecBranch(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOptSpecBranch(this);
else return visitor.visitChildren(this);
}
}
public final OptSpecBranchContext optSpecBranch() throws RecognitionException {
OptSpecBranchContext _localctx = new OptSpecBranchContext(_ctx, getState());
enterRule(_localctx, 284, RULE_optSpecBranch);
try {
enterOuterAlt(_localctx, 1);
{
setState(2787);
match(ATSIGN);
setState(2788);
match(BRANCH);
setState(2789);
match(LEFT_PAREN);
setState(2790);
((OptSpecBranchContext)_localctx).name = identifier();
setState(2791);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedDmlStatementContext extends ParserRuleContext {
public SupportedDmlStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedDmlStatement; }
public SupportedDmlStatementContext() { }
public void copyFrom(SupportedDmlStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InsertTableContext extends SupportedDmlStatementContext {
public MultipartIdentifierContext tableName;
public Token tableId;
public IdentifierContext labelName;
public IdentifierListContext cols;
public IdentifierSeqContext hints;
public TerminalNode INSERT() { return getToken(PLParser.INSERT, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public TerminalNode OVERWRITE() { return getToken(PLParser.OVERWRITE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode DORIS_INTERNAL_TABLE_ID() { return getToken(PLParser.DORIS_INTERNAL_TABLE_ID, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ExplainContext explain() {
return getRuleContext(ExplainContext.class,0);
}
public CteContext cte() {
return getRuleContext(CteContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode LABEL() { return getToken(PLParser.LABEL, 0); }
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public OptSpecBranchContext optSpecBranch() {
return getRuleContext(OptSpecBranchContext.class,0);
}
public InsertTableContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInsertTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInsertTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInsertTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LoadContext extends SupportedDmlStatementContext {
public MultipartIdentifierContext lableName;
public DataDescContext dataDesc;
public List<DataDescContext> dataDescs = new ArrayList<DataDescContext>();
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode LABEL() { return getToken(PLParser.LABEL, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<DataDescContext> dataDesc() {
return getRuleContexts(DataDescContext.class);
}
public DataDescContext dataDesc(int i) {
return getRuleContext(DataDescContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public WithRemoteStorageSystemContext withRemoteStorageSystem() {
return getRuleContext(WithRemoteStorageSystemContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public LoadContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UpdateContext extends SupportedDmlStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode UPDATE() { return getToken(PLParser.UPDATE, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public UpdateAssignmentSeqContext updateAssignmentSeq() {
return getRuleContext(UpdateAssignmentSeqContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ExplainContext explain() {
return getRuleContext(ExplainContext.class,0);
}
public CteContext cte() {
return getRuleContext(CteContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public UpdateContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUpdate(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUpdate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReplayContext extends SupportedDmlStatementContext {
public ReplayCommandContext replayCommand() {
return getRuleContext(ReplayCommandContext.class,0);
}
public ReplayContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReplay(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReplay(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReplay(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DeleteContext extends SupportedDmlStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ExplainContext explain() {
return getRuleContext(ExplainContext.class,0);
}
public CteContext cte() {
return getRuleContext(CteContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public RelationsContext relations() {
return getRuleContext(RelationsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public DeleteContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDelete(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDelete(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDelete(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExportContext extends SupportedDmlStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierListContext partition;
public Token filePath;
public TerminalNode EXPORT() { return getToken(PLParser.EXPORT, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public WithRemoteStorageSystemContext withRemoteStorageSystem() {
return getRuleContext(WithRemoteStorageSystemContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExportContext(SupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExport(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExport(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExport(this);
else return visitor.visitChildren(this);
}
}
public final SupportedDmlStatementContext supportedDmlStatement() throws RecognitionException {
SupportedDmlStatementContext _localctx = new SupportedDmlStatementContext(_ctx, getState());
enterRule(_localctx, 286, RULE_supportedDmlStatement);
int _la;
try {
setState(2911);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,320,_ctx) ) {
case 1:
_localctx = new InsertTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2794);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 310)) & ~0x3f) == 0 && ((1L << (_la - 310)) & 549755813891L) != 0)) {
{
setState(2793);
explain();
}
}
setState(2797);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2796);
cte();
}
}
setState(2799);
match(INSERT);
setState(2803);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTO:
{
setState(2800);
match(INTO);
}
break;
case OVERWRITE:
{
setState(2801);
match(OVERWRITE);
setState(2802);
match(TABLE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2813);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) {
case 1:
{
setState(2805);
((InsertTableContext)_localctx).tableName = multipartIdentifier();
setState(2807);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATSIGN) {
{
setState(2806);
optSpecBranch();
}
}
}
break;
case 2:
{
setState(2809);
match(DORIS_INTERNAL_TABLE_ID);
setState(2810);
match(LEFT_PAREN);
setState(2811);
((InsertTableContext)_localctx).tableId = match(INTEGER_VALUE);
setState(2812);
match(RIGHT_PAREN);
}
break;
}
setState(2816);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION || _la==PARTITIONS || _la==TEMPORARY) {
{
setState(2815);
partitionSpec();
}
}
setState(2821);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,300,_ctx) ) {
case 1:
{
setState(2818);
match(WITH);
setState(2819);
match(LABEL);
setState(2820);
((InsertTableContext)_localctx).labelName = identifier();
}
break;
}
setState(2824);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,301,_ctx) ) {
case 1:
{
setState(2823);
((InsertTableContext)_localctx).cols = identifierList();
}
break;
}
setState(2830);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_BRACKET) {
{
setState(2826);
match(LEFT_BRACKET);
setState(2827);
((InsertTableContext)_localctx).hints = identifierSeq();
setState(2828);
match(RIGHT_BRACKET);
}
}
setState(2832);
query();
}
break;
case 2:
_localctx = new UpdateContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2834);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 310)) & ~0x3f) == 0 && ((1L << (_la - 310)) & 549755813891L) != 0)) {
{
setState(2833);
explain();
}
}
setState(2837);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2836);
cte();
}
}
setState(2839);
match(UPDATE);
setState(2840);
((UpdateContext)_localctx).tableName = multipartIdentifier();
setState(2841);
tableAlias();
setState(2842);
match(SET);
setState(2843);
updateAssignmentSeq();
setState(2845);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,305,_ctx) ) {
case 1:
{
setState(2844);
fromClause();
}
break;
}
setState(2848);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) {
case 1:
{
setState(2847);
whereClause();
}
break;
}
}
break;
case 3:
_localctx = new DeleteContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2851);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 310)) & ~0x3f) == 0 && ((1L << (_la - 310)) & 549755813891L) != 0)) {
{
setState(2850);
explain();
}
}
setState(2854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2853);
cte();
}
}
setState(2856);
match(DELETE);
setState(2857);
match(FROM);
setState(2858);
((DeleteContext)_localctx).tableName = multipartIdentifier();
setState(2860);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,309,_ctx) ) {
case 1:
{
setState(2859);
partitionSpec();
}
break;
}
setState(2862);
tableAlias();
setState(2865);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) {
case 1:
{
setState(2863);
match(USING);
setState(2864);
relations();
}
break;
}
setState(2868);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,311,_ctx) ) {
case 1:
{
setState(2867);
whereClause();
}
break;
}
}
break;
case 4:
_localctx = new LoadContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2870);
match(LOAD);
setState(2871);
match(LABEL);
setState(2872);
((LoadContext)_localctx).lableName = multipartIdentifier();
setState(2873);
match(LEFT_PAREN);
setState(2874);
((LoadContext)_localctx).dataDesc = dataDesc();
((LoadContext)_localctx).dataDescs.add(((LoadContext)_localctx).dataDesc);
setState(2879);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2875);
match(COMMA);
setState(2876);
((LoadContext)_localctx).dataDesc = dataDesc();
((LoadContext)_localctx).dataDescs.add(((LoadContext)_localctx).dataDesc);
}
}
setState(2881);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2882);
match(RIGHT_PAREN);
setState(2884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,313,_ctx) ) {
case 1:
{
setState(2883);
withRemoteStorageSystem();
}
break;
}
setState(2887);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,314,_ctx) ) {
case 1:
{
setState(2886);
propertyClause();
}
break;
}
setState(2890);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) {
case 1:
{
setState(2889);
commentSpec();
}
break;
}
}
break;
case 5:
_localctx = new ExportContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2892);
match(EXPORT);
setState(2893);
match(TABLE);
setState(2894);
((ExportContext)_localctx).tableName = multipartIdentifier();
setState(2897);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(2895);
match(PARTITION);
setState(2896);
((ExportContext)_localctx).partition = identifierList();
}
}
setState(2900);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2899);
whereClause();
}
}
setState(2902);
match(TO);
setState(2903);
((ExportContext)_localctx).filePath = match(STRING_LITERAL);
setState(2905);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,318,_ctx) ) {
case 1:
{
setState(2904);
propertyClause();
}
break;
}
setState(2908);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,319,_ctx) ) {
case 1:
{
setState(2907);
withRemoteStorageSystem();
}
break;
}
}
break;
case 6:
_localctx = new ReplayContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2910);
replayCommand();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedCreateStatementContext extends ParserRuleContext {
public SupportedCreateStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedCreateStatement; }
public SupportedCreateStatementContext() { }
public void copyFrom(SupportedCreateStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTableContext extends SupportedCreateStatementContext {
public MultipartIdentifierContext name;
public IdentifierListContext ctasCols;
public IdentifierContext engine;
public IdentifierListContext keys;
public IdentifierListContext clusterKeys;
public PartitionTableContext partition;
public IdentifierListContext hashKeys;
public Token autoBucket;
public PropertyClauseContext properties;
public PropertyClauseContext extProperties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode ENGINE() { return getToken(PLParser.ENGINE, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode DISTRIBUTED() { return getToken(PLParser.DISTRIBUTED, 0); }
public List<TerminalNode> BY() { return getTokens(PLParser.BY); }
public TerminalNode BY(int i) {
return getToken(PLParser.BY, i);
}
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public RollupDefsContext rollupDefs() {
return getRuleContext(RollupDefsContext.class,0);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode EXTERNAL() { return getToken(PLParser.EXTERNAL, 0); }
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public ColumnDefsContext columnDefs() {
return getRuleContext(ColumnDefsContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AGGREGATE() { return getToken(PLParser.AGGREGATE, 0); }
public TerminalNode UNIQUE() { return getToken(PLParser.UNIQUE, 0); }
public TerminalNode DUPLICATE() { return getToken(PLParser.DUPLICATE, 0); }
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public PartitionTableContext partitionTable() {
return getRuleContext(PartitionTableContext.class,0);
}
public List<PropertyClauseContext> propertyClause() {
return getRuleContexts(PropertyClauseContext.class);
}
public PropertyClauseContext propertyClause(int i) {
return getRuleContext(PropertyClauseContext.class,i);
}
public TerminalNode HASH() { return getToken(PLParser.HASH, 0); }
public TerminalNode RANDOM() { return getToken(PLParser.RANDOM, 0); }
public TerminalNode CLUSTER() { return getToken(PLParser.CLUSTER, 0); }
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public IndexDefsContext indexDefs() {
return getRuleContext(IndexDefsContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public CreateTableContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTableLikeContext extends SupportedCreateStatementContext {
public MultipartIdentifierContext name;
public MultipartIdentifierContext existedTable;
public IdentifierListContext rollupNames;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public List<MultipartIdentifierContext> multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public TerminalNode EXTERNAL() { return getToken(PLParser.EXTERNAL, 0); }
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public CreateTableLikeContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateTableLike(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateTableLike(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateTableLike(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateViewContext extends SupportedCreateStatementContext {
public MultipartIdentifierContext name;
public SimpleColumnDefsContext cols;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public SimpleColumnDefsContext simpleColumnDefs() {
return getRuleContext(SimpleColumnDefsContext.class,0);
}
public CreateViewContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateIndexAnalyzerContext extends SupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ANALYZER() { return getToken(PLParser.ANALYZER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateIndexAnalyzerContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateIndexAnalyzer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateIndexAnalyzer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateIndexAnalyzer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateIndexTokenizerContext extends SupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKENIZER() { return getToken(PLParser.TOKENIZER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateIndexTokenizerContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateIndexTokenizer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateIndexTokenizer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateIndexTokenizer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateRowPolicyContext extends SupportedCreateStatementContext {
public IdentifierContext name;
public MultipartIdentifierContext table;
public Token type;
public UserIdentifyContext user;
public IdentifierContext roleName;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ROW() { return getToken(PLParser.ROW, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode RESTRICTIVE() { return getToken(PLParser.RESTRICTIVE, 0); }
public TerminalNode PERMISSIVE() { return getToken(PLParser.PERMISSIVE, 0); }
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public CreateRowPolicyContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateRowPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateRowPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateRowPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateIndexTokenFilterContext extends SupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKEN_FILTER() { return getToken(PLParser.TOKEN_FILTER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateIndexTokenFilterContext(SupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateIndexTokenFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateIndexTokenFilter(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateIndexTokenFilter(this);
else return visitor.visitChildren(this);
}
}
public final SupportedCreateStatementContext supportedCreateStatement() throws RecognitionException {
SupportedCreateStatementContext _localctx = new SupportedCreateStatementContext(_ctx, getState());
enterRule(_localctx, 288, RULE_supportedCreateStatement);
int _la;
try {
setState(3104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,356,_ctx) ) {
case 1:
_localctx = new CreateTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2913);
match(CREATE);
setState(2915);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL || _la==TEMPORARY) {
{
setState(2914);
_la = _input.LA(1);
if ( !(_la==EXTERNAL || _la==TEMPORARY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2917);
match(TABLE);
setState(2921);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(2918);
match(IF);
setState(2919);
match(NOT);
setState(2920);
match(EXISTS);
}
}
setState(2923);
((CreateTableContext)_localctx).name = multipartIdentifier();
setState(2938);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) {
case 1:
{
setState(2925);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,323,_ctx) ) {
case 1:
{
setState(2924);
((CreateTableContext)_localctx).ctasCols = identifierList();
}
break;
}
}
break;
case 2:
{
{
setState(2927);
match(LEFT_PAREN);
setState(2928);
columnDefs();
setState(2931);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) {
case 1:
{
setState(2929);
match(COMMA);
setState(2930);
indexDefs();
}
break;
}
setState(2934);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2933);
match(COMMA);
}
}
setState(2936);
match(RIGHT_PAREN);
}
}
break;
}
setState(2943);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,327,_ctx) ) {
case 1:
{
setState(2940);
match(ENGINE);
setState(2941);
match(EQ);
setState(2942);
((CreateTableContext)_localctx).engine = identifier();
}
break;
}
setState(2953);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,329,_ctx) ) {
case 1:
{
setState(2945);
_la = _input.LA(1);
if ( !(_la==AGGREGATE || _la==DUPLICATE || _la==UNIQUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2946);
match(KEY);
setState(2947);
((CreateTableContext)_localctx).keys = identifierList();
setState(2951);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) {
case 1:
{
setState(2948);
match(CLUSTER);
setState(2949);
match(BY);
setState(2950);
((CreateTableContext)_localctx).clusterKeys = identifierList();
}
break;
}
}
break;
}
setState(2957);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,330,_ctx) ) {
case 1:
{
setState(2955);
match(COMMENT);
setState(2956);
match(STRING_LITERAL);
}
break;
}
setState(2960);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,331,_ctx) ) {
case 1:
{
setState(2959);
((CreateTableContext)_localctx).partition = partitionTable();
}
break;
}
setState(2976);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,335,_ctx) ) {
case 1:
{
setState(2962);
match(DISTRIBUTED);
setState(2963);
match(BY);
setState(2967);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HASH:
{
setState(2964);
match(HASH);
setState(2965);
((CreateTableContext)_localctx).hashKeys = identifierList();
}
break;
case RANDOM:
{
setState(2966);
match(RANDOM);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2974);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,334,_ctx) ) {
case 1:
{
setState(2969);
match(BUCKETS);
setState(2972);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
{
setState(2970);
match(INTEGER_VALUE);
}
break;
case AUTO:
{
setState(2971);
((CreateTableContext)_localctx).autoBucket = match(AUTO);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
}
setState(2983);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,336,_ctx) ) {
case 1:
{
setState(2978);
match(ROLLUP);
setState(2979);
match(LEFT_PAREN);
setState(2980);
rollupDefs();
setState(2981);
match(RIGHT_PAREN);
}
break;
}
setState(2986);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,337,_ctx) ) {
case 1:
{
setState(2985);
((CreateTableContext)_localctx).properties = propertyClause();
}
break;
}
setState(2990);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,338,_ctx) ) {
case 1:
{
setState(2988);
match(BROKER);
setState(2989);
((CreateTableContext)_localctx).extProperties = propertyClause();
}
break;
}
setState(2994);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,339,_ctx) ) {
case 1:
{
setState(2992);
match(AS);
setState(2993);
query();
}
break;
}
}
break;
case 2:
_localctx = new CreateViewContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2996);
match(CREATE);
setState(2999);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(2997);
match(OR);
setState(2998);
match(REPLACE);
}
}
setState(3001);
match(VIEW);
setState(3005);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3002);
match(IF);
setState(3003);
match(NOT);
setState(3004);
match(EXISTS);
}
}
setState(3007);
((CreateViewContext)_localctx).name = multipartIdentifier();
setState(3012);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(3008);
match(LEFT_PAREN);
setState(3009);
((CreateViewContext)_localctx).cols = simpleColumnDefs();
setState(3010);
match(RIGHT_PAREN);
}
}
setState(3016);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(3014);
match(COMMENT);
setState(3015);
match(STRING_LITERAL);
}
}
setState(3018);
match(AS);
setState(3019);
query();
}
break;
case 3:
_localctx = new CreateTableLikeContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3021);
match(CREATE);
setState(3023);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL || _la==TEMPORARY) {
{
setState(3022);
_la = _input.LA(1);
if ( !(_la==EXTERNAL || _la==TEMPORARY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(3025);
match(TABLE);
setState(3029);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3026);
match(IF);
setState(3027);
match(NOT);
setState(3028);
match(EXISTS);
}
}
setState(3031);
((CreateTableLikeContext)_localctx).name = multipartIdentifier();
setState(3032);
match(LIKE);
setState(3033);
((CreateTableLikeContext)_localctx).existedTable = multipartIdentifier();
setState(3039);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,347,_ctx) ) {
case 1:
{
setState(3034);
match(WITH);
setState(3035);
match(ROLLUP);
setState(3037);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,346,_ctx) ) {
case 1:
{
setState(3036);
((CreateTableLikeContext)_localctx).rollupNames = identifierList();
}
break;
}
}
break;
}
}
break;
case 4:
_localctx = new CreateRowPolicyContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(3041);
match(CREATE);
setState(3042);
match(ROW);
setState(3043);
match(POLICY);
setState(3047);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3044);
match(IF);
setState(3045);
match(NOT);
setState(3046);
match(EXISTS);
}
}
setState(3049);
((CreateRowPolicyContext)_localctx).name = identifier();
setState(3050);
match(ON);
setState(3051);
((CreateRowPolicyContext)_localctx).table = multipartIdentifier();
setState(3052);
match(AS);
setState(3053);
((CreateRowPolicyContext)_localctx).type = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PERMISSIVE || _la==RESTRICTIVE) ) {
((CreateRowPolicyContext)_localctx).type = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3054);
match(TO);
setState(3058);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(3055);
((CreateRowPolicyContext)_localctx).user = userIdentify();
}
break;
case ROLE:
{
setState(3056);
match(ROLE);
setState(3057);
((CreateRowPolicyContext)_localctx).roleName = identifier();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3060);
match(USING);
setState(3061);
match(LEFT_PAREN);
setState(3062);
booleanExpression(0);
setState(3063);
match(RIGHT_PAREN);
}
break;
case 5:
_localctx = new CreateIndexAnalyzerContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(3065);
match(CREATE);
setState(3066);
match(INVERTED);
setState(3067);
match(INDEX);
setState(3068);
match(ANALYZER);
setState(3072);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3069);
match(IF);
setState(3070);
match(NOT);
setState(3071);
match(EXISTS);
}
}
setState(3074);
((CreateIndexAnalyzerContext)_localctx).name = identifier();
setState(3076);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,351,_ctx) ) {
case 1:
{
setState(3075);
((CreateIndexAnalyzerContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 6:
_localctx = new CreateIndexTokenizerContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(3078);
match(CREATE);
setState(3079);
match(INVERTED);
setState(3080);
match(INDEX);
setState(3081);
match(TOKENIZER);
setState(3085);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3082);
match(IF);
setState(3083);
match(NOT);
setState(3084);
match(EXISTS);
}
}
setState(3087);
((CreateIndexTokenizerContext)_localctx).name = identifier();
setState(3089);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,353,_ctx) ) {
case 1:
{
setState(3088);
((CreateIndexTokenizerContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 7:
_localctx = new CreateIndexTokenFilterContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(3091);
match(CREATE);
setState(3092);
match(INVERTED);
setState(3093);
match(INDEX);
setState(3094);
match(TOKEN_FILTER);
setState(3098);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3095);
match(IF);
setState(3096);
match(NOT);
setState(3097);
match(EXISTS);
}
}
setState(3100);
((CreateIndexTokenFilterContext)_localctx).name = identifier();
setState(3102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,355,_ctx) ) {
case 1:
{
setState(3101);
((CreateIndexTokenFilterContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedAlterStatementContext extends ParserRuleContext {
public SupportedAlterStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedAlterStatement; }
public SupportedAlterStatementContext() { }
public void copyFrom(SupportedAlterStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterSystemRenameComputeGroupContext extends SupportedAlterStatementContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode SYSTEM() { return getToken(PLParser.SYSTEM, 0); }
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public TerminalNode COMPUTE() { return getToken(PLParser.COMPUTE, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public AlterSystemRenameComputeGroupContext(SupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterSystemRenameComputeGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterSystemRenameComputeGroup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterSystemRenameComputeGroup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterViewContext extends SupportedAlterStatementContext {
public MultipartIdentifierContext name;
public SimpleColumnDefsContext cols;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SimpleColumnDefsContext simpleColumnDefs() {
return getRuleContext(SimpleColumnDefsContext.class,0);
}
public AlterViewContext(SupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterStorageVaultContext extends SupportedAlterStatementContext {
public MultipartIdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterStorageVaultContext(SupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterStorageVault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterStorageVault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterStorageVault(this);
else return visitor.visitChildren(this);
}
}
public final SupportedAlterStatementContext supportedAlterStatement() throws RecognitionException {
SupportedAlterStatementContext _localctx = new SupportedAlterStatementContext(_ctx, getState());
enterRule(_localctx, 290, RULE_supportedAlterStatement);
int _la;
try {
setState(3138);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,360,_ctx) ) {
case 1:
_localctx = new AlterViewContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3106);
match(ALTER);
setState(3107);
match(VIEW);
setState(3108);
((AlterViewContext)_localctx).name = multipartIdentifier();
setState(3122);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MODIFY:
{
setState(3109);
match(MODIFY);
setState(3110);
commentSpec();
}
break;
case LEFT_PAREN:
case AS:
case COMMENT:
{
setState(3115);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(3111);
match(LEFT_PAREN);
setState(3112);
((AlterViewContext)_localctx).cols = simpleColumnDefs();
setState(3113);
match(RIGHT_PAREN);
}
}
setState(3118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(3117);
commentSpec();
}
}
setState(3120);
match(AS);
setState(3121);
query();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
_localctx = new AlterStorageVaultContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3124);
match(ALTER);
setState(3125);
match(STORAGE);
setState(3126);
match(VAULT);
setState(3127);
((AlterStorageVaultContext)_localctx).name = multipartIdentifier();
setState(3128);
((AlterStorageVaultContext)_localctx).properties = propertyClause();
}
break;
case 3:
_localctx = new AlterSystemRenameComputeGroupContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3130);
match(ALTER);
setState(3131);
match(SYSTEM);
setState(3132);
match(RENAME);
setState(3133);
match(COMPUTE);
setState(3134);
match(GROUP);
setState(3135);
((AlterSystemRenameComputeGroupContext)_localctx).name = identifier();
setState(3136);
((AlterSystemRenameComputeGroupContext)_localctx).newName = identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedDropStatementContext extends ParserRuleContext {
public SupportedDropStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedDropStatement; }
public SupportedDropStatementContext() { }
public void copyFrom(SupportedDropStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropRoleContext extends SupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropRoleContext(SupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropRole(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropRole(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropIndexAnalyzerContext extends SupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ANALYZER() { return getToken(PLParser.ANALYZER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropIndexAnalyzerContext(SupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropIndexAnalyzer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropIndexAnalyzer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropIndexAnalyzer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropIndexTokenizerContext extends SupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKENIZER() { return getToken(PLParser.TOKENIZER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropIndexTokenizerContext(SupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropIndexTokenizer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropIndexTokenizer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropIndexTokenizer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropCatalogRecycleBinContext extends SupportedDropStatementContext {
public Token idType;
public Token id;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode RECYCLE() { return getToken(PLParser.RECYCLE, 0); }
public TerminalNode BIN() { return getToken(PLParser.BIN, 0); }
public TerminalNode WHERE() { return getToken(PLParser.WHERE, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public DropCatalogRecycleBinContext(SupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropCatalogRecycleBin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropCatalogRecycleBin(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropCatalogRecycleBin(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropIndexTokenFilterContext extends SupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKEN_FILTER() { return getToken(PLParser.TOKEN_FILTER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropIndexTokenFilterContext(SupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropIndexTokenFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropIndexTokenFilter(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropIndexTokenFilter(this);
else return visitor.visitChildren(this);
}
}
public final SupportedDropStatementContext supportedDropStatement() throws RecognitionException {
SupportedDropStatementContext _localctx = new SupportedDropStatementContext(_ctx, getState());
enterRule(_localctx, 292, RULE_supportedDropStatement);
int _la;
try {
setState(3182);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,365,_ctx) ) {
case 1:
_localctx = new DropCatalogRecycleBinContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3140);
match(DROP);
setState(3141);
match(CATALOG);
setState(3142);
match(RECYCLE);
setState(3143);
match(BIN);
setState(3144);
match(WHERE);
setState(3145);
((DropCatalogRecycleBinContext)_localctx).idType = match(STRING_LITERAL);
setState(3146);
match(EQ);
setState(3147);
((DropCatalogRecycleBinContext)_localctx).id = match(INTEGER_VALUE);
}
break;
case 2:
_localctx = new DropRoleContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3148);
match(DROP);
setState(3149);
match(ROLE);
setState(3152);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3150);
match(IF);
setState(3151);
match(EXISTS);
}
}
setState(3154);
((DropRoleContext)_localctx).name = identifier();
}
break;
case 3:
_localctx = new DropIndexAnalyzerContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3155);
match(DROP);
setState(3156);
match(INVERTED);
setState(3157);
match(INDEX);
setState(3158);
match(ANALYZER);
setState(3161);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3159);
match(IF);
setState(3160);
match(EXISTS);
}
}
setState(3163);
((DropIndexAnalyzerContext)_localctx).name = identifier();
}
break;
case 4:
_localctx = new DropIndexTokenizerContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(3164);
match(DROP);
setState(3165);
match(INVERTED);
setState(3166);
match(INDEX);
setState(3167);
match(TOKENIZER);
setState(3170);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3168);
match(IF);
setState(3169);
match(EXISTS);
}
}
setState(3172);
((DropIndexTokenizerContext)_localctx).name = identifier();
}
break;
case 5:
_localctx = new DropIndexTokenFilterContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(3173);
match(DROP);
setState(3174);
match(INVERTED);
setState(3175);
match(INDEX);
setState(3176);
match(TOKEN_FILTER);
setState(3179);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(3177);
match(IF);
setState(3178);
match(EXISTS);
}
}
setState(3181);
((DropIndexTokenFilterContext)_localctx).name = identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedShowStatementContext extends ParserRuleContext {
public SupportedShowStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedShowStatement; }
public SupportedShowStatementContext() { }
public void copyFrom(SupportedShowStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowIndexTokenFilterContext extends SupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKEN_FILTER() { return getToken(PLParser.TOKEN_FILTER, 0); }
public ShowIndexTokenFilterContext(SupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowIndexTokenFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowIndexTokenFilter(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowIndexTokenFilter(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowIndexAnalyzerContext extends SupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ANALYZER() { return getToken(PLParser.ANALYZER, 0); }
public ShowIndexAnalyzerContext(SupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowIndexAnalyzer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowIndexAnalyzer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowIndexAnalyzer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowIndexTokenizerContext extends SupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode TOKENIZER() { return getToken(PLParser.TOKENIZER, 0); }
public ShowIndexTokenizerContext(SupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowIndexTokenizer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowIndexTokenizer(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowIndexTokenizer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowViewContext extends SupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public List<TerminalNode> FROM() { return getTokens(PLParser.FROM); }
public TerminalNode FROM(int i) {
return getToken(PLParser.FROM, i);
}
public List<TerminalNode> IN() { return getTokens(PLParser.IN); }
public TerminalNode IN(int i) {
return getToken(PLParser.IN, i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowViewContext(SupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowView(this);
else return visitor.visitChildren(this);
}
}
public final SupportedShowStatementContext supportedShowStatement() throws RecognitionException {
SupportedShowStatementContext _localctx = new SupportedShowStatementContext(_ctx, getState());
enterRule(_localctx, 294, RULE_supportedShowStatement);
int _la;
try {
setState(3204);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,367,_ctx) ) {
case 1:
_localctx = new ShowViewContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3184);
match(SHOW);
setState(3185);
match(VIEW);
setState(3186);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3187);
((ShowViewContext)_localctx).tableName = multipartIdentifier();
setState(3190);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,366,_ctx) ) {
case 1:
{
setState(3188);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3189);
((ShowViewContext)_localctx).database = identifier();
}
break;
}
}
break;
case 2:
_localctx = new ShowIndexAnalyzerContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3192);
match(SHOW);
setState(3193);
match(INVERTED);
setState(3194);
match(INDEX);
setState(3195);
match(ANALYZER);
}
break;
case 3:
_localctx = new ShowIndexTokenizerContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3196);
match(SHOW);
setState(3197);
match(INVERTED);
setState(3198);
match(INDEX);
setState(3199);
match(TOKENIZER);
}
break;
case 4:
_localctx = new ShowIndexTokenFilterContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(3200);
match(SHOW);
setState(3201);
match(INVERTED);
setState(3202);
match(INDEX);
setState(3203);
match(TOKEN_FILTER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SupportedKillStatementContext extends ParserRuleContext {
public SupportedKillStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_supportedKillStatement; }
public SupportedKillStatementContext() { }
public void copyFrom(SupportedKillStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class KillQueryContext extends SupportedKillStatementContext {
public TerminalNode KILL() { return getToken(PLParser.KILL, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public KillQueryContext(SupportedKillStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterKillQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitKillQuery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitKillQuery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class KillConnectionContext extends SupportedKillStatementContext {
public TerminalNode KILL() { return getToken(PLParser.KILL, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode CONNECTION() { return getToken(PLParser.CONNECTION, 0); }
public KillConnectionContext(SupportedKillStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterKillConnection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitKillConnection(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitKillConnection(this);
else return visitor.visitChildren(this);
}
}
public final SupportedKillStatementContext supportedKillStatement() throws RecognitionException {
SupportedKillStatementContext _localctx = new SupportedKillStatementContext(_ctx, getState());
enterRule(_localctx, 296, RULE_supportedKillStatement);
int _la;
try {
setState(3214);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,369,_ctx) ) {
case 1:
_localctx = new KillConnectionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3206);
match(KILL);
setState(3208);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONNECTION) {
{
setState(3207);
match(CONNECTION);
}
}
setState(3210);
match(INTEGER_VALUE);
}
break;
case 2:
_localctx = new KillQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3211);
match(KILL);
setState(3212);
match(QUERY);
setState(3213);
_la = _input.LA(1);
if ( !(_la==STRING_LITERAL || _la==INTEGER_VALUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedOtherStatementContext extends ParserRuleContext {
public UnsupportedOtherStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedOtherStatement; }
public UnsupportedOtherStatementContext() { }
public void copyFrom(UnsupportedOtherStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class HelpContext extends UnsupportedOtherStatementContext {
public IdentifierOrTextContext mark;
public TerminalNode HELP() { return getToken(PLParser.HELP, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public HelpContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHelp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHelp(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHelp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UninstallPluginContext extends UnsupportedOtherStatementContext {
public IdentifierOrTextContext name;
public TerminalNode UNINSTALL() { return getToken(PLParser.UNINSTALL, 0); }
public TerminalNode PLUGIN() { return getToken(PLParser.PLUGIN, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public UninstallPluginContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUninstallPlugin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUninstallPlugin(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUninstallPlugin(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnlockTablesContext extends UnsupportedOtherStatementContext {
public TerminalNode UNLOCK() { return getToken(PLParser.UNLOCK, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public UnlockTablesContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnlockTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnlockTables(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnlockTables(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BackupContext extends UnsupportedOtherStatementContext {
public MultipartIdentifierContext label;
public IdentifierContext repo;
public PropertyClauseContext properties;
public TerminalNode BACKUP() { return getToken(PLParser.BACKUP, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<BaseTableRefContext> baseTableRef() {
return getRuleContexts(BaseTableRefContext.class);
}
public BaseTableRefContext baseTableRef(int i) {
return getRuleContext(BaseTableRefContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode EXCLUDE() { return getToken(PLParser.EXCLUDE, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public BackupContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBackup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBackup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBackup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LockTablesContext extends UnsupportedOtherStatementContext {
public TerminalNode LOCK() { return getToken(PLParser.LOCK, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public List<LockTableContext> lockTable() {
return getRuleContexts(LockTableContext.class);
}
public LockTableContext lockTable(int i) {
return getRuleContext(LockTableContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public LockTablesContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLockTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLockTables(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLockTables(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RestoreContext extends UnsupportedOtherStatementContext {
public MultipartIdentifierContext label;
public IdentifierContext repo;
public PropertyClauseContext properties;
public TerminalNode RESTORE() { return getToken(PLParser.RESTORE, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<BaseTableRefContext> baseTableRef() {
return getRuleContexts(BaseTableRefContext.class);
}
public BaseTableRefContext baseTableRef(int i) {
return getRuleContext(BaseTableRefContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode EXCLUDE() { return getToken(PLParser.EXCLUDE, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public RestoreContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRestore(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRestore(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRestore(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InstallPluginContext extends UnsupportedOtherStatementContext {
public IdentifierOrTextContext source;
public PropertyClauseContext properties;
public TerminalNode INSTALL() { return getToken(PLParser.INSTALL, 0); }
public TerminalNode PLUGIN() { return getToken(PLParser.PLUGIN, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public InstallPluginContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInstallPlugin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInstallPlugin(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInstallPlugin(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class WarmUpClusterContext extends UnsupportedOtherStatementContext {
public IdentifierContext destination;
public IdentifierContext source;
public PropertyClauseContext properties;
public TerminalNode WARM() { return getToken(PLParser.WARM, 0); }
public TerminalNode UP() { return getToken(PLParser.UP, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List<TerminalNode> CLUSTER() { return getTokens(PLParser.CLUSTER); }
public TerminalNode CLUSTER(int i) {
return getToken(PLParser.CLUSTER, i);
}
public List<TerminalNode> COMPUTE() { return getTokens(PLParser.COMPUTE); }
public TerminalNode COMPUTE(int i) {
return getToken(PLParser.COMPUTE, i);
}
public List<TerminalNode> GROUP() { return getTokens(PLParser.GROUP); }
public TerminalNode GROUP(int i) {
return getToken(PLParser.GROUP, i);
}
public TerminalNode FORCE() { return getToken(PLParser.FORCE, 0); }
public List<WarmUpItemContext> warmUpItem() {
return getRuleContexts(WarmUpItemContext.class);
}
public WarmUpItemContext warmUpItem(int i) {
return getRuleContext(WarmUpItemContext.class,i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public List<TerminalNode> AND() { return getTokens(PLParser.AND); }
public TerminalNode AND(int i) {
return getToken(PLParser.AND, i);
}
public WarmUpClusterContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWarmUpCluster(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWarmUpCluster(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWarmUpCluster(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedStartTransactionContext extends UnsupportedOtherStatementContext {
public TerminalNode START() { return getToken(PLParser.START, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode CONSISTENT() { return getToken(PLParser.CONSISTENT, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public UnsupportedStartTransactionContext(UnsupportedOtherStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnsupportedStartTransaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnsupportedStartTransaction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnsupportedStartTransaction(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedOtherStatementContext unsupportedOtherStatement() throws RecognitionException {
UnsupportedOtherStatementContext _localctx = new UnsupportedOtherStatementContext(_ctx, getState());
enterRule(_localctx, 298, RULE_unsupportedOtherStatement);
int _la;
try {
int _alt;
setState(3324);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HELP:
_localctx = new HelpContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3216);
match(HELP);
setState(3217);
((HelpContext)_localctx).mark = identifierOrText();
}
break;
case INSTALL:
_localctx = new InstallPluginContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3218);
match(INSTALL);
setState(3219);
match(PLUGIN);
setState(3220);
match(FROM);
setState(3221);
((InstallPluginContext)_localctx).source = identifierOrText();
setState(3223);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,370,_ctx) ) {
case 1:
{
setState(3222);
((InstallPluginContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case UNINSTALL:
_localctx = new UninstallPluginContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3225);
match(UNINSTALL);
setState(3226);
match(PLUGIN);
setState(3227);
((UninstallPluginContext)_localctx).name = identifierOrText();
}
break;
case LOCK:
_localctx = new LockTablesContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(3228);
match(LOCK);
setState(3229);
match(TABLES);
setState(3238);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,372,_ctx) ) {
case 1:
{
setState(3230);
lockTable();
setState(3235);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,371,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3231);
match(COMMA);
setState(3232);
lockTable();
}
}
}
setState(3237);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,371,_ctx);
}
}
break;
}
}
break;
case UNLOCK:
_localctx = new UnlockTablesContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(3240);
match(UNLOCK);
setState(3241);
match(TABLES);
}
break;
case WARM:
_localctx = new WarmUpClusterContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(3242);
match(WARM);
setState(3243);
match(UP);
setState(3247);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLUSTER:
{
setState(3244);
match(CLUSTER);
}
break;
case COMPUTE:
{
setState(3245);
match(COMPUTE);
setState(3246);
match(GROUP);
}
break;
default:
throw new NoViableAltException(this);
}
setState(3249);
((WarmUpClusterContext)_localctx).destination = identifier();
setState(3250);
match(WITH);
setState(3265);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLUSTER:
case COMPUTE:
{
setState(3254);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLUSTER:
{
setState(3251);
match(CLUSTER);
}
break;
case COMPUTE:
{
setState(3252);
match(COMPUTE);
setState(3253);
match(GROUP);
}
break;
default:
throw new NoViableAltException(this);
}
setState(3256);
((WarmUpClusterContext)_localctx).source = identifier();
}
break;
case TABLE:
{
{
setState(3257);
warmUpItem();
setState(3262);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,375,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3258);
match(AND);
setState(3259);
warmUpItem();
}
}
}
setState(3264);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,375,_ctx);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(3268);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,377,_ctx) ) {
case 1:
{
setState(3267);
match(FORCE);
}
break;
}
setState(3271);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,378,_ctx) ) {
case 1:
{
setState(3270);
((WarmUpClusterContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case BACKUP:
_localctx = new BackupContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(3273);
match(BACKUP);
setState(3274);
match(SNAPSHOT);
setState(3275);
((BackupContext)_localctx).label = multipartIdentifier();
setState(3276);
match(TO);
setState(3277);
((BackupContext)_localctx).repo = identifier();
setState(3290);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,380,_ctx) ) {
case 1:
{
setState(3278);
_la = _input.LA(1);
if ( !(_la==EXCLUDE || _la==ON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3279);
match(LEFT_PAREN);
setState(3280);
baseTableRef();
setState(3285);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(3281);
match(COMMA);
setState(3282);
baseTableRef();
}
}
setState(3287);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(3288);
match(RIGHT_PAREN);
}
break;
}
setState(3293);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,381,_ctx) ) {
case 1:
{
setState(3292);
((BackupContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case RESTORE:
_localctx = new RestoreContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(3295);
match(RESTORE);
setState(3296);
match(SNAPSHOT);
setState(3297);
((RestoreContext)_localctx).label = multipartIdentifier();
setState(3298);
match(FROM);
setState(3299);
((RestoreContext)_localctx).repo = identifier();
setState(3312);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,383,_ctx) ) {
case 1:
{
setState(3300);
_la = _input.LA(1);
if ( !(_la==EXCLUDE || _la==ON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3301);
match(LEFT_PAREN);
setState(3302);
baseTableRef();
setState(3307);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(3303);
match(COMMA);
setState(3304);
baseTableRef();
}
}
setState(3309);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(3310);
match(RIGHT_PAREN);
}
break;
}
setState(3315);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,384,_ctx) ) {
case 1:
{
setState(3314);
((RestoreContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case START:
_localctx = new UnsupportedStartTransactionContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(3317);
match(START);
setState(3318);
match(TRANSACTION);
setState(3322);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,385,_ctx) ) {
case 1:
{
setState(3319);
match(WITH);
setState(3320);
match(CONSISTENT);
setState(3321);
match(SNAPSHOT);
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WarmUpItemContext extends ParserRuleContext {
public MultipartIdentifierContext tableName;
public IdentifierContext partitionName;
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public WarmUpItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_warmUpItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWarmUpItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWarmUpItem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWarmUpItem(this);
else return visitor.visitChildren(this);
}
}
public final WarmUpItemContext warmUpItem() throws RecognitionException {
WarmUpItemContext _localctx = new WarmUpItemContext(_ctx, getState());
enterRule(_localctx, 300, RULE_warmUpItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(3326);
match(TABLE);
setState(3327);
((WarmUpItemContext)_localctx).tableName = multipartIdentifier();
setState(3330);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,387,_ctx) ) {
case 1:
{
setState(3328);
match(PARTITION);
setState(3329);
((WarmUpItemContext)_localctx).partitionName = identifier();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LockTableContext extends ParserRuleContext {
public MultipartIdentifierContext name;
public IdentifierOrTextContext alias;
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode READ() { return getToken(PLParser.READ, 0); }
public TerminalNode WRITE() { return getToken(PLParser.WRITE, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode LOW_PRIORITY() { return getToken(PLParser.LOW_PRIORITY, 0); }
public LockTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lockTable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLockTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLockTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLockTable(this);
else return visitor.visitChildren(this);
}
}
public final LockTableContext lockTable() throws RecognitionException {
LockTableContext _localctx = new LockTableContext(_ctx, getState());
enterRule(_localctx, 302, RULE_lockTable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3332);
((LockTableContext)_localctx).name = multipartIdentifier();
setState(3335);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(3333);
match(AS);
setState(3334);
((LockTableContext)_localctx).alias = identifierOrText();
}
}
setState(3345);
_errHandler.sync(this);
switch (_input.LA(1)) {
case READ:
{
setState(3337);
match(READ);
setState(3339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,389,_ctx) ) {
case 1:
{
setState(3338);
match(LOCAL);
}
break;
}
}
break;
case LOW_PRIORITY:
case WRITE:
{
setState(3342);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOW_PRIORITY) {
{
setState(3341);
match(LOW_PRIORITY);
}
}
setState(3344);
match(WRITE);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedShowStatementContext extends ParserRuleContext {
public UnsupportedShowStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedShowStatement; }
public UnsupportedShowStatementContext() { }
public void copyFrom(UnsupportedShowStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDataContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowDataContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowData(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowData(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRepositoriesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode REPOSITORIES() { return getToken(PLParser.REPOSITORIES, 0); }
public ShowRepositoriesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRepositories(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRepositories(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRepositories(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowIndexContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public TerminalNode KEYS() { return getToken(PLParser.KEYS, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode INDEXES() { return getToken(PLParser.INDEXES, 0); }
public List<TerminalNode> FROM() { return getTokens(PLParser.FROM); }
public TerminalNode FROM(int i) {
return getToken(PLParser.FROM, i);
}
public List<TerminalNode> IN() { return getTokens(PLParser.IN); }
public TerminalNode IN(int i) {
return getToken(PLParser.IN, i);
}
public List<MultipartIdentifierContext> multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public ShowIndexContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDynamicPartitionContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DYNAMIC() { return getToken(PLParser.DYNAMIC, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowDynamicPartitionContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDynamicPartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDynamicPartition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDynamicPartition(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowWaringErrorsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode WARNINGS() { return getToken(PLParser.WARNINGS, 0); }
public TerminalNode ERRORS() { return getToken(PLParser.ERRORS, 0); }
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public ShowWaringErrorsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowWaringErrors(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowWaringErrors(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowWaringErrors(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTableStatusContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTableStatusContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTableStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTableStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTableStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowBackupContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode BACKUP() { return getToken(PLParser.BACKUP, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowBackupContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowBackup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowBackup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowBackup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateFunctionContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public FunctionArgumentsContext functionArguments() {
return getRuleContext(FunctionArgumentsContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateFunctionContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowGrantsForUserContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode GRANTS() { return getToken(PLParser.GRANTS, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public ShowGrantsForUserContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowGrantsForUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowGrantsForUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowGrantsForUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCacheHotSpotContext extends UnsupportedShowStatementContext {
public Token tablePath;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CACHE() { return getToken(PLParser.CACHE, 0); }
public TerminalNode HOTSPOT() { return getToken(PLParser.HOTSPOT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ShowCacheHotSpotContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCacheHotSpot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCacheHotSpot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCacheHotSpot(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTablesContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTablesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTables(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTables(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowMaterializedViewContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowMaterializedViewContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowMaterializedView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowMaterializedView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowMaterializedView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowExportContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode EXPORT() { return getToken(PLParser.EXPORT, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowExportContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowExport(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowExport(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowExport(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowStorageEnginesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ENGINES() { return getToken(PLParser.ENGINES, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public ShowStorageEnginesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowStorageEngines(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowStorageEngines(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowStorageEngines(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAuthorsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode AUTHORS() { return getToken(PLParser.AUTHORS, 0); }
public ShowAuthorsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAuthors(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAuthors(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAuthors(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCatalogsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CATALOGS() { return getToken(PLParser.CATALOGS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowCatalogsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCatalogs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCatalogs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCatalogs(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRolesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ROLES() { return getToken(PLParser.ROLES, 0); }
public ShowRolesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRoles(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRoles(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRoles(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRowPolicyContext extends UnsupportedShowStatementContext {
public IdentifierContext role;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ROW() { return getToken(PLParser.ROW, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowRowPolicyContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRowPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRowPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRowPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTriggersContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TRIGGERS() { return getToken(PLParser.TRIGGERS, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTriggersContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTriggers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTriggers(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTriggers(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateTableContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode BRIEF() { return getToken(PLParser.BRIEF, 0); }
public ShowCreateTableContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCatalogContext extends UnsupportedShowStatementContext {
public IdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowCatalogContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowColumnsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public TerminalNode FIELDS() { return getToken(PLParser.FIELDS, 0); }
public List<TerminalNode> FROM() { return getTokens(PLParser.FROM); }
public TerminalNode FROM(int i) {
return getToken(PLParser.FROM, i);
}
public List<TerminalNode> IN() { return getTokens(PLParser.IN); }
public TerminalNode IN(int i) {
return getToken(PLParser.IN, i);
}
public List<MultipartIdentifierContext> multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowColumnsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowColumns(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowColumns(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowBuildIndexContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode BUILD() { return getToken(PLParser.BUILD, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowBuildIndexContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowBuildIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowBuildIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowBuildIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowVariablesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode VARIABLES() { return getToken(PLParser.VARIABLES, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public ShowVariablesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowVariables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowVariables(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowVariables(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowEventsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode EVENTS() { return getToken(PLParser.EVENTS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowEventsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowEvents(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowEvents(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowEvents(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowPluginsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PLUGINS() { return getToken(PLParser.PLUGINS, 0); }
public ShowPluginsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowPlugins(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowPlugins(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowPlugins(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAllPropertiesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowAllPropertiesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAllProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAllProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAllProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDataSkewContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode SKEW() { return getToken(PLParser.SKEW, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public ShowDataSkewContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDataSkew(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDataSkew(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDataSkew(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowConvertLscContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CONVERT_LSC() { return getToken(PLParser.CONVERT_LSC, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowConvertLscContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowConvertLsc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowConvertLsc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowConvertLsc(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowSqlBlockRuleContext extends UnsupportedShowStatementContext {
public IdentifierContext ruleName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode SQL_BLOCK_RULE() { return getToken(PLParser.SQL_BLOCK_RULE, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowSqlBlockRuleContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowSqlBlockRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowSqlBlockRule(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowSqlBlockRule(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTableCreationContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode CREATION() { return getToken(PLParser.CREATION, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTableCreationContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTableCreation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTableCreation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTableCreation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowReplicaStatusContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowReplicaStatusContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowReplicaStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowReplicaStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowReplicaStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDeleteContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowDeleteContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDelete(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDelete(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDelete(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTabletsFromTableContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLETS() { return getToken(PLParser.TABLETS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public ShowTabletsFromTableContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTabletsFromTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTabletsFromTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTabletsFromTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowStagesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode STAGES() { return getToken(PLParser.STAGES, 0); }
public ShowStagesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowStages(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowStages(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowStages(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTransactionContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTransactionContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTransaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTransaction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTransaction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowBrokerContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public ShowBrokerContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowBroker(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowBroker(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowBroker(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowResourcesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode RESOURCES() { return getToken(PLParser.RESOURCES, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public ShowResourcesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowResources(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowResources(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowGrantsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode GRANTS() { return getToken(PLParser.GRANTS, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public ShowGrantsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowGrants(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowGrants(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowGrants(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowWorkloadGroupsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode GROUPS() { return getToken(PLParser.GROUPS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowWorkloadGroupsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowWorkloadGroups(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowWorkloadGroups(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowWorkloadGroups(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTabletStorageFormatContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode FORMAT() { return getToken(PLParser.FORMAT, 0); }
public TerminalNode VERBOSE() { return getToken(PLParser.VERBOSE, 0); }
public ShowTabletStorageFormatContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTabletStorageFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTabletStorageFormat(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTabletStorageFormat(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateViewContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateViewContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCharsetContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CHARSET() { return getToken(PLParser.CHARSET, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public ShowCharsetContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCharset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCharset(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCharset(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowProcContext extends UnsupportedShowStatementContext {
public Token path;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ShowProcContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowProc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowProc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowProc(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowOpenTablesContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode OPEN() { return getToken(PLParser.OPEN, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowOpenTablesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowOpenTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowOpenTables(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowOpenTables(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowQueryStatsContext extends UnsupportedShowStatementContext {
public IdentifierContext database;
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode VERBOSE() { return getToken(PLParser.VERBOSE, 0); }
public ShowQueryStatsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowQueryStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowQueryStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowQueryStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateDatabaseContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateDatabaseContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowQueryProfileContext extends UnsupportedShowStatementContext {
public Token queryIdPath;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode PROFILE() { return getToken(PLParser.PROFILE, 0); }
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ShowQueryProfileContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowQueryProfile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowQueryProfile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowQueryProfile(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowStoragePolicyContext extends UnsupportedShowStatementContext {
public IdentifierOrTextContext policy;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public ShowStoragePolicyContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowStoragePolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowStoragePolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowStoragePolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowLoadContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode STREAM() { return getToken(PLParser.STREAM, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowLoadContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowEncryptKeysContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ENCRYPTKEYS() { return getToken(PLParser.ENCRYPTKEYS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowEncryptKeysContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowEncryptKeys(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowEncryptKeys(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowEncryptKeys(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowClustersContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CLUSTERS() { return getToken(PLParser.CLUSTERS, 0); }
public TerminalNode COMPUTE() { return getToken(PLParser.COMPUTE, 0); }
public TerminalNode GROUPS() { return getToken(PLParser.GROUPS, 0); }
public ShowClustersContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowClusters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowClusters(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowClusters(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTrashContext extends UnsupportedShowStatementContext {
public Token backend;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TRASH() { return getToken(PLParser.TRASH, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ShowTrashContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTrash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTrash(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTrash(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowPartitionsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PARTITIONS() { return getToken(PLParser.PARTITIONS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public ShowPartitionsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowPartitions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowPartitions(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowFrontendsContext extends UnsupportedShowStatementContext {
public IdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode FRONTENDS() { return getToken(PLParser.FRONTENDS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowFrontendsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowFrontends(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowFrontends(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowFrontends(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowGlobalFunctionsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode FUNCTIONS() { return getToken(PLParser.FUNCTIONS, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowGlobalFunctionsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowGlobalFunctions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowGlobalFunctions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowGlobalFunctions(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowPartitionIdContext extends UnsupportedShowStatementContext {
public Token partitionId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowPartitionIdContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowPartitionId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowPartitionId(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowPartitionId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowLoadProfileContext extends UnsupportedShowStatementContext {
public Token loadIdPath;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode PROFILE() { return getToken(PLParser.PROFILE, 0); }
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ShowLoadProfileContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowLoadProfile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowLoadProfile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowLoadProfile(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowSnapshotContext extends UnsupportedShowStatementContext {
public IdentifierContext repo;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowSnapshotContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowSnapshot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowSnapshot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowSnapshot(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCatalogRecycleBinContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode RECYCLE() { return getToken(PLParser.RECYCLE, 0); }
public TerminalNode BIN() { return getToken(PLParser.BIN, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowCatalogRecycleBinContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCatalogRecycleBin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCatalogRecycleBin(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCatalogRecycleBin(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCopyContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COPY() { return getToken(PLParser.COPY, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCopyContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCopy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCopy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCopy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCollationContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COLLATION() { return getToken(PLParser.COLLATION, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowCollationContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCollation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCollation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCollation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowBackendsContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode BACKENDS() { return getToken(PLParser.BACKENDS, 0); }
public ShowBackendsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowBackends(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowBackends(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowBackends(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTypeCastContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TYPECAST() { return getToken(PLParser.TYPECAST, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTypeCastContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTypeCast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTypeCast(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTypeCast(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTabletBelongContext extends UnsupportedShowStatementContext {
public Token INTEGER_VALUE;
public List<Token> tabletIds = new ArrayList<Token>();
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLETS() { return getToken(PLParser.TABLETS, 0); }
public TerminalNode BELONG() { return getToken(PLParser.BELONG, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ShowTabletBelongContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTabletBelong(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTabletBelong(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTabletBelong(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowPrivilegesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PRIVILEGES() { return getToken(PLParser.PRIVILEGES, 0); }
public ShowPrivilegesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowPrivileges(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowPrivileges(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowPrivileges(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowREplicaDistributionContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode DISTRIBUTION() { return getToken(PLParser.DISTRIBUTION, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public ShowREplicaDistributionContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowREplicaDistribution(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowREplicaDistribution(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowREplicaDistribution(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRestoreContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode RESTORE() { return getToken(PLParser.RESTORE, 0); }
public TerminalNode BRIEF() { return getToken(PLParser.BRIEF, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowRestoreContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRestore(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRestore(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRestore(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowLoadWaringsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public Token url;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode WARNINGS() { return getToken(PLParser.WARNINGS, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowLoadWaringsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowLoadWarings(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowLoadWarings(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowLoadWarings(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTableIdContext extends UnsupportedShowStatementContext {
public Token tableId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowTableIdContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTableId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTableId(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTableId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAlterTableContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowAlterTableContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAlterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAlterTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAlterTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowSmallFilesContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode FILE() { return getToken(PLParser.FILE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowSmallFilesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowSmallFiles(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowSmallFiles(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowSmallFiles(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowWaringErrorCountContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COUNT() { return getToken(PLParser.COUNT, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode WARNINGS() { return getToken(PLParser.WARNINGS, 0); }
public TerminalNode ERRORS() { return getToken(PLParser.ERRORS, 0); }
public ShowWaringErrorCountContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowWaringErrorCount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowWaringErrorCount(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowWaringErrorCount(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDatabasesContext extends UnsupportedShowStatementContext {
public IdentifierContext catalog;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DATABASES() { return getToken(PLParser.DATABASES, 0); }
public TerminalNode SCHEMAS() { return getToken(PLParser.SCHEMAS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowDatabasesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDatabases(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDatabases(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDatabases(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTabletIdContext extends UnsupportedShowStatementContext {
public Token tabletId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowTabletIdContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTabletId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTabletId(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTabletId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowStorageVaultContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public TerminalNode VAULTS() { return getToken(PLParser.VAULTS, 0); }
public ShowStorageVaultContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowStorageVault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowStorageVault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowStorageVault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowStatusContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public ShowStatusContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowUserPropertiesContext extends UnsupportedShowStatementContext {
public IdentifierOrTextContext user;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PROPERTY() { return getToken(PLParser.PROPERTY, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public ShowUserPropertiesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowUserProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowUserProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowUserProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowWarmUpJobContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode WARM() { return getToken(PLParser.WARM, 0); }
public TerminalNode UP() { return getToken(PLParser.UP, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowWarmUpJobContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowWarmUpJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowWarmUpJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowWarmUpJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowLastInsertContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode LAST() { return getToken(PLParser.LAST, 0); }
public TerminalNode INSERT() { return getToken(PLParser.INSERT, 0); }
public ShowLastInsertContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowLastInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowLastInsert(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowLastInsert(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateCatalogContext extends UnsupportedShowStatementContext {
public IdentifierContext name;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowCreateCatalogContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateMaterializedViewContext extends UnsupportedShowStatementContext {
public IdentifierContext mvName;
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateMaterializedViewContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateMaterializedView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateMaterializedView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateMaterializedView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowProcessListContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode PROCESSLIST() { return getToken(PLParser.PROCESSLIST, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public ShowProcessListContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowProcessList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowProcessList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowProcessList(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDataTypesContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode TYPES() { return getToken(PLParser.TYPES, 0); }
public ShowDataTypesContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDataTypes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDataTypes(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDataTypes(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDiagnoseTabletContext extends UnsupportedShowStatementContext {
public Token tabletId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode DIAGNOSIS() { return getToken(PLParser.DIAGNOSIS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowDiagnoseTabletContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDiagnoseTablet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDiagnoseTablet(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDiagnoseTablet(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowWhitelistContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode WHITELIST() { return getToken(PLParser.WHITELIST, 0); }
public ShowWhitelistContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowWhitelist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowWhitelist(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowWhitelist(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowViewsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode VIEWS() { return getToken(PLParser.VIEWS, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowViewsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowViews(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowViews(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowViews(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowFunctionsContext extends UnsupportedShowStatementContext {
public MultipartIdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode FUNCTIONS() { return getToken(PLParser.FUNCTIONS, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public TerminalNode BUILTIN() { return getToken(PLParser.BUILTIN, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowFunctionsContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowFunctions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowFunctions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowFunctions(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowDatabaseIdContext extends UnsupportedShowStatementContext {
public Token databaseId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowDatabaseIdContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowDatabaseId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowDatabaseId(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowDatabaseId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateRepositoryContext extends UnsupportedShowStatementContext {
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPOSITORY() { return getToken(PLParser.REPOSITORY, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowCreateRepositoryContext(UnsupportedShowStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateRepository(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateRepository(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateRepository(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedShowStatementContext unsupportedShowStatement() throws RecognitionException {
UnsupportedShowStatementContext _localctx = new UnsupportedShowStatementContext(_ctx, getState());
enterRule(_localctx, 304, RULE_unsupportedShowStatement);
int _la;
try {
int _alt;
setState(4035);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,517,_ctx) ) {
case 1:
_localctx = new ShowSqlBlockRuleContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(3347);
match(SHOW);
setState(3348);
match(SQL_BLOCK_RULE);
setState(3351);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,392,_ctx) ) {
case 1:
{
setState(3349);
match(FOR);
setState(3350);
((ShowSqlBlockRuleContext)_localctx).ruleName = identifier();
}
break;
}
}
break;
case 2:
_localctx = new ShowRowPolicyContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(3353);
match(SHOW);
setState(3354);
match(ROW);
setState(3355);
match(POLICY);
setState(3362);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,394,_ctx) ) {
case 1:
{
setState(3356);
match(FOR);
setState(3360);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(3357);
userIdentify();
}
break;
case ROLE:
{
{
setState(3358);
match(ROLE);
setState(3359);
((ShowRowPolicyContext)_localctx).role = identifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
case 3:
_localctx = new ShowStoragePolicyContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(3364);
match(SHOW);
setState(3365);
match(STORAGE);
setState(3366);
match(POLICY);
setState(3372);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,396,_ctx) ) {
case 1:
{
setState(3367);
match(USING);
setState(3370);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,395,_ctx) ) {
case 1:
{
setState(3368);
match(FOR);
setState(3369);
((ShowStoragePolicyContext)_localctx).policy = identifierOrText();
}
break;
}
}
break;
}
}
break;
case 4:
_localctx = new ShowStagesContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(3374);
match(SHOW);
setState(3375);
match(STAGES);
}
break;
case 5:
_localctx = new ShowStorageVaultContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(3376);
match(SHOW);
setState(3377);
match(STORAGE);
setState(3378);
_la = _input.LA(1);
if ( !(_la==VAULT || _la==VAULTS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 6:
_localctx = new ShowCreateRepositoryContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(3379);
match(SHOW);
setState(3380);
match(CREATE);
setState(3381);
match(REPOSITORY);
setState(3382);
match(FOR);
setState(3383);
identifier();
}
break;
case 7:
_localctx = new ShowWhitelistContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(3384);
match(SHOW);
setState(3385);
match(WHITELIST);
}
break;
case 8:
_localctx = new ShowVariablesContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(3386);
match(SHOW);
setState(3388);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(3387);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(3390);
match(VARIABLES);
setState(3392);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,398,_ctx) ) {
case 1:
{
setState(3391);
wildWhere();
}
break;
}
}
break;
case 9:
_localctx = new ShowOpenTablesContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(3394);
match(SHOW);
setState(3395);
match(OPEN);
setState(3396);
match(TABLES);
setState(3399);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) {
case 1:
{
setState(3397);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3398);
((ShowOpenTablesContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3402);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,400,_ctx) ) {
case 1:
{
setState(3401);
wildWhere();
}
break;
}
}
break;
case 10:
_localctx = new ShowTableStatusContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(3404);
match(SHOW);
setState(3405);
match(TABLE);
setState(3406);
match(STATUS);
setState(3409);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,401,_ctx) ) {
case 1:
{
setState(3407);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3408);
((ShowTableStatusContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3412);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,402,_ctx) ) {
case 1:
{
setState(3411);
wildWhere();
}
break;
}
}
break;
case 11:
_localctx = new ShowTablesContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(3414);
match(SHOW);
setState(3416);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3415);
match(FULL);
}
}
setState(3418);
match(TABLES);
setState(3421);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,404,_ctx) ) {
case 1:
{
setState(3419);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3420);
((ShowTablesContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3424);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,405,_ctx) ) {
case 1:
{
setState(3423);
wildWhere();
}
break;
}
}
break;
case 12:
_localctx = new ShowViewsContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(3426);
match(SHOW);
setState(3428);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3427);
match(FULL);
}
}
setState(3430);
match(VIEWS);
setState(3433);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,407,_ctx) ) {
case 1:
{
setState(3431);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3432);
((ShowViewsContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3436);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,408,_ctx) ) {
case 1:
{
setState(3435);
wildWhere();
}
break;
}
}
break;
case 13:
_localctx = new ShowTableIdContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(3438);
match(SHOW);
setState(3439);
match(TABLE);
setState(3440);
((ShowTableIdContext)_localctx).tableId = match(INTEGER_VALUE);
}
break;
case 14:
_localctx = new ShowProcessListContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(3441);
match(SHOW);
setState(3443);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3442);
match(FULL);
}
}
setState(3445);
match(PROCESSLIST);
}
break;
case 15:
_localctx = new ShowStatusContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(3446);
match(SHOW);
setState(3448);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(3447);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(3450);
match(STATUS);
setState(3452);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,411,_ctx) ) {
case 1:
{
setState(3451);
wildWhere();
}
break;
}
}
break;
case 16:
_localctx = new ShowTriggersContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(3454);
match(SHOW);
setState(3456);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3455);
match(FULL);
}
}
setState(3458);
match(TRIGGERS);
setState(3461);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,413,_ctx) ) {
case 1:
{
setState(3459);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3460);
((ShowTriggersContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3464);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,414,_ctx) ) {
case 1:
{
setState(3463);
wildWhere();
}
break;
}
}
break;
case 17:
_localctx = new ShowEventsContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(3466);
match(SHOW);
setState(3467);
match(EVENTS);
setState(3470);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) {
case 1:
{
setState(3468);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3469);
((ShowEventsContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3473);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) {
case 1:
{
setState(3472);
wildWhere();
}
break;
}
}
break;
case 18:
_localctx = new ShowPluginsContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(3475);
match(SHOW);
setState(3476);
match(PLUGINS);
}
break;
case 19:
_localctx = new ShowStorageEnginesContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(3477);
match(SHOW);
setState(3479);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORAGE) {
{
setState(3478);
match(STORAGE);
}
}
setState(3481);
match(ENGINES);
}
break;
case 20:
_localctx = new ShowAuthorsContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(3482);
match(SHOW);
setState(3483);
match(AUTHORS);
}
break;
case 21:
_localctx = new ShowCreateTableContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(3484);
match(SHOW);
setState(3486);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BRIEF) {
{
setState(3485);
match(BRIEF);
}
}
setState(3488);
match(CREATE);
setState(3489);
match(TABLE);
setState(3490);
((ShowCreateTableContext)_localctx).name = multipartIdentifier();
}
break;
case 22:
_localctx = new ShowCreateViewContext(_localctx);
enterOuterAlt(_localctx, 22);
{
setState(3491);
match(SHOW);
setState(3492);
match(CREATE);
setState(3493);
match(VIEW);
setState(3494);
((ShowCreateViewContext)_localctx).name = multipartIdentifier();
}
break;
case 23:
_localctx = new ShowMaterializedViewContext(_localctx);
enterOuterAlt(_localctx, 23);
{
setState(3495);
match(SHOW);
setState(3496);
match(CREATE);
setState(3497);
match(MATERIALIZED);
setState(3498);
match(VIEW);
setState(3499);
((ShowMaterializedViewContext)_localctx).name = multipartIdentifier();
}
break;
case 24:
_localctx = new ShowCreateDatabaseContext(_localctx);
enterOuterAlt(_localctx, 24);
{
setState(3500);
match(SHOW);
setState(3501);
match(CREATE);
setState(3502);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3503);
((ShowCreateDatabaseContext)_localctx).name = multipartIdentifier();
}
break;
case 25:
_localctx = new ShowCreateCatalogContext(_localctx);
enterOuterAlt(_localctx, 25);
{
setState(3504);
match(SHOW);
setState(3505);
match(CREATE);
setState(3506);
match(CATALOG);
setState(3507);
((ShowCreateCatalogContext)_localctx).name = identifier();
}
break;
case 26:
_localctx = new ShowCreateFunctionContext(_localctx);
enterOuterAlt(_localctx, 26);
{
setState(3508);
match(SHOW);
setState(3509);
match(CREATE);
setState(3511);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(3510);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(3513);
match(FUNCTION);
setState(3514);
functionIdentifier();
setState(3515);
match(LEFT_PAREN);
setState(3517);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 186)) & ~0x3f) == 0 && ((1L << (_la - 186)) & 143005235300353L) != 0) || ((((_la - 251)) & ~0x3f) == 0 && ((1L << (_la - 251)) & 16870906416594945L) != 0) || _la==DOUBLE || _la==FLOAT || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 4604407840769L) != 0) || _la==MAP || _la==QUANTILE_STATE || _la==SMALLINT || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 20266198328541187L) != 0)) {
{
setState(3516);
functionArguments();
}
}
setState(3519);
match(RIGHT_PAREN);
setState(3522);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) {
case 1:
{
setState(3520);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3521);
((ShowCreateFunctionContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 27:
_localctx = new ShowDatabasesContext(_localctx);
enterOuterAlt(_localctx, 27);
{
setState(3524);
match(SHOW);
setState(3525);
_la = _input.LA(1);
if ( !(_la==DATABASES || _la==SCHEMAS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3528);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) {
case 1:
{
setState(3526);
match(FROM);
setState(3527);
((ShowDatabasesContext)_localctx).catalog = identifier();
}
break;
}
setState(3531);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) {
case 1:
{
setState(3530);
wildWhere();
}
break;
}
}
break;
case 28:
_localctx = new ShowDatabaseIdContext(_localctx);
enterOuterAlt(_localctx, 28);
{
setState(3533);
match(SHOW);
setState(3534);
match(DATABASE);
setState(3535);
((ShowDatabaseIdContext)_localctx).databaseId = match(INTEGER_VALUE);
}
break;
case 29:
_localctx = new ShowDataTypesContext(_localctx);
enterOuterAlt(_localctx, 29);
{
setState(3536);
match(SHOW);
setState(3537);
match(DATA);
setState(3538);
match(TYPES);
}
break;
case 30:
_localctx = new ShowCatalogsContext(_localctx);
enterOuterAlt(_localctx, 30);
{
setState(3539);
match(SHOW);
setState(3540);
match(CATALOGS);
setState(3542);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,424,_ctx) ) {
case 1:
{
setState(3541);
wildWhere();
}
break;
}
}
break;
case 31:
_localctx = new ShowCatalogContext(_localctx);
enterOuterAlt(_localctx, 31);
{
setState(3544);
match(SHOW);
setState(3545);
match(CATALOG);
setState(3546);
((ShowCatalogContext)_localctx).name = identifier();
}
break;
case 32:
_localctx = new ShowDynamicPartitionContext(_localctx);
enterOuterAlt(_localctx, 32);
{
setState(3547);
match(SHOW);
setState(3548);
match(DYNAMIC);
setState(3549);
match(PARTITION);
setState(3550);
match(TABLES);
setState(3553);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) {
case 1:
{
setState(3551);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3552);
((ShowDynamicPartitionContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 33:
_localctx = new ShowColumnsContext(_localctx);
enterOuterAlt(_localctx, 33);
{
setState(3555);
match(SHOW);
setState(3557);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3556);
match(FULL);
}
}
setState(3559);
_la = _input.LA(1);
if ( !(_la==COLUMNS || _la==FIELDS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3560);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3561);
((ShowColumnsContext)_localctx).tableName = multipartIdentifier();
setState(3564);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,427,_ctx) ) {
case 1:
{
setState(3562);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3563);
((ShowColumnsContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3567);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) {
case 1:
{
setState(3566);
wildWhere();
}
break;
}
}
break;
case 34:
_localctx = new ShowCollationContext(_localctx);
enterOuterAlt(_localctx, 34);
{
setState(3569);
match(SHOW);
setState(3570);
match(COLLATION);
setState(3572);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,429,_ctx) ) {
case 1:
{
setState(3571);
wildWhere();
}
break;
}
}
break;
case 35:
_localctx = new ShowCharsetContext(_localctx);
enterOuterAlt(_localctx, 35);
{
setState(3574);
match(SHOW);
setState(3578);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHAR:
{
{
setState(3575);
match(CHAR);
setState(3576);
match(SET);
}
}
break;
case CHARSET:
{
setState(3577);
match(CHARSET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(3581);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,431,_ctx) ) {
case 1:
{
setState(3580);
wildWhere();
}
break;
}
}
break;
case 36:
_localctx = new ShowProcContext(_localctx);
enterOuterAlt(_localctx, 36);
{
setState(3583);
match(SHOW);
setState(3584);
match(PROC);
setState(3585);
((ShowProcContext)_localctx).path = match(STRING_LITERAL);
}
break;
case 37:
_localctx = new ShowWaringErrorCountContext(_localctx);
enterOuterAlt(_localctx, 37);
{
setState(3586);
match(SHOW);
setState(3587);
match(COUNT);
setState(3588);
match(LEFT_PAREN);
setState(3589);
match(ASTERISK);
setState(3590);
match(RIGHT_PAREN);
setState(3591);
_la = _input.LA(1);
if ( !(_la==ERRORS || _la==WARNINGS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 38:
_localctx = new ShowWaringErrorsContext(_localctx);
enterOuterAlt(_localctx, 38);
{
setState(3592);
match(SHOW);
setState(3593);
_la = _input.LA(1);
if ( !(_la==ERRORS || _la==WARNINGS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3595);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,432,_ctx) ) {
case 1:
{
setState(3594);
limitClause();
}
break;
}
}
break;
case 39:
_localctx = new ShowLoadWaringsContext(_localctx);
enterOuterAlt(_localctx, 39);
{
setState(3597);
match(SHOW);
setState(3598);
match(LOAD);
setState(3599);
match(WARNINGS);
setState(3612);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,436,_ctx) ) {
case 1:
{
{
setState(3602);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,433,_ctx) ) {
case 1:
{
setState(3600);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3601);
((ShowLoadWaringsContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3605);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,434,_ctx) ) {
case 1:
{
setState(3604);
wildWhere();
}
break;
}
setState(3608);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,435,_ctx) ) {
case 1:
{
setState(3607);
limitClause();
}
break;
}
}
}
break;
case 2:
{
{
setState(3610);
match(ON);
setState(3611);
((ShowLoadWaringsContext)_localctx).url = match(STRING_LITERAL);
}
}
break;
}
}
break;
case 40:
_localctx = new ShowLoadContext(_localctx);
enterOuterAlt(_localctx, 40);
{
setState(3614);
match(SHOW);
setState(3616);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STREAM) {
{
setState(3615);
match(STREAM);
}
}
setState(3618);
match(LOAD);
setState(3621);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,438,_ctx) ) {
case 1:
{
setState(3619);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3620);
((ShowLoadContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3624);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,439,_ctx) ) {
case 1:
{
setState(3623);
wildWhere();
}
break;
}
setState(3627);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,440,_ctx) ) {
case 1:
{
setState(3626);
sortClause();
}
break;
}
setState(3630);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,441,_ctx) ) {
case 1:
{
setState(3629);
limitClause();
}
break;
}
}
break;
case 41:
_localctx = new ShowExportContext(_localctx);
enterOuterAlt(_localctx, 41);
{
setState(3632);
match(SHOW);
setState(3633);
match(EXPORT);
setState(3636);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) {
case 1:
{
setState(3634);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3635);
((ShowExportContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3639);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,443,_ctx) ) {
case 1:
{
setState(3638);
wildWhere();
}
break;
}
setState(3642);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,444,_ctx) ) {
case 1:
{
setState(3641);
sortClause();
}
break;
}
setState(3645);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,445,_ctx) ) {
case 1:
{
setState(3644);
limitClause();
}
break;
}
}
break;
case 42:
_localctx = new ShowDeleteContext(_localctx);
enterOuterAlt(_localctx, 42);
{
setState(3647);
match(SHOW);
setState(3648);
match(DELETE);
setState(3651);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,446,_ctx) ) {
case 1:
{
setState(3649);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3650);
((ShowDeleteContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 43:
_localctx = new ShowAlterTableContext(_localctx);
enterOuterAlt(_localctx, 43);
{
setState(3653);
match(SHOW);
setState(3654);
match(ALTER);
setState(3655);
match(TABLE);
setState(3660);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROLLUP:
{
setState(3656);
match(ROLLUP);
}
break;
case MATERIALIZED:
{
{
setState(3657);
match(MATERIALIZED);
setState(3658);
match(VIEW);
}
}
break;
case COLUMN:
{
setState(3659);
match(COLUMN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(3664);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,448,_ctx) ) {
case 1:
{
setState(3662);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3663);
((ShowAlterTableContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3667);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,449,_ctx) ) {
case 1:
{
setState(3666);
wildWhere();
}
break;
}
setState(3670);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,450,_ctx) ) {
case 1:
{
setState(3669);
sortClause();
}
break;
}
setState(3673);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,451,_ctx) ) {
case 1:
{
setState(3672);
limitClause();
}
break;
}
}
break;
case 44:
_localctx = new ShowDataSkewContext(_localctx);
enterOuterAlt(_localctx, 44);
{
setState(3675);
match(SHOW);
setState(3676);
match(DATA);
setState(3677);
match(SKEW);
setState(3678);
match(FROM);
setState(3679);
baseTableRef();
}
break;
case 45:
_localctx = new ShowDataContext(_localctx);
enterOuterAlt(_localctx, 45);
{
setState(3680);
match(SHOW);
setState(3681);
match(DATA);
setState(3683);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,452,_ctx) ) {
case 1:
{
setState(3682);
match(ALL);
}
break;
}
setState(3687);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,453,_ctx) ) {
case 1:
{
setState(3685);
match(FROM);
setState(3686);
((ShowDataContext)_localctx).tableName = multipartIdentifier();
}
break;
}
setState(3690);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,454,_ctx) ) {
case 1:
{
setState(3689);
sortClause();
}
break;
}
setState(3693);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,455,_ctx) ) {
case 1:
{
setState(3692);
propertyClause();
}
break;
}
}
break;
case 46:
_localctx = new ShowPartitionsContext(_localctx);
enterOuterAlt(_localctx, 46);
{
setState(3695);
match(SHOW);
setState(3697);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(3696);
match(TEMPORARY);
}
}
setState(3699);
match(PARTITIONS);
setState(3700);
match(FROM);
setState(3701);
((ShowPartitionsContext)_localctx).tableName = multipartIdentifier();
setState(3703);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,457,_ctx) ) {
case 1:
{
setState(3702);
wildWhere();
}
break;
}
setState(3706);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) {
case 1:
{
setState(3705);
sortClause();
}
break;
}
setState(3709);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,459,_ctx) ) {
case 1:
{
setState(3708);
limitClause();
}
break;
}
}
break;
case 47:
_localctx = new ShowPartitionIdContext(_localctx);
enterOuterAlt(_localctx, 47);
{
setState(3711);
match(SHOW);
setState(3712);
match(PARTITION);
setState(3713);
((ShowPartitionIdContext)_localctx).partitionId = match(INTEGER_VALUE);
}
break;
case 48:
_localctx = new ShowTabletIdContext(_localctx);
enterOuterAlt(_localctx, 48);
{
setState(3714);
match(SHOW);
setState(3715);
match(TABLET);
setState(3716);
((ShowTabletIdContext)_localctx).tabletId = match(INTEGER_VALUE);
}
break;
case 49:
_localctx = new ShowTabletBelongContext(_localctx);
enterOuterAlt(_localctx, 49);
{
setState(3717);
match(SHOW);
setState(3718);
match(TABLETS);
setState(3719);
match(BELONG);
setState(3720);
((ShowTabletBelongContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((ShowTabletBelongContext)_localctx).tabletIds.add(((ShowTabletBelongContext)_localctx).INTEGER_VALUE);
setState(3725);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,460,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3721);
match(COMMA);
setState(3722);
((ShowTabletBelongContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((ShowTabletBelongContext)_localctx).tabletIds.add(((ShowTabletBelongContext)_localctx).INTEGER_VALUE);
}
}
}
setState(3727);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,460,_ctx);
}
}
break;
case 50:
_localctx = new ShowTabletsFromTableContext(_localctx);
enterOuterAlt(_localctx, 50);
{
setState(3728);
match(SHOW);
setState(3729);
match(TABLETS);
setState(3730);
match(FROM);
setState(3731);
((ShowTabletsFromTableContext)_localctx).tableName = multipartIdentifier();
setState(3733);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,461,_ctx) ) {
case 1:
{
setState(3732);
partitionSpec();
}
break;
}
setState(3736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,462,_ctx) ) {
case 1:
{
setState(3735);
wildWhere();
}
break;
}
setState(3739);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,463,_ctx) ) {
case 1:
{
setState(3738);
sortClause();
}
break;
}
setState(3742);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,464,_ctx) ) {
case 1:
{
setState(3741);
limitClause();
}
break;
}
}
break;
case 51:
_localctx = new ShowUserPropertiesContext(_localctx);
enterOuterAlt(_localctx, 51);
{
setState(3744);
match(SHOW);
setState(3745);
match(PROPERTY);
setState(3748);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,465,_ctx) ) {
case 1:
{
setState(3746);
match(FOR);
setState(3747);
((ShowUserPropertiesContext)_localctx).user = identifierOrText();
}
break;
}
setState(3751);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,466,_ctx) ) {
case 1:
{
setState(3750);
wildWhere();
}
break;
}
}
break;
case 52:
_localctx = new ShowAllPropertiesContext(_localctx);
enterOuterAlt(_localctx, 52);
{
setState(3753);
match(SHOW);
setState(3754);
match(ALL);
setState(3755);
match(PROPERTIES);
setState(3757);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,467,_ctx) ) {
case 1:
{
setState(3756);
wildWhere();
}
break;
}
}
break;
case 53:
_localctx = new ShowBackupContext(_localctx);
enterOuterAlt(_localctx, 53);
{
setState(3759);
match(SHOW);
setState(3760);
match(BACKUP);
setState(3763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,468,_ctx) ) {
case 1:
{
setState(3761);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3762);
((ShowBackupContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3766);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,469,_ctx) ) {
case 1:
{
setState(3765);
wildWhere();
}
break;
}
}
break;
case 54:
_localctx = new ShowRestoreContext(_localctx);
enterOuterAlt(_localctx, 54);
{
setState(3768);
match(SHOW);
setState(3770);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BRIEF) {
{
setState(3769);
match(BRIEF);
}
}
setState(3772);
match(RESTORE);
setState(3775);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,471,_ctx) ) {
case 1:
{
setState(3773);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3774);
((ShowRestoreContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3778);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,472,_ctx) ) {
case 1:
{
setState(3777);
wildWhere();
}
break;
}
}
break;
case 55:
_localctx = new ShowBrokerContext(_localctx);
enterOuterAlt(_localctx, 55);
{
setState(3780);
match(SHOW);
setState(3781);
match(BROKER);
}
break;
case 56:
_localctx = new ShowResourcesContext(_localctx);
enterOuterAlt(_localctx, 56);
{
setState(3782);
match(SHOW);
setState(3783);
match(RESOURCES);
setState(3785);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,473,_ctx) ) {
case 1:
{
setState(3784);
wildWhere();
}
break;
}
setState(3788);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,474,_ctx) ) {
case 1:
{
setState(3787);
sortClause();
}
break;
}
setState(3791);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,475,_ctx) ) {
case 1:
{
setState(3790);
limitClause();
}
break;
}
}
break;
case 57:
_localctx = new ShowWorkloadGroupsContext(_localctx);
enterOuterAlt(_localctx, 57);
{
setState(3793);
match(SHOW);
setState(3794);
match(WORKLOAD);
setState(3795);
match(GROUPS);
setState(3797);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,476,_ctx) ) {
case 1:
{
setState(3796);
wildWhere();
}
break;
}
}
break;
case 58:
_localctx = new ShowBackendsContext(_localctx);
enterOuterAlt(_localctx, 58);
{
setState(3799);
match(SHOW);
setState(3800);
match(BACKENDS);
}
break;
case 59:
_localctx = new ShowTrashContext(_localctx);
enterOuterAlt(_localctx, 59);
{
setState(3801);
match(SHOW);
setState(3802);
match(TRASH);
setState(3805);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,477,_ctx) ) {
case 1:
{
setState(3803);
match(ON);
setState(3804);
((ShowTrashContext)_localctx).backend = match(STRING_LITERAL);
}
break;
}
}
break;
case 60:
_localctx = new ShowFrontendsContext(_localctx);
enterOuterAlt(_localctx, 60);
{
setState(3807);
match(SHOW);
setState(3808);
match(FRONTENDS);
setState(3810);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,478,_ctx) ) {
case 1:
{
setState(3809);
((ShowFrontendsContext)_localctx).name = identifier();
}
break;
}
}
break;
case 61:
_localctx = new ShowRepositoriesContext(_localctx);
enterOuterAlt(_localctx, 61);
{
setState(3812);
match(SHOW);
setState(3813);
match(REPOSITORIES);
}
break;
case 62:
_localctx = new ShowSnapshotContext(_localctx);
enterOuterAlt(_localctx, 62);
{
setState(3814);
match(SHOW);
setState(3815);
match(SNAPSHOT);
setState(3816);
match(ON);
setState(3817);
((ShowSnapshotContext)_localctx).repo = identifier();
setState(3819);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,479,_ctx) ) {
case 1:
{
setState(3818);
wildWhere();
}
break;
}
}
break;
case 63:
_localctx = new ShowGrantsContext(_localctx);
enterOuterAlt(_localctx, 63);
{
setState(3821);
match(SHOW);
setState(3823);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(3822);
match(ALL);
}
}
setState(3825);
match(GRANTS);
}
break;
case 64:
_localctx = new ShowGrantsForUserContext(_localctx);
enterOuterAlt(_localctx, 64);
{
setState(3826);
match(SHOW);
setState(3827);
match(GRANTS);
setState(3828);
match(FOR);
setState(3829);
userIdentify();
}
break;
case 65:
_localctx = new ShowRolesContext(_localctx);
enterOuterAlt(_localctx, 65);
{
setState(3830);
match(SHOW);
setState(3831);
match(ROLES);
}
break;
case 66:
_localctx = new ShowPrivilegesContext(_localctx);
enterOuterAlt(_localctx, 66);
{
setState(3832);
match(SHOW);
setState(3833);
match(PRIVILEGES);
}
break;
case 67:
_localctx = new ShowFunctionsContext(_localctx);
enterOuterAlt(_localctx, 67);
{
setState(3834);
match(SHOW);
setState(3836);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3835);
match(FULL);
}
}
setState(3839);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BUILTIN) {
{
setState(3838);
match(BUILTIN);
}
}
setState(3841);
match(FUNCTIONS);
setState(3844);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,483,_ctx) ) {
case 1:
{
setState(3842);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3843);
((ShowFunctionsContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3847);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,484,_ctx) ) {
case 1:
{
setState(3846);
wildWhere();
}
break;
}
}
break;
case 68:
_localctx = new ShowGlobalFunctionsContext(_localctx);
enterOuterAlt(_localctx, 68);
{
setState(3849);
match(SHOW);
setState(3850);
match(GLOBAL);
setState(3852);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULL) {
{
setState(3851);
match(FULL);
}
}
setState(3854);
match(FUNCTIONS);
setState(3856);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,486,_ctx) ) {
case 1:
{
setState(3855);
wildWhere();
}
break;
}
}
break;
case 69:
_localctx = new ShowTypeCastContext(_localctx);
enterOuterAlt(_localctx, 69);
{
setState(3858);
match(SHOW);
setState(3859);
match(TYPECAST);
setState(3862);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,487,_ctx) ) {
case 1:
{
setState(3860);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3861);
((ShowTypeCastContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 70:
_localctx = new ShowSmallFilesContext(_localctx);
enterOuterAlt(_localctx, 70);
{
setState(3864);
match(SHOW);
setState(3865);
match(FILE);
setState(3868);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,488,_ctx) ) {
case 1:
{
setState(3866);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3867);
((ShowSmallFilesContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 71:
_localctx = new ShowIndexContext(_localctx);
enterOuterAlt(_localctx, 71);
{
setState(3870);
match(SHOW);
setState(3871);
_la = _input.LA(1);
if ( !(((((_la - 403)) & ~0x3f) == 0 && ((1L << (_la - 403)) & 100663299L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3872);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3873);
((ShowIndexContext)_localctx).tableName = multipartIdentifier();
setState(3876);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,489,_ctx) ) {
case 1:
{
setState(3874);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3875);
((ShowIndexContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 72:
_localctx = new ShowTransactionContext(_localctx);
enterOuterAlt(_localctx, 72);
{
setState(3878);
match(SHOW);
setState(3879);
match(TRANSACTION);
setState(3882);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,490,_ctx) ) {
case 1:
{
setState(3880);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3881);
((ShowTransactionContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3885);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,491,_ctx) ) {
case 1:
{
setState(3884);
wildWhere();
}
break;
}
}
break;
case 73:
_localctx = new ShowQueryProfileContext(_localctx);
enterOuterAlt(_localctx, 73);
{
setState(3887);
match(SHOW);
setState(3888);
match(QUERY);
setState(3889);
match(PROFILE);
setState(3891);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,492,_ctx) ) {
case 1:
{
setState(3890);
((ShowQueryProfileContext)_localctx).queryIdPath = match(STRING_LITERAL);
}
break;
}
setState(3894);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,493,_ctx) ) {
case 1:
{
setState(3893);
limitClause();
}
break;
}
}
break;
case 74:
_localctx = new ShowLoadProfileContext(_localctx);
enterOuterAlt(_localctx, 74);
{
setState(3896);
match(SHOW);
setState(3897);
match(LOAD);
setState(3898);
match(PROFILE);
setState(3900);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,494,_ctx) ) {
case 1:
{
setState(3899);
((ShowLoadProfileContext)_localctx).loadIdPath = match(STRING_LITERAL);
}
break;
}
setState(3903);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,495,_ctx) ) {
case 1:
{
setState(3902);
limitClause();
}
break;
}
}
break;
case 75:
_localctx = new ShowCacheHotSpotContext(_localctx);
enterOuterAlt(_localctx, 75);
{
setState(3905);
match(SHOW);
setState(3906);
match(CACHE);
setState(3907);
match(HOTSPOT);
setState(3908);
((ShowCacheHotSpotContext)_localctx).tablePath = match(STRING_LITERAL);
}
break;
case 76:
_localctx = new ShowEncryptKeysContext(_localctx);
enterOuterAlt(_localctx, 76);
{
setState(3909);
match(SHOW);
setState(3910);
match(ENCRYPTKEYS);
setState(3913);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,496,_ctx) ) {
case 1:
{
setState(3911);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3912);
((ShowEncryptKeysContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3916);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,497,_ctx) ) {
case 1:
{
setState(3915);
wildWhere();
}
break;
}
}
break;
case 77:
_localctx = new ShowTableCreationContext(_localctx);
enterOuterAlt(_localctx, 77);
{
setState(3918);
match(SHOW);
setState(3919);
match(TABLE);
setState(3920);
match(CREATION);
setState(3923);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,498,_ctx) ) {
case 1:
{
setState(3921);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3922);
((ShowTableCreationContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3926);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,499,_ctx) ) {
case 1:
{
setState(3925);
wildWhere();
}
break;
}
}
break;
case 78:
_localctx = new ShowLastInsertContext(_localctx);
enterOuterAlt(_localctx, 78);
{
setState(3928);
match(SHOW);
setState(3929);
match(LAST);
setState(3930);
match(INSERT);
}
break;
case 79:
_localctx = new ShowCreateMaterializedViewContext(_localctx);
enterOuterAlt(_localctx, 79);
{
setState(3931);
match(SHOW);
setState(3932);
match(CREATE);
setState(3933);
match(MATERIALIZED);
setState(3934);
match(VIEW);
setState(3935);
((ShowCreateMaterializedViewContext)_localctx).mvName = identifier();
setState(3936);
match(ON);
setState(3937);
((ShowCreateMaterializedViewContext)_localctx).tableName = multipartIdentifier();
}
break;
case 80:
_localctx = new ShowCatalogRecycleBinContext(_localctx);
enterOuterAlt(_localctx, 80);
{
setState(3939);
match(SHOW);
setState(3940);
match(CATALOG);
setState(3941);
match(RECYCLE);
setState(3942);
match(BIN);
setState(3944);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,500,_ctx) ) {
case 1:
{
setState(3943);
wildWhere();
}
break;
}
}
break;
case 81:
_localctx = new ShowQueryStatsContext(_localctx);
enterOuterAlt(_localctx, 81);
{
setState(3946);
match(SHOW);
setState(3947);
match(QUERY);
setState(3948);
match(STATS);
setState(3959);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,503,_ctx) ) {
case 1:
{
{
setState(3949);
match(FOR);
setState(3950);
((ShowQueryStatsContext)_localctx).database = identifier();
}
}
break;
case 2:
{
{
setState(3951);
match(FROM);
setState(3952);
((ShowQueryStatsContext)_localctx).tableName = multipartIdentifier();
setState(3957);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,502,_ctx) ) {
case 1:
{
setState(3953);
match(ALL);
setState(3955);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,501,_ctx) ) {
case 1:
{
setState(3954);
match(VERBOSE);
}
break;
}
}
break;
}
}
}
break;
}
}
break;
case 82:
_localctx = new ShowBuildIndexContext(_localctx);
enterOuterAlt(_localctx, 82);
{
setState(3961);
match(SHOW);
setState(3962);
match(BUILD);
setState(3963);
match(INDEX);
setState(3966);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,504,_ctx) ) {
case 1:
{
setState(3964);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3965);
((ShowBuildIndexContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(3969);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,505,_ctx) ) {
case 1:
{
setState(3968);
wildWhere();
}
break;
}
setState(3972);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,506,_ctx) ) {
case 1:
{
setState(3971);
sortClause();
}
break;
}
setState(3975);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,507,_ctx) ) {
case 1:
{
setState(3974);
limitClause();
}
break;
}
}
break;
case 83:
_localctx = new ShowClustersContext(_localctx);
enterOuterAlt(_localctx, 83);
{
setState(3977);
match(SHOW);
setState(3981);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLUSTERS:
{
setState(3978);
match(CLUSTERS);
}
break;
case COMPUTE:
{
{
setState(3979);
match(COMPUTE);
setState(3980);
match(GROUPS);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 84:
_localctx = new ShowConvertLscContext(_localctx);
enterOuterAlt(_localctx, 84);
{
setState(3983);
match(SHOW);
setState(3984);
match(CONVERT_LSC);
setState(3987);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,509,_ctx) ) {
case 1:
{
setState(3985);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(3986);
((ShowConvertLscContext)_localctx).database = multipartIdentifier();
}
break;
}
}
break;
case 85:
_localctx = new ShowReplicaStatusContext(_localctx);
enterOuterAlt(_localctx, 85);
{
setState(3989);
match(SHOW);
setState(3990);
match(REPLICA);
setState(3991);
match(STATUS);
setState(3992);
match(FROM);
setState(3993);
baseTableRef();
setState(3995);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,510,_ctx) ) {
case 1:
{
setState(3994);
wildWhere();
}
break;
}
}
break;
case 86:
_localctx = new ShowREplicaDistributionContext(_localctx);
enterOuterAlt(_localctx, 86);
{
setState(3997);
match(SHOW);
setState(3998);
match(REPLICA);
setState(3999);
match(DISTRIBUTION);
setState(4000);
match(FROM);
setState(4001);
baseTableRef();
}
break;
case 87:
_localctx = new ShowTabletStorageFormatContext(_localctx);
enterOuterAlt(_localctx, 87);
{
setState(4002);
match(SHOW);
setState(4003);
match(TABLET);
setState(4004);
match(STORAGE);
setState(4005);
match(FORMAT);
setState(4007);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,511,_ctx) ) {
case 1:
{
setState(4006);
match(VERBOSE);
}
break;
}
}
break;
case 88:
_localctx = new ShowDiagnoseTabletContext(_localctx);
enterOuterAlt(_localctx, 88);
{
setState(4009);
match(SHOW);
setState(4010);
match(TABLET);
setState(4011);
match(DIAGNOSIS);
setState(4012);
((ShowDiagnoseTabletContext)_localctx).tabletId = match(INTEGER_VALUE);
}
break;
case 89:
_localctx = new ShowCopyContext(_localctx);
enterOuterAlt(_localctx, 89);
{
setState(4013);
match(SHOW);
setState(4014);
match(COPY);
setState(4017);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,512,_ctx) ) {
case 1:
{
setState(4015);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4016);
((ShowCopyContext)_localctx).database = multipartIdentifier();
}
break;
}
setState(4020);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,513,_ctx) ) {
case 1:
{
setState(4019);
whereClause();
}
break;
}
setState(4023);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,514,_ctx) ) {
case 1:
{
setState(4022);
sortClause();
}
break;
}
setState(4026);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,515,_ctx) ) {
case 1:
{
setState(4025);
limitClause();
}
break;
}
}
break;
case 90:
_localctx = new ShowWarmUpJobContext(_localctx);
enterOuterAlt(_localctx, 90);
{
setState(4028);
match(SHOW);
setState(4029);
match(WARM);
setState(4030);
match(UP);
setState(4031);
match(JOB);
setState(4033);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,516,_ctx) ) {
case 1:
{
setState(4032);
wildWhere();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedLoadStatementContext extends ParserRuleContext {
public UnsupportedLoadStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedLoadStatement; }
public UnsupportedLoadStatementContext() { }
public void copyFrom(UnsupportedLoadStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRoutineLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportWhereStatementAliasContext extends UnsupportedLoadStatementContext {
public ImportWhereStatementContext importWhereStatement() {
return getRuleContext(ImportWhereStatementContext.class,0);
}
public ImportWhereStatementAliasContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportWhereStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportWhereStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportWhereStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ResumeRoutineLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode RESUME() { return getToken(PLParser.RESUME, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ResumeRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResumeRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResumeRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResumeRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowCreateLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportPrecedingFilterStatementAliasContext extends UnsupportedLoadStatementContext {
public ImportPrecedingFilterStatementContext importPrecedingFilterStatement() {
return getRuleContext(ImportPrecedingFilterStatementContext.class,0);
}
public ImportPrecedingFilterStatementAliasContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportPrecedingFilterStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportPrecedingFilterStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportPrecedingFilterStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PauseAllRoutineLoadContext extends UnsupportedLoadStatementContext {
public TerminalNode PAUSE() { return getToken(PLParser.PAUSE, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public PauseAllRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPauseAllRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPauseAllRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPauseAllRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SyncContext extends UnsupportedLoadStatementContext {
public TerminalNode SYNC() { return getToken(PLParser.SYNC, 0); }
public SyncContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSync(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSync(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSync(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportSequenceStatementAliasContext extends UnsupportedLoadStatementContext {
public ImportSequenceStatementContext importSequenceStatement() {
return getRuleContext(ImportSequenceStatementContext.class,0);
}
public ImportSequenceStatementAliasContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportSequenceStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportSequenceStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportSequenceStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MysqlLoadContext extends UnsupportedLoadStatementContext {
public PropertyItemListContext properties;
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public MysqlDataDescContext mysqlDataDesc() {
return getRuleContext(MysqlDataDescContext.class,0);
}
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public MysqlLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMysqlLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMysqlLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMysqlLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowCreateRoutineLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public ShowCreateRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowCreateRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowCreateRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowCreateRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateRoutineLoadJobContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public IdentifierContext table;
public IdentifierContext type;
public PropertyItemListContext customProperties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public List<LoadPropertyContext> loadProperty() {
return getRuleContexts(LoadPropertyContext.class);
}
public LoadPropertyContext loadProperty(int i) {
return getRuleContext(LoadPropertyContext.class,i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public TerminalNode APPEND() { return getToken(PLParser.APPEND, 0); }
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode MERGE() { return getToken(PLParser.MERGE, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CreateRoutineLoadJobContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateRoutineLoadJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateRoutineLoadJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateRoutineLoadJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportColumnsStatementAliasContext extends UnsupportedLoadStatementContext {
public ImportColumnsStatementContext importColumnsStatement() {
return getRuleContext(ImportColumnsStatementContext.class,0);
}
public ImportColumnsStatementAliasContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportColumnsStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportColumnsStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportColumnsStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PauseRoutineLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode PAUSE() { return getToken(PLParser.PAUSE, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PauseRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPauseRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPauseRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPauseRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportDeleteOnStatementAliasContext extends UnsupportedLoadStatementContext {
public ImportDeleteOnStatementContext importDeleteOnStatement() {
return getRuleContext(ImportDeleteOnStatementContext.class,0);
}
public ImportDeleteOnStatementAliasContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportDeleteOnStatementAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportDeleteOnStatementAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportDeleteOnStatementAlias(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowRoutineLoadTaskContext extends UnsupportedLoadStatementContext {
public IdentifierContext database;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode TASK() { return getToken(PLParser.TASK, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowRoutineLoadTaskContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowRoutineLoadTask(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowRoutineLoadTask(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowRoutineLoadTask(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ResumeAllRoutineLoadContext extends UnsupportedLoadStatementContext {
public TerminalNode RESUME() { return getToken(PLParser.RESUME, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public ResumeAllRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResumeAllRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResumeAllRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResumeAllRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StopRoutineLoadContext extends UnsupportedLoadStatementContext {
public MultipartIdentifierContext label;
public TerminalNode STOP() { return getToken(PLParser.STOP, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public StopRoutineLoadContext(UnsupportedLoadStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStopRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStopRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStopRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedLoadStatementContext unsupportedLoadStatement() throws RecognitionException {
UnsupportedLoadStatementContext _localctx = new UnsupportedLoadStatementContext(_ctx, getState());
enterRule(_localctx, 306, RULE_unsupportedLoadStatement);
int _la;
try {
setState(4149);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,532,_ctx) ) {
case 1:
_localctx = new MysqlLoadContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4037);
match(LOAD);
setState(4038);
mysqlDataDesc();
setState(4044);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,518,_ctx) ) {
case 1:
{
setState(4039);
match(PROPERTIES);
setState(4040);
match(LEFT_PAREN);
setState(4041);
((MysqlLoadContext)_localctx).properties = propertyItemList();
setState(4042);
match(RIGHT_PAREN);
}
break;
}
setState(4047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,519,_ctx) ) {
case 1:
{
setState(4046);
commentSpec();
}
break;
}
}
break;
case 2:
_localctx = new CreateRoutineLoadJobContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4049);
match(CREATE);
setState(4050);
match(ROUTINE);
setState(4051);
match(LOAD);
setState(4052);
((CreateRoutineLoadJobContext)_localctx).label = multipartIdentifier();
setState(4055);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(4053);
match(ON);
setState(4054);
((CreateRoutineLoadJobContext)_localctx).table = identifier();
}
}
setState(4059);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(4057);
match(WITH);
setState(4058);
_la = _input.LA(1);
if ( !(_la==APPEND || _la==DELETE || _la==MERGE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(4069);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLUMNS || _la==DELETE || ((((_la - 498)) & ~0x3f) == 0 && ((1L << (_la - 498)) & 536871297L) != 0) || _la==TEMPORARY || _la==WHERE) {
{
setState(4061);
loadProperty();
setState(4066);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4062);
match(COMMA);
setState(4063);
loadProperty();
}
}
setState(4068);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(4072);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROPERTIES) {
{
setState(4071);
propertyClause();
}
}
setState(4074);
match(FROM);
setState(4075);
((CreateRoutineLoadJobContext)_localctx).type = identifier();
setState(4076);
match(LEFT_PAREN);
setState(4077);
((CreateRoutineLoadJobContext)_localctx).customProperties = propertyItemList();
setState(4078);
match(RIGHT_PAREN);
setState(4080);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,525,_ctx) ) {
case 1:
{
setState(4079);
commentSpec();
}
break;
}
}
break;
case 3:
_localctx = new PauseRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4082);
match(PAUSE);
setState(4083);
match(ROUTINE);
setState(4084);
match(LOAD);
setState(4085);
match(FOR);
setState(4086);
((PauseRoutineLoadContext)_localctx).label = multipartIdentifier();
}
break;
case 4:
_localctx = new PauseAllRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4087);
match(PAUSE);
setState(4088);
match(ALL);
setState(4089);
match(ROUTINE);
setState(4090);
match(LOAD);
}
break;
case 5:
_localctx = new ResumeRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4091);
match(RESUME);
setState(4092);
match(ROUTINE);
setState(4093);
match(LOAD);
setState(4094);
match(FOR);
setState(4095);
((ResumeRoutineLoadContext)_localctx).label = multipartIdentifier();
}
break;
case 6:
_localctx = new ResumeAllRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4096);
match(RESUME);
setState(4097);
match(ALL);
setState(4098);
match(ROUTINE);
setState(4099);
match(LOAD);
}
break;
case 7:
_localctx = new StopRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4100);
match(STOP);
setState(4101);
match(ROUTINE);
setState(4102);
match(LOAD);
setState(4103);
match(FOR);
setState(4104);
((StopRoutineLoadContext)_localctx).label = multipartIdentifier();
}
break;
case 8:
_localctx = new ShowRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(4105);
match(SHOW);
setState(4107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(4106);
match(ALL);
}
}
setState(4109);
match(ROUTINE);
setState(4110);
match(LOAD);
setState(4116);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,528,_ctx) ) {
case 1:
{
{
setState(4111);
match(FOR);
setState(4112);
((ShowRoutineLoadContext)_localctx).label = multipartIdentifier();
}
}
break;
case 2:
{
setState(4114);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,527,_ctx) ) {
case 1:
{
setState(4113);
wildWhere();
}
break;
}
}
break;
}
}
break;
case 9:
_localctx = new ShowRoutineLoadTaskContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(4118);
match(SHOW);
setState(4119);
match(ROUTINE);
setState(4120);
match(LOAD);
setState(4121);
match(TASK);
setState(4124);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,529,_ctx) ) {
case 1:
{
setState(4122);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4123);
((ShowRoutineLoadTaskContext)_localctx).database = identifier();
}
break;
}
setState(4127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,530,_ctx) ) {
case 1:
{
setState(4126);
wildWhere();
}
break;
}
}
break;
case 10:
_localctx = new ShowCreateRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(4129);
match(SHOW);
setState(4131);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(4130);
match(ALL);
}
}
setState(4133);
match(CREATE);
setState(4134);
match(ROUTINE);
setState(4135);
match(LOAD);
setState(4136);
match(FOR);
setState(4137);
((ShowCreateRoutineLoadContext)_localctx).label = multipartIdentifier();
}
break;
case 11:
_localctx = new ShowCreateLoadContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(4138);
match(SHOW);
setState(4139);
match(CREATE);
setState(4140);
match(LOAD);
setState(4141);
match(FOR);
setState(4142);
((ShowCreateLoadContext)_localctx).label = multipartIdentifier();
}
break;
case 12:
_localctx = new SyncContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(4143);
match(SYNC);
}
break;
case 13:
_localctx = new ImportSequenceStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(4144);
importSequenceStatement();
}
break;
case 14:
_localctx = new ImportPrecedingFilterStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(4145);
importPrecedingFilterStatement();
}
break;
case 15:
_localctx = new ImportWhereStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(4146);
importWhereStatement();
}
break;
case 16:
_localctx = new ImportDeleteOnStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(4147);
importDeleteOnStatement();
}
break;
case 17:
_localctx = new ImportColumnsStatementAliasContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(4148);
importColumnsStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LoadPropertyContext extends ParserRuleContext {
public LoadPropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loadProperty; }
public LoadPropertyContext() { }
public void copyFrom(LoadPropertyContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportPrecedingFilterContext extends LoadPropertyContext {
public ImportPrecedingFilterStatementContext importPrecedingFilterStatement() {
return getRuleContext(ImportPrecedingFilterStatementContext.class,0);
}
public ImportPrecedingFilterContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportPrecedingFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportPrecedingFilter(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportPrecedingFilter(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportSequenceContext extends LoadPropertyContext {
public ImportSequenceStatementContext importSequenceStatement() {
return getRuleContext(ImportSequenceStatementContext.class,0);
}
public ImportSequenceContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportSequence(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportSequence(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportColumnsContext extends LoadPropertyContext {
public ImportColumnsStatementContext importColumnsStatement() {
return getRuleContext(ImportColumnsStatementContext.class,0);
}
public ImportColumnsContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportColumns(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportColumns(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportWhereContext extends LoadPropertyContext {
public ImportWhereStatementContext importWhereStatement() {
return getRuleContext(ImportWhereStatementContext.class,0);
}
public ImportWhereContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportWhere(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportWhere(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportWhere(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SeparatorContext extends LoadPropertyContext {
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public TerminalNode TERMINATED() { return getToken(PLParser.TERMINATED, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public SeparatorContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSeparator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSeparator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSeparator(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportPartitionsContext extends LoadPropertyContext {
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public ImportPartitionsContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportPartitions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportPartitions(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImportDeleteOnContext extends LoadPropertyContext {
public ImportDeleteOnStatementContext importDeleteOnStatement() {
return getRuleContext(ImportDeleteOnStatementContext.class,0);
}
public ImportDeleteOnContext(LoadPropertyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportDeleteOn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportDeleteOn(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportDeleteOn(this);
else return visitor.visitChildren(this);
}
}
public final LoadPropertyContext loadProperty() throws RecognitionException {
LoadPropertyContext _localctx = new LoadPropertyContext(_ctx, getState());
enterRule(_localctx, 308, RULE_loadProperty);
try {
setState(4161);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,533,_ctx) ) {
case 1:
_localctx = new SeparatorContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4151);
match(COLUMNS);
setState(4152);
match(TERMINATED);
setState(4153);
match(BY);
setState(4154);
match(STRING_LITERAL);
}
break;
case 2:
_localctx = new ImportColumnsContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4155);
importColumnsStatement();
}
break;
case 3:
_localctx = new ImportPrecedingFilterContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4156);
importPrecedingFilterStatement();
}
break;
case 4:
_localctx = new ImportWhereContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4157);
importWhereStatement();
}
break;
case 5:
_localctx = new ImportDeleteOnContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4158);
importDeleteOnStatement();
}
break;
case 6:
_localctx = new ImportSequenceContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4159);
importSequenceStatement();
}
break;
case 7:
_localctx = new ImportPartitionsContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4160);
partitionSpec();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportSequenceStatementContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ImportSequenceStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importSequenceStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportSequenceStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportSequenceStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportSequenceStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportSequenceStatementContext importSequenceStatement() throws RecognitionException {
ImportSequenceStatementContext _localctx = new ImportSequenceStatementContext(_ctx, getState());
enterRule(_localctx, 310, RULE_importSequenceStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(4163);
match(ORDER);
setState(4164);
match(BY);
setState(4165);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportDeleteOnStatementContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ImportDeleteOnStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDeleteOnStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportDeleteOnStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportDeleteOnStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportDeleteOnStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportDeleteOnStatementContext importDeleteOnStatement() throws RecognitionException {
ImportDeleteOnStatementContext _localctx = new ImportDeleteOnStatementContext(_ctx, getState());
enterRule(_localctx, 312, RULE_importDeleteOnStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(4167);
match(DELETE);
setState(4168);
match(ON);
setState(4169);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportWhereStatementContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(PLParser.WHERE, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ImportWhereStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importWhereStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportWhereStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportWhereStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportWhereStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportWhereStatementContext importWhereStatement() throws RecognitionException {
ImportWhereStatementContext _localctx = new ImportWhereStatementContext(_ctx, getState());
enterRule(_localctx, 314, RULE_importWhereStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(4171);
match(WHERE);
setState(4172);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportPrecedingFilterStatementContext extends ParserRuleContext {
public TerminalNode PRECEDING() { return getToken(PLParser.PRECEDING, 0); }
public TerminalNode FILTER() { return getToken(PLParser.FILTER, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ImportPrecedingFilterStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importPrecedingFilterStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportPrecedingFilterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportPrecedingFilterStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportPrecedingFilterStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportPrecedingFilterStatementContext importPrecedingFilterStatement() throws RecognitionException {
ImportPrecedingFilterStatementContext _localctx = new ImportPrecedingFilterStatementContext(_ctx, getState());
enterRule(_localctx, 316, RULE_importPrecedingFilterStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(4174);
match(PRECEDING);
setState(4175);
match(FILTER);
setState(4176);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportColumnsStatementContext extends ParserRuleContext {
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<ImportColumnDescContext> importColumnDesc() {
return getRuleContexts(ImportColumnDescContext.class);
}
public ImportColumnDescContext importColumnDesc(int i) {
return getRuleContext(ImportColumnDescContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ImportColumnsStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importColumnsStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportColumnsStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportColumnsStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportColumnsStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportColumnsStatementContext importColumnsStatement() throws RecognitionException {
ImportColumnsStatementContext _localctx = new ImportColumnsStatementContext(_ctx, getState());
enterRule(_localctx, 318, RULE_importColumnsStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(4178);
match(COLUMNS);
setState(4179);
match(LEFT_PAREN);
setState(4180);
importColumnDesc();
setState(4185);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4181);
match(COMMA);
setState(4182);
importColumnDesc();
}
}
setState(4187);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4188);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportColumnDescContext extends ParserRuleContext {
public IdentifierContext name;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ImportColumnDescContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importColumnDesc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterImportColumnDesc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitImportColumnDesc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitImportColumnDesc(this);
else return visitor.visitChildren(this);
}
}
public final ImportColumnDescContext importColumnDesc() throws RecognitionException {
ImportColumnDescContext _localctx = new ImportColumnDescContext(_ctx, getState());
enterRule(_localctx, 320, RULE_importColumnDesc);
int _la;
try {
setState(4203);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(4190);
((ImportColumnDescContext)_localctx).name = identifier();
setState(4193);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(4191);
match(EQ);
setState(4192);
booleanExpression(0);
}
}
}
break;
case LEFT_PAREN:
enterOuterAlt(_localctx, 2);
{
setState(4195);
match(LEFT_PAREN);
setState(4196);
((ImportColumnDescContext)_localctx).name = identifier();
setState(4199);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(4197);
match(EQ);
setState(4198);
booleanExpression(0);
}
}
setState(4201);
match(RIGHT_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedRefreshStatementContext extends ParserRuleContext {
public UnsupportedRefreshStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedRefreshStatement; }
public UnsupportedRefreshStatementContext() { }
public void copyFrom(UnsupportedRefreshStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshCatalogContext extends UnsupportedRefreshStatementContext {
public IdentifierContext name;
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public RefreshCatalogContext(UnsupportedRefreshStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshTableContext extends UnsupportedRefreshStatementContext {
public MultipartIdentifierContext name;
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public RefreshTableContext(UnsupportedRefreshStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshDatabaseContext extends UnsupportedRefreshStatementContext {
public MultipartIdentifierContext name;
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public RefreshDatabaseContext(UnsupportedRefreshStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshLdapContext extends UnsupportedRefreshStatementContext {
public IdentifierOrTextContext user;
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode LDAP() { return getToken(PLParser.LDAP, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public RefreshLdapContext(UnsupportedRefreshStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshLdap(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshLdap(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshLdap(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedRefreshStatementContext unsupportedRefreshStatement() throws RecognitionException {
UnsupportedRefreshStatementContext _localctx = new UnsupportedRefreshStatementContext(_ctx, getState());
enterRule(_localctx, 322, RULE_unsupportedRefreshStatement);
try {
setState(4227);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,541,_ctx) ) {
case 1:
_localctx = new RefreshTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4205);
match(REFRESH);
setState(4206);
match(TABLE);
setState(4207);
((RefreshTableContext)_localctx).name = multipartIdentifier();
}
break;
case 2:
_localctx = new RefreshDatabaseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4208);
match(REFRESH);
setState(4209);
match(DATABASE);
setState(4210);
((RefreshDatabaseContext)_localctx).name = multipartIdentifier();
setState(4212);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,538,_ctx) ) {
case 1:
{
setState(4211);
propertyClause();
}
break;
}
}
break;
case 3:
_localctx = new RefreshCatalogContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4214);
match(REFRESH);
setState(4215);
match(CATALOG);
setState(4216);
((RefreshCatalogContext)_localctx).name = identifier();
setState(4218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,539,_ctx) ) {
case 1:
{
setState(4217);
propertyClause();
}
break;
}
}
break;
case 4:
_localctx = new RefreshLdapContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4220);
match(REFRESH);
setState(4221);
match(LDAP);
setState(4225);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(4222);
match(ALL);
}
break;
case FOR:
{
{
setState(4223);
match(FOR);
setState(4224);
((RefreshLdapContext)_localctx).user = identifierOrText();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedCleanStatementContext extends ParserRuleContext {
public UnsupportedCleanStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedCleanStatement; }
public UnsupportedCleanStatementContext() { }
public void copyFrom(UnsupportedCleanStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CleanLabelContext extends UnsupportedCleanStatementContext {
public IdentifierContext label;
public IdentifierContext database;
public TerminalNode CLEAN() { return getToken(PLParser.CLEAN, 0); }
public TerminalNode LABEL() { return getToken(PLParser.LABEL, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public CleanLabelContext(UnsupportedCleanStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCleanLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCleanLabel(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCleanLabel(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CleanQueryStatsContext extends UnsupportedCleanStatementContext {
public IdentifierContext database;
public MultipartIdentifierContext table;
public TerminalNode CLEAN() { return getToken(PLParser.CLEAN, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public CleanQueryStatsContext(UnsupportedCleanStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCleanQueryStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCleanQueryStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCleanQueryStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CleanAllProfileContext extends UnsupportedCleanStatementContext {
public TerminalNode CLEAN() { return getToken(PLParser.CLEAN, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode PROFILE() { return getToken(PLParser.PROFILE, 0); }
public CleanAllProfileContext(UnsupportedCleanStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCleanAllProfile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCleanAllProfile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCleanAllProfile(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CleanAllQueryStatsContext extends UnsupportedCleanStatementContext {
public TerminalNode CLEAN() { return getToken(PLParser.CLEAN, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public CleanAllQueryStatsContext(UnsupportedCleanStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCleanAllQueryStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCleanAllQueryStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCleanAllQueryStats(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedCleanStatementContext unsupportedCleanStatement() throws RecognitionException {
UnsupportedCleanStatementContext _localctx = new UnsupportedCleanStatementContext(_ctx, getState());
enterRule(_localctx, 324, RULE_unsupportedCleanStatement);
int _la;
try {
setState(4252);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,544,_ctx) ) {
case 1:
_localctx = new CleanLabelContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4229);
match(CLEAN);
setState(4230);
match(LABEL);
setState(4232);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3927138875067072511L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731775120419L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761490469167143L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & 9222670387358137151L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -7342142259167539995L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305842422950835435L) != 0) || _la==IDENTIFIER || _la==BACKQUOTED_IDENTIFIER) {
{
setState(4231);
((CleanLabelContext)_localctx).label = identifier();
}
}
setState(4234);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4235);
((CleanLabelContext)_localctx).database = identifier();
}
break;
case 2:
_localctx = new CleanAllProfileContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4236);
match(CLEAN);
setState(4237);
match(ALL);
setState(4238);
match(PROFILE);
}
break;
case 3:
_localctx = new CleanQueryStatsContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4239);
match(CLEAN);
setState(4240);
match(QUERY);
setState(4241);
match(STATS);
setState(4246);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
{
{
setState(4242);
match(FOR);
setState(4243);
((CleanQueryStatsContext)_localctx).database = identifier();
}
}
break;
case FROM:
case IN:
{
{
setState(4244);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4245);
((CleanQueryStatsContext)_localctx).table = multipartIdentifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
_localctx = new CleanAllQueryStatsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4248);
match(CLEAN);
setState(4249);
match(ALL);
setState(4250);
match(QUERY);
setState(4251);
match(STATS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedJobStatementContext extends ParserRuleContext {
public UnsupportedJobStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedJobStatement; }
public UnsupportedJobStatementContext() { }
public void copyFrom(UnsupportedJobStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelJobTaskContext extends UnsupportedJobStatementContext {
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode TASK() { return getToken(PLParser.TASK, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public CancelJobTaskContext(UnsupportedJobStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelJobTask(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelJobTask(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelJobTask(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ResumeJobContext extends UnsupportedJobStatementContext {
public TerminalNode RESUME() { return getToken(PLParser.RESUME, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ResumeJobContext(UnsupportedJobStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResumeJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResumeJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResumeJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropJobContext extends UnsupportedJobStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public DropJobContext(UnsupportedJobStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PauseJobContext extends UnsupportedJobStatementContext {
public TerminalNode PAUSE() { return getToken(PLParser.PAUSE, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public PauseJobContext(UnsupportedJobStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPauseJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPauseJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPauseJob(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedJobStatementContext unsupportedJobStatement() throws RecognitionException {
UnsupportedJobStatementContext _localctx = new UnsupportedJobStatementContext(_ctx, getState());
enterRule(_localctx, 326, RULE_unsupportedJobStatement);
try {
setState(4278);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PAUSE:
_localctx = new PauseJobContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4254);
match(PAUSE);
setState(4255);
match(JOB);
setState(4257);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,545,_ctx) ) {
case 1:
{
setState(4256);
wildWhere();
}
break;
}
}
break;
case DROP:
_localctx = new DropJobContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4259);
match(DROP);
setState(4260);
match(JOB);
setState(4263);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,546,_ctx) ) {
case 1:
{
setState(4261);
match(IF);
setState(4262);
match(EXISTS);
}
break;
}
setState(4266);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,547,_ctx) ) {
case 1:
{
setState(4265);
wildWhere();
}
break;
}
}
break;
case RESUME:
_localctx = new ResumeJobContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4268);
match(RESUME);
setState(4269);
match(JOB);
setState(4271);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,548,_ctx) ) {
case 1:
{
setState(4270);
wildWhere();
}
break;
}
}
break;
case CANCEL:
_localctx = new CancelJobTaskContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4273);
match(CANCEL);
setState(4274);
match(TASK);
setState(4276);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,549,_ctx) ) {
case 1:
{
setState(4275);
wildWhere();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedCancelStatementContext extends ParserRuleContext {
public UnsupportedCancelStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedCancelStatement; }
public UnsupportedCancelStatementContext() { }
public void copyFrom(UnsupportedCancelStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelBackupContext extends UnsupportedCancelStatementContext {
public IdentifierContext database;
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode BACKUP() { return getToken(PLParser.BACKUP, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CancelBackupContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelBackup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelBackup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelBackup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelWarmUpContext extends UnsupportedCancelStatementContext {
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode WARM() { return getToken(PLParser.WARM, 0); }
public TerminalNode UP() { return getToken(PLParser.UP, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public CancelWarmUpContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelWarmUp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelWarmUp(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelWarmUp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelExportContext extends UnsupportedCancelStatementContext {
public IdentifierContext database;
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode EXPORT() { return getToken(PLParser.EXPORT, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CancelExportContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelExport(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelExport(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelExport(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelBuildIndexContext extends UnsupportedCancelStatementContext {
public MultipartIdentifierContext tableName;
public Token INTEGER_VALUE;
public List<Token> jobIds = new ArrayList<Token>();
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode BUILD() { return getToken(PLParser.BUILD, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CancelBuildIndexContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelBuildIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelBuildIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelBuildIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelRestoreContext extends UnsupportedCancelStatementContext {
public IdentifierContext database;
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode RESTORE() { return getToken(PLParser.RESTORE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CancelRestoreContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelRestore(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelRestore(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelRestore(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelLoadContext extends UnsupportedCancelStatementContext {
public IdentifierContext database;
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CancelLoadContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelAlterTableContext extends UnsupportedCancelStatementContext {
public MultipartIdentifierContext tableName;
public Token INTEGER_VALUE;
public List<Token> jobIds = new ArrayList<Token>();
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CancelAlterTableContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelAlterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelAlterTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelAlterTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CancelDecommisionBackendContext extends UnsupportedCancelStatementContext {
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode DECOMMISSION() { return getToken(PLParser.DECOMMISSION, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CancelDecommisionBackendContext(UnsupportedCancelStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCancelDecommisionBackend(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCancelDecommisionBackend(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCancelDecommisionBackend(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedCancelStatementContext unsupportedCancelStatement() throws RecognitionException {
UnsupportedCancelStatementContext _localctx = new UnsupportedCancelStatementContext(_ctx, getState());
enterRule(_localctx, 328, RULE_unsupportedCancelStatement);
int _la;
try {
int _alt;
setState(4368);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,564,_ctx) ) {
case 1:
_localctx = new CancelLoadContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4280);
match(CANCEL);
setState(4281);
match(LOAD);
setState(4284);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,551,_ctx) ) {
case 1:
{
setState(4282);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4283);
((CancelLoadContext)_localctx).database = identifier();
}
break;
}
setState(4287);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,552,_ctx) ) {
case 1:
{
setState(4286);
wildWhere();
}
break;
}
}
break;
case 2:
_localctx = new CancelExportContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4289);
match(CANCEL);
setState(4290);
match(EXPORT);
setState(4293);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,553,_ctx) ) {
case 1:
{
setState(4291);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4292);
((CancelExportContext)_localctx).database = identifier();
}
break;
}
setState(4296);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,554,_ctx) ) {
case 1:
{
setState(4295);
wildWhere();
}
break;
}
}
break;
case 3:
_localctx = new CancelAlterTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4298);
match(CANCEL);
setState(4299);
match(ALTER);
setState(4300);
match(TABLE);
setState(4305);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROLLUP:
{
setState(4301);
match(ROLLUP);
}
break;
case MATERIALIZED:
{
{
setState(4302);
match(MATERIALIZED);
setState(4303);
match(VIEW);
}
}
break;
case COLUMN:
{
setState(4304);
match(COLUMN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(4307);
match(FROM);
setState(4308);
((CancelAlterTableContext)_localctx).tableName = multipartIdentifier();
setState(4319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,557,_ctx) ) {
case 1:
{
setState(4309);
match(LEFT_PAREN);
setState(4310);
((CancelAlterTableContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((CancelAlterTableContext)_localctx).jobIds.add(((CancelAlterTableContext)_localctx).INTEGER_VALUE);
setState(4315);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4311);
match(COMMA);
setState(4312);
((CancelAlterTableContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((CancelAlterTableContext)_localctx).jobIds.add(((CancelAlterTableContext)_localctx).INTEGER_VALUE);
}
}
setState(4317);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4318);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 4:
_localctx = new CancelBuildIndexContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4321);
match(CANCEL);
setState(4322);
match(BUILD);
setState(4323);
match(INDEX);
setState(4324);
match(ON);
setState(4325);
((CancelBuildIndexContext)_localctx).tableName = multipartIdentifier();
setState(4336);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,559,_ctx) ) {
case 1:
{
setState(4326);
match(LEFT_PAREN);
setState(4327);
((CancelBuildIndexContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((CancelBuildIndexContext)_localctx).jobIds.add(((CancelBuildIndexContext)_localctx).INTEGER_VALUE);
setState(4332);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4328);
match(COMMA);
setState(4329);
((CancelBuildIndexContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((CancelBuildIndexContext)_localctx).jobIds.add(((CancelBuildIndexContext)_localctx).INTEGER_VALUE);
}
}
setState(4334);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4335);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 5:
_localctx = new CancelDecommisionBackendContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4338);
match(CANCEL);
setState(4339);
match(DECOMMISSION);
setState(4340);
match(BACKEND);
setState(4341);
((CancelDecommisionBackendContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((CancelDecommisionBackendContext)_localctx).hostPorts.add(((CancelDecommisionBackendContext)_localctx).STRING_LITERAL);
setState(4346);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,560,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4342);
match(COMMA);
setState(4343);
((CancelDecommisionBackendContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((CancelDecommisionBackendContext)_localctx).hostPorts.add(((CancelDecommisionBackendContext)_localctx).STRING_LITERAL);
}
}
}
setState(4348);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,560,_ctx);
}
}
break;
case 6:
_localctx = new CancelBackupContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4349);
match(CANCEL);
setState(4350);
match(BACKUP);
setState(4353);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,561,_ctx) ) {
case 1:
{
setState(4351);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4352);
((CancelBackupContext)_localctx).database = identifier();
}
break;
}
}
break;
case 7:
_localctx = new CancelRestoreContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4355);
match(CANCEL);
setState(4356);
match(RESTORE);
setState(4359);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,562,_ctx) ) {
case 1:
{
setState(4357);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4358);
((CancelRestoreContext)_localctx).database = identifier();
}
break;
}
}
break;
case 8:
_localctx = new CancelWarmUpContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(4361);
match(CANCEL);
setState(4362);
match(WARM);
setState(4363);
match(UP);
setState(4364);
match(JOB);
setState(4366);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,563,_ctx) ) {
case 1:
{
setState(4365);
wildWhere();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedRecoverStatementContext extends ParserRuleContext {
public UnsupportedRecoverStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedRecoverStatement; }
public UnsupportedRecoverStatementContext() { }
public void copyFrom(UnsupportedRecoverStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RecoverPartitionContext extends UnsupportedRecoverStatementContext {
public IdentifierContext name;
public Token id;
public IdentifierContext alias;
public MultipartIdentifierContext tableName;
public TerminalNode RECOVER() { return getToken(PLParser.RECOVER, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public RecoverPartitionContext(UnsupportedRecoverStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRecoverPartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRecoverPartition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRecoverPartition(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RecoverTableContext extends UnsupportedRecoverStatementContext {
public MultipartIdentifierContext name;
public Token id;
public IdentifierContext alias;
public TerminalNode RECOVER() { return getToken(PLParser.RECOVER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public RecoverTableContext(UnsupportedRecoverStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRecoverTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRecoverTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRecoverTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RecoverDatabaseContext extends UnsupportedRecoverStatementContext {
public IdentifierContext name;
public Token id;
public IdentifierContext alias;
public TerminalNode RECOVER() { return getToken(PLParser.RECOVER, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public RecoverDatabaseContext(UnsupportedRecoverStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRecoverDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRecoverDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRecoverDatabase(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedRecoverStatementContext unsupportedRecoverStatement() throws RecognitionException {
UnsupportedRecoverStatementContext _localctx = new UnsupportedRecoverStatementContext(_ctx, getState());
enterRule(_localctx, 330, RULE_unsupportedRecoverStatement);
int _la;
try {
setState(4403);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,571,_ctx) ) {
case 1:
_localctx = new RecoverDatabaseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4370);
match(RECOVER);
setState(4371);
match(DATABASE);
setState(4372);
((RecoverDatabaseContext)_localctx).name = identifier();
setState(4374);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,565,_ctx) ) {
case 1:
{
setState(4373);
((RecoverDatabaseContext)_localctx).id = match(INTEGER_VALUE);
}
break;
}
setState(4378);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,566,_ctx) ) {
case 1:
{
setState(4376);
match(AS);
setState(4377);
((RecoverDatabaseContext)_localctx).alias = identifier();
}
break;
}
}
break;
case 2:
_localctx = new RecoverTableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4380);
match(RECOVER);
setState(4381);
match(TABLE);
setState(4382);
((RecoverTableContext)_localctx).name = multipartIdentifier();
setState(4384);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,567,_ctx) ) {
case 1:
{
setState(4383);
((RecoverTableContext)_localctx).id = match(INTEGER_VALUE);
}
break;
}
setState(4388);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,568,_ctx) ) {
case 1:
{
setState(4386);
match(AS);
setState(4387);
((RecoverTableContext)_localctx).alias = identifier();
}
break;
}
}
break;
case 3:
_localctx = new RecoverPartitionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4390);
match(RECOVER);
setState(4391);
match(PARTITION);
setState(4392);
((RecoverPartitionContext)_localctx).name = identifier();
setState(4394);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTEGER_VALUE) {
{
setState(4393);
((RecoverPartitionContext)_localctx).id = match(INTEGER_VALUE);
}
}
setState(4398);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(4396);
match(AS);
setState(4397);
((RecoverPartitionContext)_localctx).alias = identifier();
}
}
setState(4400);
match(FROM);
setState(4401);
((RecoverPartitionContext)_localctx).tableName = multipartIdentifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedAdminStatementContext extends ParserRuleContext {
public UnsupportedAdminStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedAdminStatement; }
public UnsupportedAdminStatementContext() { }
public void copyFrom(UnsupportedAdminStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminShowReplicaDistributionContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode DISTRIBUTION() { return getToken(PLParser.DISTRIBUTION, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public AdminShowReplicaDistributionContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminShowReplicaDistribution(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminShowReplicaDistribution(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminShowReplicaDistribution(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminShowTabletStorageFormatContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode FORMAT() { return getToken(PLParser.FORMAT, 0); }
public TerminalNode VERBOSE() { return getToken(PLParser.VERBOSE, 0); }
public AdminShowTabletStorageFormatContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminShowTabletStorageFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminShowTabletStorageFormat(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminShowTabletStorageFormat(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminSetReplicaStatusContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public AdminSetReplicaStatusContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminSetReplicaStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminSetReplicaStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminSetReplicaStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminRebalanceDiskContext extends UnsupportedAdminStatementContext {
public Token STRING_LITERAL;
public List<Token> backends = new ArrayList<Token>();
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode REBALANCE() { return getToken(PLParser.REBALANCE, 0); }
public TerminalNode DISK() { return getToken(PLParser.DISK, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public AdminRebalanceDiskContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminRebalanceDisk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminRebalanceDisk(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminRebalanceDisk(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminSetReplicaVersionContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public AdminSetReplicaVersionContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminSetReplicaVersion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminSetReplicaVersion(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminSetReplicaVersion(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminSetTableStatusContext extends UnsupportedAdminStatementContext {
public MultipartIdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AdminSetTableStatusContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminSetTableStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminSetTableStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminSetTableStatus(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminSetPartitionVersionContext extends UnsupportedAdminStatementContext {
public MultipartIdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AdminSetPartitionVersionContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminSetPartitionVersion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminSetPartitionVersion(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminSetPartitionVersion(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCancelRepairTableContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode REPAIR() { return getToken(PLParser.REPAIR, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public AdminCancelRepairTableContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCancelRepairTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCancelRepairTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCancelRepairTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCopyTabletContext extends UnsupportedAdminStatementContext {
public Token tabletId;
public PropertyClauseContext properties;
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode COPY() { return getToken(PLParser.COPY, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AdminCopyTabletContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCopyTablet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCopyTablet(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCopyTablet(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminRepairTableContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode REPAIR() { return getToken(PLParser.REPAIR, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public AdminRepairTableContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminRepairTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminRepairTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminRepairTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminSetFrontendConfigContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode CONFIG() { return getToken(PLParser.CONFIG, 0); }
public TerminalNode FRONTEND() { return getToken(PLParser.FRONTEND, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> ALL() { return getTokens(PLParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(PLParser.ALL, i);
}
public TerminalNode FRONTENDS() { return getToken(PLParser.FRONTENDS, 0); }
public AdminSetFrontendConfigContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminSetFrontendConfig(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminSetFrontendConfig(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminSetFrontendConfig(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCheckTabletsContext extends UnsupportedAdminStatementContext {
public PropertyClauseContext properties;
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode CHECK() { return getToken(PLParser.CHECK, 0); }
public TabletListContext tabletList() {
return getRuleContext(TabletListContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AdminCheckTabletsContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCheckTablets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCheckTablets(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCheckTablets(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCleanTrashContext extends UnsupportedAdminStatementContext {
public Token STRING_LITERAL;
public List<Token> backends = new ArrayList<Token>();
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode CLEAN() { return getToken(PLParser.CLEAN, 0); }
public TerminalNode TRASH() { return getToken(PLParser.TRASH, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public AdminCleanTrashContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCleanTrash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCleanTrash(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCleanTrash(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCompactTableContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode COMPACT() { return getToken(PLParser.COMPACT, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public AdminCompactTableContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCompactTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCompactTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCompactTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminDiagnoseTabletContext extends UnsupportedAdminStatementContext {
public Token tabletId;
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode DIAGNOSE() { return getToken(PLParser.DIAGNOSE, 0); }
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public AdminDiagnoseTabletContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminDiagnoseTablet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminDiagnoseTablet(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminDiagnoseTablet(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminCancelRebalanceDiskContext extends UnsupportedAdminStatementContext {
public Token STRING_LITERAL;
public List<Token> backends = new ArrayList<Token>();
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode CANCEL() { return getToken(PLParser.CANCEL, 0); }
public TerminalNode REBALANCE() { return getToken(PLParser.REBALANCE, 0); }
public TerminalNode DISK() { return getToken(PLParser.DISK, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public AdminCancelRebalanceDiskContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminCancelRebalanceDisk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminCancelRebalanceDisk(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminCancelRebalanceDisk(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdminShowReplicaStatusContext extends UnsupportedAdminStatementContext {
public TerminalNode ADMIN() { return getToken(PLParser.ADMIN, 0); }
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public BaseTableRefContext baseTableRef() {
return getRuleContext(BaseTableRefContext.class,0);
}
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public AdminShowReplicaStatusContext(UnsupportedAdminStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAdminShowReplicaStatus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAdminShowReplicaStatus(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAdminShowReplicaStatus(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedAdminStatementContext unsupportedAdminStatement() throws RecognitionException {
UnsupportedAdminStatementContext _localctx = new UnsupportedAdminStatementContext(_ctx, getState());
enterRule(_localctx, 332, RULE_unsupportedAdminStatement);
try {
setState(4550);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,585,_ctx) ) {
case 1:
_localctx = new AdminShowReplicaStatusContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4405);
match(ADMIN);
setState(4406);
match(SHOW);
setState(4407);
match(REPLICA);
setState(4408);
match(STATUS);
setState(4409);
match(FROM);
setState(4410);
baseTableRef();
setState(4412);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,572,_ctx) ) {
case 1:
{
setState(4411);
wildWhere();
}
break;
}
}
break;
case 2:
_localctx = new AdminShowReplicaDistributionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4414);
match(ADMIN);
setState(4415);
match(SHOW);
setState(4416);
match(REPLICA);
setState(4417);
match(DISTRIBUTION);
setState(4418);
match(FROM);
setState(4419);
baseTableRef();
}
break;
case 3:
_localctx = new AdminSetReplicaStatusContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4420);
match(ADMIN);
setState(4421);
match(SET);
setState(4422);
match(REPLICA);
setState(4423);
match(STATUS);
setState(4424);
match(PROPERTIES);
setState(4425);
match(LEFT_PAREN);
setState(4426);
propertyItemList();
setState(4427);
match(RIGHT_PAREN);
}
break;
case 4:
_localctx = new AdminSetReplicaVersionContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4429);
match(ADMIN);
setState(4430);
match(SET);
setState(4431);
match(REPLICA);
setState(4432);
match(VERSION);
setState(4433);
match(PROPERTIES);
setState(4434);
match(LEFT_PAREN);
setState(4435);
propertyItemList();
setState(4436);
match(RIGHT_PAREN);
}
break;
case 5:
_localctx = new AdminRepairTableContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4438);
match(ADMIN);
setState(4439);
match(REPAIR);
setState(4440);
match(TABLE);
setState(4441);
baseTableRef();
}
break;
case 6:
_localctx = new AdminCancelRepairTableContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4442);
match(ADMIN);
setState(4443);
match(CANCEL);
setState(4444);
match(REPAIR);
setState(4445);
match(TABLE);
setState(4446);
baseTableRef();
}
break;
case 7:
_localctx = new AdminCompactTableContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4447);
match(ADMIN);
setState(4448);
match(COMPACT);
setState(4449);
match(TABLE);
setState(4450);
baseTableRef();
setState(4452);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,573,_ctx) ) {
case 1:
{
setState(4451);
wildWhere();
}
break;
}
}
break;
case 8:
_localctx = new AdminSetFrontendConfigContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(4454);
match(ADMIN);
setState(4455);
match(SET);
setState(4459);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FRONTEND:
{
setState(4456);
match(FRONTEND);
}
break;
case ALL:
{
{
setState(4457);
match(ALL);
setState(4458);
match(FRONTENDS);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(4461);
match(CONFIG);
setState(4466);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,575,_ctx) ) {
case 1:
{
setState(4462);
match(LEFT_PAREN);
setState(4463);
propertyItemList();
setState(4464);
match(RIGHT_PAREN);
}
break;
}
setState(4469);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,576,_ctx) ) {
case 1:
{
setState(4468);
match(ALL);
}
break;
}
}
break;
case 9:
_localctx = new AdminCheckTabletsContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(4471);
match(ADMIN);
setState(4472);
match(CHECK);
setState(4473);
tabletList();
setState(4475);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,577,_ctx) ) {
case 1:
{
setState(4474);
((AdminCheckTabletsContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 10:
_localctx = new AdminRebalanceDiskContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(4477);
match(ADMIN);
setState(4478);
match(REBALANCE);
setState(4479);
match(DISK);
setState(4487);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,578,_ctx) ) {
case 1:
{
setState(4480);
match(ON);
setState(4481);
match(LEFT_PAREN);
setState(4482);
((AdminRebalanceDiskContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminRebalanceDiskContext)_localctx).backends.add(((AdminRebalanceDiskContext)_localctx).STRING_LITERAL);
{
setState(4483);
match(COMMA);
setState(4484);
((AdminRebalanceDiskContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminRebalanceDiskContext)_localctx).backends.add(((AdminRebalanceDiskContext)_localctx).STRING_LITERAL);
}
setState(4486);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 11:
_localctx = new AdminCancelRebalanceDiskContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(4489);
match(ADMIN);
setState(4490);
match(CANCEL);
setState(4491);
match(REBALANCE);
setState(4492);
match(DISK);
setState(4500);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,579,_ctx) ) {
case 1:
{
setState(4493);
match(ON);
setState(4494);
match(LEFT_PAREN);
setState(4495);
((AdminCancelRebalanceDiskContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminCancelRebalanceDiskContext)_localctx).backends.add(((AdminCancelRebalanceDiskContext)_localctx).STRING_LITERAL);
{
setState(4496);
match(COMMA);
setState(4497);
((AdminCancelRebalanceDiskContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminCancelRebalanceDiskContext)_localctx).backends.add(((AdminCancelRebalanceDiskContext)_localctx).STRING_LITERAL);
}
setState(4499);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 12:
_localctx = new AdminCleanTrashContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(4502);
match(ADMIN);
setState(4503);
match(CLEAN);
setState(4504);
match(TRASH);
setState(4512);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,580,_ctx) ) {
case 1:
{
setState(4505);
match(ON);
setState(4506);
match(LEFT_PAREN);
setState(4507);
((AdminCleanTrashContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminCleanTrashContext)_localctx).backends.add(((AdminCleanTrashContext)_localctx).STRING_LITERAL);
{
setState(4508);
match(COMMA);
setState(4509);
((AdminCleanTrashContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AdminCleanTrashContext)_localctx).backends.add(((AdminCleanTrashContext)_localctx).STRING_LITERAL);
}
setState(4511);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 13:
_localctx = new AdminSetPartitionVersionContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(4514);
match(ADMIN);
setState(4515);
match(SET);
setState(4516);
match(TABLE);
setState(4517);
((AdminSetPartitionVersionContext)_localctx).name = multipartIdentifier();
setState(4518);
match(PARTITION);
setState(4519);
match(VERSION);
setState(4521);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,581,_ctx) ) {
case 1:
{
setState(4520);
((AdminSetPartitionVersionContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 14:
_localctx = new AdminDiagnoseTabletContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(4523);
match(ADMIN);
setState(4524);
match(DIAGNOSE);
setState(4525);
match(TABLET);
setState(4526);
((AdminDiagnoseTabletContext)_localctx).tabletId = match(INTEGER_VALUE);
}
break;
case 15:
_localctx = new AdminShowTabletStorageFormatContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(4527);
match(ADMIN);
setState(4528);
match(SHOW);
setState(4529);
match(TABLET);
setState(4530);
match(STORAGE);
setState(4531);
match(FORMAT);
setState(4533);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,582,_ctx) ) {
case 1:
{
setState(4532);
match(VERBOSE);
}
break;
}
}
break;
case 16:
_localctx = new AdminCopyTabletContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(4535);
match(ADMIN);
setState(4536);
match(COPY);
setState(4537);
match(TABLET);
setState(4538);
((AdminCopyTabletContext)_localctx).tabletId = match(INTEGER_VALUE);
setState(4540);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,583,_ctx) ) {
case 1:
{
setState(4539);
((AdminCopyTabletContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 17:
_localctx = new AdminSetTableStatusContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(4542);
match(ADMIN);
setState(4543);
match(SET);
setState(4544);
match(TABLE);
setState(4545);
((AdminSetTableStatusContext)_localctx).name = multipartIdentifier();
setState(4546);
match(STATUS);
setState(4548);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,584,_ctx) ) {
case 1:
{
setState(4547);
((AdminSetTableStatusContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BaseTableRefContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public OptScanParamsContext optScanParams() {
return getRuleContext(OptScanParamsContext.class,0);
}
public TableSnapshotContext tableSnapshot() {
return getRuleContext(TableSnapshotContext.class,0);
}
public SpecifiedPartitionContext specifiedPartition() {
return getRuleContext(SpecifiedPartitionContext.class,0);
}
public TabletListContext tabletList() {
return getRuleContext(TabletListContext.class,0);
}
public SampleContext sample() {
return getRuleContext(SampleContext.class,0);
}
public RelationHintContext relationHint() {
return getRuleContext(RelationHintContext.class,0);
}
public BaseTableRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_baseTableRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBaseTableRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBaseTableRef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBaseTableRef(this);
else return visitor.visitChildren(this);
}
}
public final BaseTableRefContext baseTableRef() throws RecognitionException {
BaseTableRefContext _localctx = new BaseTableRefContext(_ctx, getState());
enterRule(_localctx, 334, RULE_baseTableRef);
try {
enterOuterAlt(_localctx, 1);
{
setState(4552);
multipartIdentifier();
setState(4554);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,586,_ctx) ) {
case 1:
{
setState(4553);
optScanParams();
}
break;
}
setState(4557);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,587,_ctx) ) {
case 1:
{
setState(4556);
tableSnapshot();
}
break;
}
setState(4560);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,588,_ctx) ) {
case 1:
{
setState(4559);
specifiedPartition();
}
break;
}
setState(4563);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,589,_ctx) ) {
case 1:
{
setState(4562);
tabletList();
}
break;
}
setState(4565);
tableAlias();
setState(4567);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,590,_ctx) ) {
case 1:
{
setState(4566);
sample();
}
break;
}
setState(4570);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,591,_ctx) ) {
case 1:
{
setState(4569);
relationHint();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WildWhereContext extends ParserRuleContext {
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode WHERE() { return getToken(PLParser.WHERE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public WildWhereContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildWhere; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWildWhere(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWildWhere(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWildWhere(this);
else return visitor.visitChildren(this);
}
}
public final WildWhereContext wildWhere() throws RecognitionException {
WildWhereContext _localctx = new WildWhereContext(_ctx, getState());
enterRule(_localctx, 336, RULE_wildWhere);
try {
setState(4576);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIKE:
enterOuterAlt(_localctx, 1);
{
setState(4572);
match(LIKE);
setState(4573);
match(STRING_LITERAL);
}
break;
case WHERE:
enterOuterAlt(_localctx, 2);
{
setState(4574);
match(WHERE);
setState(4575);
expression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedTransactionStatementContext extends ParserRuleContext {
public UnsupportedTransactionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedTransactionStatement; }
public UnsupportedTransactionStatementContext() { }
public void copyFrom(UnsupportedTransactionStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TranscationCommitContext extends UnsupportedTransactionStatementContext {
public TerminalNode COMMIT() { return getToken(PLParser.COMMIT, 0); }
public TerminalNode WORK() { return getToken(PLParser.WORK, 0); }
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(PLParser.CHAIN, 0); }
public TerminalNode RELEASE() { return getToken(PLParser.RELEASE, 0); }
public List<TerminalNode> NO() { return getTokens(PLParser.NO); }
public TerminalNode NO(int i) {
return getToken(PLParser.NO, i);
}
public TranscationCommitContext(UnsupportedTransactionStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTranscationCommit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTranscationCommit(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTranscationCommit(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TransactionRollbackContext extends UnsupportedTransactionStatementContext {
public TerminalNode ROLLBACK() { return getToken(PLParser.ROLLBACK, 0); }
public TerminalNode WORK() { return getToken(PLParser.WORK, 0); }
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(PLParser.CHAIN, 0); }
public TerminalNode RELEASE() { return getToken(PLParser.RELEASE, 0); }
public List<TerminalNode> NO() { return getTokens(PLParser.NO); }
public TerminalNode NO(int i) {
return getToken(PLParser.NO, i);
}
public TransactionRollbackContext(UnsupportedTransactionStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTransactionRollback(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTransactionRollback(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTransactionRollback(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TransactionBeginContext extends UnsupportedTransactionStatementContext {
public TerminalNode BEGIN() { return getToken(PLParser.BEGIN, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode LABEL() { return getToken(PLParser.LABEL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TransactionBeginContext(UnsupportedTransactionStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTransactionBegin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTransactionBegin(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTransactionBegin(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedTransactionStatementContext unsupportedTransactionStatement() throws RecognitionException {
UnsupportedTransactionStatementContext _localctx = new UnsupportedTransactionStatementContext(_ctx, getState());
enterRule(_localctx, 338, RULE_unsupportedTransactionStatement);
int _la;
try {
setState(4620);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BEGIN:
_localctx = new TransactionBeginContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4578);
match(BEGIN);
setState(4584);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,594,_ctx) ) {
case 1:
{
setState(4579);
match(WITH);
setState(4580);
match(LABEL);
setState(4582);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,593,_ctx) ) {
case 1:
{
setState(4581);
identifier();
}
break;
}
}
break;
}
}
break;
case COMMIT:
_localctx = new TranscationCommitContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4586);
match(COMMIT);
setState(4588);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,595,_ctx) ) {
case 1:
{
setState(4587);
match(WORK);
}
break;
}
setState(4595);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,597,_ctx) ) {
case 1:
{
setState(4590);
match(AND);
setState(4592);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(4591);
match(NO);
}
}
setState(4594);
match(CHAIN);
}
break;
}
setState(4601);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,599,_ctx) ) {
case 1:
{
setState(4598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(4597);
match(NO);
}
}
setState(4600);
match(RELEASE);
}
break;
}
}
break;
case ROLLBACK:
_localctx = new TransactionRollbackContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4603);
match(ROLLBACK);
setState(4605);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,600,_ctx) ) {
case 1:
{
setState(4604);
match(WORK);
}
break;
}
setState(4612);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,602,_ctx) ) {
case 1:
{
setState(4607);
match(AND);
setState(4609);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(4608);
match(NO);
}
}
setState(4611);
match(CHAIN);
}
break;
}
setState(4618);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,604,_ctx) ) {
case 1:
{
setState(4615);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(4614);
match(NO);
}
}
setState(4617);
match(RELEASE);
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedGrantRevokeStatementContext extends ParserRuleContext {
public UnsupportedGrantRevokeStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedGrantRevokeStatement; }
public UnsupportedGrantRevokeStatementContext() { }
public void copyFrom(UnsupportedGrantRevokeStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GrantResourcePrivilegeContext extends UnsupportedGrantRevokeStatementContext {
public TerminalNode GRANT() { return getToken(PLParser.GRANT, 0); }
public PrivilegeListContext privilegeList() {
return getRuleContext(PrivilegeListContext.class,0);
}
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierOrTextOrAsteriskContext identifierOrTextOrAsterisk() {
return getRuleContext(IdentifierOrTextOrAsteriskContext.class,0);
}
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public TerminalNode CLUSTER() { return getToken(PLParser.CLUSTER, 0); }
public TerminalNode COMPUTE() { return getToken(PLParser.COMPUTE, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public TerminalNode STAGE() { return getToken(PLParser.STAGE, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode REVOKE() { return getToken(PLParser.REVOKE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public GrantResourcePrivilegeContext(UnsupportedGrantRevokeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGrantResourcePrivilege(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGrantResourcePrivilege(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGrantResourcePrivilege(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GrantTablePrivilegeContext extends UnsupportedGrantRevokeStatementContext {
public TerminalNode GRANT() { return getToken(PLParser.GRANT, 0); }
public PrivilegeListContext privilegeList() {
return getRuleContext(PrivilegeListContext.class,0);
}
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public MultipartIdentifierOrAsteriskContext multipartIdentifierOrAsterisk() {
return getRuleContext(MultipartIdentifierOrAsteriskContext.class,0);
}
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode REVOKE() { return getToken(PLParser.REVOKE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public GrantTablePrivilegeContext(UnsupportedGrantRevokeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGrantTablePrivilege(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGrantTablePrivilege(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGrantTablePrivilege(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GrantRoleContext extends UnsupportedGrantRevokeStatementContext {
public Token STRING_LITERAL;
public List<Token> roles = new ArrayList<Token>();
public TerminalNode GRANT() { return getToken(PLParser.GRANT, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode REVOKE() { return getToken(PLParser.REVOKE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public GrantRoleContext(UnsupportedGrantRevokeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGrantRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGrantRole(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGrantRole(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedGrantRevokeStatementContext unsupportedGrantRevokeStatement() throws RecognitionException {
UnsupportedGrantRevokeStatementContext _localctx = new UnsupportedGrantRevokeStatementContext(_ctx, getState());
enterRule(_localctx, 340, RULE_unsupportedGrantRevokeStatement);
int _la;
try {
setState(4706);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,614,_ctx) ) {
case 1:
_localctx = new GrantTablePrivilegeContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4622);
match(GRANT);
setState(4623);
privilegeList();
setState(4624);
match(ON);
setState(4625);
multipartIdentifierOrAsterisk();
setState(4626);
match(TO);
setState(4630);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(4627);
userIdentify();
}
break;
case ROLE:
{
setState(4628);
match(ROLE);
setState(4629);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
_localctx = new GrantResourcePrivilegeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4632);
match(GRANT);
setState(4633);
privilegeList();
setState(4634);
match(ON);
setState(4644);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RESOURCE:
{
setState(4635);
match(RESOURCE);
}
break;
case CLUSTER:
{
setState(4636);
match(CLUSTER);
}
break;
case COMPUTE:
{
setState(4637);
match(COMPUTE);
setState(4638);
match(GROUP);
}
break;
case STAGE:
{
setState(4639);
match(STAGE);
}
break;
case STORAGE:
{
setState(4640);
match(STORAGE);
setState(4641);
match(VAULT);
}
break;
case WORKLOAD:
{
setState(4642);
match(WORKLOAD);
setState(4643);
match(GROUP);
}
break;
default:
throw new NoViableAltException(this);
}
setState(4646);
identifierOrTextOrAsterisk();
setState(4647);
match(TO);
setState(4651);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(4648);
userIdentify();
}
break;
case ROLE:
{
setState(4649);
match(ROLE);
setState(4650);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 3:
_localctx = new GrantRoleContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4653);
match(GRANT);
setState(4654);
((GrantRoleContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((GrantRoleContext)_localctx).roles.add(((GrantRoleContext)_localctx).STRING_LITERAL);
setState(4659);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4655);
match(COMMA);
setState(4656);
((GrantRoleContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((GrantRoleContext)_localctx).roles.add(((GrantRoleContext)_localctx).STRING_LITERAL);
}
}
setState(4661);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4662);
match(TO);
setState(4663);
userIdentify();
}
break;
case 4:
_localctx = new GrantTablePrivilegeContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4664);
match(REVOKE);
setState(4665);
privilegeList();
setState(4666);
match(ON);
setState(4667);
multipartIdentifierOrAsterisk();
setState(4668);
match(FROM);
setState(4672);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(4669);
userIdentify();
}
break;
case ROLE:
{
setState(4670);
match(ROLE);
setState(4671);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 5:
_localctx = new GrantResourcePrivilegeContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4674);
match(REVOKE);
setState(4675);
privilegeList();
setState(4676);
match(ON);
setState(4686);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RESOURCE:
{
setState(4677);
match(RESOURCE);
}
break;
case CLUSTER:
{
setState(4678);
match(CLUSTER);
}
break;
case COMPUTE:
{
setState(4679);
match(COMPUTE);
setState(4680);
match(GROUP);
}
break;
case STAGE:
{
setState(4681);
match(STAGE);
}
break;
case STORAGE:
{
setState(4682);
match(STORAGE);
setState(4683);
match(VAULT);
}
break;
case WORKLOAD:
{
setState(4684);
match(WORKLOAD);
setState(4685);
match(GROUP);
}
break;
default:
throw new NoViableAltException(this);
}
setState(4688);
identifierOrTextOrAsterisk();
setState(4689);
match(FROM);
setState(4693);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(4690);
userIdentify();
}
break;
case ROLE:
{
setState(4691);
match(ROLE);
setState(4692);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 6:
_localctx = new GrantRoleContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4695);
match(REVOKE);
setState(4696);
((GrantRoleContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((GrantRoleContext)_localctx).roles.add(((GrantRoleContext)_localctx).STRING_LITERAL);
setState(4701);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4697);
match(COMMA);
setState(4698);
((GrantRoleContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((GrantRoleContext)_localctx).roles.add(((GrantRoleContext)_localctx).STRING_LITERAL);
}
}
setState(4703);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4704);
match(FROM);
setState(4705);
userIdentify();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrivilegeContext extends ParserRuleContext {
public IdentifierContext name;
public IdentifierListContext columns;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public PrivilegeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_privilege; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPrivilege(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPrivilege(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPrivilege(this);
else return visitor.visitChildren(this);
}
}
public final PrivilegeContext privilege() throws RecognitionException {
PrivilegeContext _localctx = new PrivilegeContext(_ctx, getState());
enterRule(_localctx, 342, RULE_privilege);
int _la;
try {
setState(4713);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(4708);
((PrivilegeContext)_localctx).name = identifier();
setState(4710);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(4709);
((PrivilegeContext)_localctx).columns = identifierList();
}
}
}
break;
case ALL:
enterOuterAlt(_localctx, 2);
{
setState(4712);
match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrivilegeListContext extends ParserRuleContext {
public List<PrivilegeContext> privilege() {
return getRuleContexts(PrivilegeContext.class);
}
public PrivilegeContext privilege(int i) {
return getRuleContext(PrivilegeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PrivilegeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_privilegeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPrivilegeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPrivilegeList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPrivilegeList(this);
else return visitor.visitChildren(this);
}
}
public final PrivilegeListContext privilegeList() throws RecognitionException {
PrivilegeListContext _localctx = new PrivilegeListContext(_ctx, getState());
enterRule(_localctx, 344, RULE_privilegeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(4715);
privilege();
setState(4720);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4716);
match(COMMA);
setState(4717);
privilege();
}
}
setState(4722);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedAlterStatementContext extends ParserRuleContext {
public UnsupportedAlterStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedAlterStatement; }
public UnsupportedAlterStatementContext() { }
public void copyFrom(UnsupportedAlterStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterStoragePlicyContext extends UnsupportedAlterStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterStoragePlicyContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterStoragePlicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterStoragePlicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterStoragePlicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterSystemContext extends UnsupportedAlterStatementContext {
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode SYSTEM() { return getToken(PLParser.SYSTEM, 0); }
public AlterSystemClauseContext alterSystemClause() {
return getRuleContext(AlterSystemClauseContext.class,0);
}
public AlterSystemContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterSystem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterSystem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterSystem(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterCatalogRenameContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public AlterCatalogRenameContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterCatalogRename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterCatalogRename(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterCatalogRename(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterDatabaseSetQuotaContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode QUOTA() { return getToken(PLParser.QUOTA, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode REPLICA() { return getToken(PLParser.REPLICA, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public AlterDatabaseSetQuotaContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterDatabaseSetQuota(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterDatabaseSetQuota(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterDatabaseSetQuota(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTableDropRollupContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public List<DropRollupClauseContext> dropRollupClause() {
return getRuleContexts(DropRollupClauseContext.class);
}
public DropRollupClauseContext dropRollupClause(int i) {
return getRuleContext(DropRollupClauseContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public AlterTableDropRollupContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterTableDropRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterTableDropRollup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterTableDropRollup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterWorkloadGroupContext extends UnsupportedAlterStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterWorkloadGroupContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterWorkloadGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterWorkloadGroup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterWorkloadGroup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTablePropertiesContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public AlterTablePropertiesContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterTableProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterTableProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterTableProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterUserContext extends UnsupportedAlterStatementContext {
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public GrantUserIdentifyContext grantUserIdentify() {
return getRuleContext(GrantUserIdentifyContext.class,0);
}
public PasswordOptionContext passwordOption() {
return getRuleContext(PasswordOptionContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public AlterUserContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterRoleContext extends UnsupportedAlterStatementContext {
public IdentifierContext role;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AlterRoleContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterRole(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterRole(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterDatabaseRenameContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public AlterDatabaseRenameContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterDatabaseRename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterDatabaseRename(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterDatabaseRename(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterWorkloadPolicyContext extends UnsupportedAlterStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterWorkloadPolicyContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterWorkloadPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterWorkloadPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterWorkloadPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterDatabasePropertiesContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AlterDatabasePropertiesContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterDatabaseProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterDatabaseProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterDatabaseProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterCatalogPropertiesContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AlterCatalogPropertiesContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterCatalogProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterCatalogProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterCatalogProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterCatalogCommentContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public Token comment;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public AlterCatalogCommentContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterCatalogComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterCatalogComment(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterCatalogComment(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterSqlBlockRuleContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode SQL_BLOCK_RULE() { return getToken(PLParser.SQL_BLOCK_RULE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterSqlBlockRuleContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterSqlBlockRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterSqlBlockRule(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterSqlBlockRule(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterResourceContext extends UnsupportedAlterStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterResourceContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterResource(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterResource(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterRoutineLoadContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext name;
public PropertyClauseContext properties;
public IdentifierContext type;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AlterRoutineLoadContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterRoutineLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterRoutineLoad(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterRoutineLoad(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTableAddRollupContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public List<AddRollupClauseContext> addRollupClause() {
return getRuleContexts(AddRollupClauseContext.class);
}
public AddRollupClauseContext addRollupClause(int i) {
return getRuleContext(AddRollupClauseContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public AlterTableAddRollupContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterTableAddRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterTableAddRollup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterTableAddRollup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterRepositoryContext extends UnsupportedAlterStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode REPOSITORY() { return getToken(PLParser.REPOSITORY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterRepositoryContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterRepository(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterRepository(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterRepository(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTableContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public List<AlterTableClauseContext> alterTableClause() {
return getRuleContexts(AlterTableClauseContext.class);
}
public AlterTableClauseContext alterTableClause(int i) {
return getRuleContext(AlterTableClauseContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public AlterTableContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterColocateGroupContext extends UnsupportedAlterStatementContext {
public MultipartIdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode COLOCATE() { return getToken(PLParser.COLOCATE, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public AlterColocateGroupContext(UnsupportedAlterStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterColocateGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterColocateGroup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterColocateGroup(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedAlterStatementContext unsupportedAlterStatement() throws RecognitionException {
UnsupportedAlterStatementContext _localctx = new UnsupportedAlterStatementContext(_ctx, getState());
enterRule(_localctx, 346, RULE_unsupportedAlterStatement);
int _la;
try {
int _alt;
setState(4898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,631,_ctx) ) {
case 1:
_localctx = new AlterTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4723);
match(ALTER);
setState(4724);
match(TABLE);
setState(4725);
((AlterTableContext)_localctx).tableName = multipartIdentifier();
setState(4726);
alterTableClause();
setState(4731);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,618,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4727);
match(COMMA);
setState(4728);
alterTableClause();
}
}
}
setState(4733);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,618,_ctx);
}
}
break;
case 2:
_localctx = new AlterTableAddRollupContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4734);
match(ALTER);
setState(4735);
match(TABLE);
setState(4736);
((AlterTableAddRollupContext)_localctx).tableName = multipartIdentifier();
setState(4737);
match(ADD);
setState(4738);
match(ROLLUP);
setState(4739);
addRollupClause();
setState(4744);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,619,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4740);
match(COMMA);
setState(4741);
addRollupClause();
}
}
}
setState(4746);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,619,_ctx);
}
}
break;
case 3:
_localctx = new AlterTableDropRollupContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4747);
match(ALTER);
setState(4748);
match(TABLE);
setState(4749);
((AlterTableDropRollupContext)_localctx).tableName = multipartIdentifier();
setState(4750);
match(DROP);
setState(4751);
match(ROLLUP);
setState(4752);
dropRollupClause();
setState(4757);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,620,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4753);
match(COMMA);
setState(4754);
dropRollupClause();
}
}
}
setState(4759);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,620,_ctx);
}
}
break;
case 4:
_localctx = new AlterSystemContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4760);
match(ALTER);
setState(4761);
match(SYSTEM);
setState(4762);
alterSystemClause();
}
break;
case 5:
_localctx = new AlterDatabaseSetQuotaContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4763);
match(ALTER);
setState(4764);
match(DATABASE);
setState(4765);
((AlterDatabaseSetQuotaContext)_localctx).name = identifier();
setState(4766);
match(SET);
setState(4767);
_la = _input.LA(1);
if ( !(_la==DATA || _la==REPLICA || _la==TRANSACTION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4768);
match(QUOTA);
setState(4769);
match(INTEGER_VALUE);
setState(4771);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,621,_ctx) ) {
case 1:
{
setState(4770);
identifier();
}
break;
}
}
break;
case 6:
_localctx = new AlterDatabaseRenameContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4773);
match(ALTER);
setState(4774);
match(DATABASE);
setState(4775);
((AlterDatabaseRenameContext)_localctx).name = identifier();
setState(4776);
match(RENAME);
setState(4777);
((AlterDatabaseRenameContext)_localctx).newName = identifier();
}
break;
case 7:
_localctx = new AlterDatabasePropertiesContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4779);
match(ALTER);
setState(4780);
match(DATABASE);
setState(4781);
((AlterDatabasePropertiesContext)_localctx).name = identifier();
setState(4782);
match(SET);
setState(4783);
match(PROPERTIES);
setState(4784);
match(LEFT_PAREN);
setState(4785);
propertyItemList();
setState(4786);
match(RIGHT_PAREN);
}
break;
case 8:
_localctx = new AlterCatalogRenameContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(4788);
match(ALTER);
setState(4789);
match(CATALOG);
setState(4790);
((AlterCatalogRenameContext)_localctx).name = identifier();
setState(4791);
match(RENAME);
setState(4792);
((AlterCatalogRenameContext)_localctx).newName = identifier();
}
break;
case 9:
_localctx = new AlterCatalogPropertiesContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(4794);
match(ALTER);
setState(4795);
match(CATALOG);
setState(4796);
((AlterCatalogPropertiesContext)_localctx).name = identifier();
setState(4797);
match(SET);
setState(4798);
match(PROPERTIES);
setState(4799);
match(LEFT_PAREN);
setState(4800);
propertyItemList();
setState(4801);
match(RIGHT_PAREN);
}
break;
case 10:
_localctx = new AlterCatalogCommentContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(4803);
match(ALTER);
setState(4804);
match(CATALOG);
setState(4805);
((AlterCatalogCommentContext)_localctx).name = identifier();
setState(4806);
match(MODIFY);
setState(4807);
match(COMMENT);
setState(4808);
((AlterCatalogCommentContext)_localctx).comment = match(STRING_LITERAL);
}
break;
case 11:
_localctx = new AlterResourceContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(4810);
match(ALTER);
setState(4811);
match(RESOURCE);
setState(4812);
((AlterResourceContext)_localctx).name = identifierOrText();
setState(4814);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,622,_ctx) ) {
case 1:
{
setState(4813);
((AlterResourceContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 12:
_localctx = new AlterColocateGroupContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(4816);
match(ALTER);
setState(4817);
match(COLOCATE);
setState(4818);
match(GROUP);
setState(4819);
((AlterColocateGroupContext)_localctx).name = multipartIdentifier();
setState(4820);
match(SET);
setState(4821);
match(LEFT_PAREN);
setState(4822);
propertyItemList();
setState(4823);
match(RIGHT_PAREN);
}
break;
case 13:
_localctx = new AlterWorkloadGroupContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(4825);
match(ALTER);
setState(4826);
match(WORKLOAD);
setState(4827);
match(GROUP);
setState(4828);
((AlterWorkloadGroupContext)_localctx).name = identifierOrText();
setState(4830);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,623,_ctx) ) {
case 1:
{
setState(4829);
((AlterWorkloadGroupContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 14:
_localctx = new AlterWorkloadPolicyContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(4832);
match(ALTER);
setState(4833);
match(WORKLOAD);
setState(4834);
match(POLICY);
setState(4835);
((AlterWorkloadPolicyContext)_localctx).name = identifierOrText();
setState(4837);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,624,_ctx) ) {
case 1:
{
setState(4836);
((AlterWorkloadPolicyContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 15:
_localctx = new AlterRoutineLoadContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(4839);
match(ALTER);
setState(4840);
match(ROUTINE);
setState(4841);
match(LOAD);
setState(4842);
match(FOR);
setState(4843);
((AlterRoutineLoadContext)_localctx).name = multipartIdentifier();
setState(4845);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,625,_ctx) ) {
case 1:
{
setState(4844);
((AlterRoutineLoadContext)_localctx).properties = propertyClause();
}
break;
}
setState(4853);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,626,_ctx) ) {
case 1:
{
setState(4847);
match(FROM);
setState(4848);
((AlterRoutineLoadContext)_localctx).type = identifier();
setState(4849);
match(LEFT_PAREN);
setState(4850);
propertyItemList();
setState(4851);
match(RIGHT_PAREN);
}
break;
}
}
break;
case 16:
_localctx = new AlterSqlBlockRuleContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(4855);
match(ALTER);
setState(4856);
match(SQL_BLOCK_RULE);
setState(4857);
((AlterSqlBlockRuleContext)_localctx).name = identifier();
setState(4859);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,627,_ctx) ) {
case 1:
{
setState(4858);
((AlterSqlBlockRuleContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 17:
_localctx = new AlterTablePropertiesContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(4861);
match(ALTER);
setState(4862);
match(TABLE);
setState(4863);
((AlterTablePropertiesContext)_localctx).name = multipartIdentifier();
setState(4864);
match(SET);
setState(4865);
match(LEFT_PAREN);
setState(4866);
propertyItemList();
setState(4867);
match(RIGHT_PAREN);
}
break;
case 18:
_localctx = new AlterStoragePlicyContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(4869);
match(ALTER);
setState(4870);
match(STORAGE);
setState(4871);
match(POLICY);
setState(4872);
((AlterStoragePlicyContext)_localctx).name = identifierOrText();
setState(4873);
((AlterStoragePlicyContext)_localctx).properties = propertyClause();
}
break;
case 19:
_localctx = new AlterUserContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(4875);
match(ALTER);
setState(4876);
match(USER);
setState(4879);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(4877);
match(IF);
setState(4878);
match(EXISTS);
}
}
setState(4881);
grantUserIdentify();
setState(4882);
passwordOption();
setState(4885);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,629,_ctx) ) {
case 1:
{
setState(4883);
match(COMMENT);
setState(4884);
match(STRING_LITERAL);
}
break;
}
}
break;
case 20:
_localctx = new AlterRoleContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(4887);
match(ALTER);
setState(4888);
match(ROLE);
setState(4889);
((AlterRoleContext)_localctx).role = identifier();
setState(4890);
commentSpec();
}
break;
case 21:
_localctx = new AlterRepositoryContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(4892);
match(ALTER);
setState(4893);
match(REPOSITORY);
setState(4894);
((AlterRepositoryContext)_localctx).name = identifier();
setState(4896);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,630,_ctx) ) {
case 1:
{
setState(4895);
((AlterRepositoryContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterSystemClauseContext extends ParserRuleContext {
public AlterSystemClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterSystemClause; }
public AlterSystemClauseContext() { }
public void copyFrom(AlterSystemClauseContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropBrokerClauseContext extends AlterSystemClauseContext {
public IdentifierOrTextContext name;
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public DropBrokerClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropBrokerClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropBrokerClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropBrokerClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyFrontendOrBackendHostNameClauseContext extends AlterSystemClauseContext {
public Token hostPort;
public Token hostName;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode HOSTNAME() { return getToken(PLParser.HOSTNAME, 0); }
public TerminalNode FRONTEND() { return getToken(PLParser.FRONTEND, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public ModifyFrontendOrBackendHostNameClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyFrontendOrBackendHostNameClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyFrontendOrBackendHostNameClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyFrontendOrBackendHostNameClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropObserverClauseContext extends AlterSystemClauseContext {
public Token hostPort;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode OBSERVER() { return getToken(PLParser.OBSERVER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public DropObserverClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropObserverClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropObserverClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropObserverClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddFollowerClauseContext extends AlterSystemClauseContext {
public Token hostPort;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode FOLLOWER() { return getToken(PLParser.FOLLOWER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public AddFollowerClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddFollowerClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddFollowerClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddFollowerClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropFollowerClauseContext extends AlterSystemClauseContext {
public Token hostPort;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode FOLLOWER() { return getToken(PLParser.FOLLOWER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public DropFollowerClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropFollowerClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropFollowerClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropFollowerClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropAllBrokerClauseContext extends AlterSystemClauseContext {
public IdentifierOrTextContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public DropAllBrokerClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropAllBrokerClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropAllBrokerClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropAllBrokerClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropBackendClauseContext extends AlterSystemClauseContext {
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode DROPP() { return getToken(PLParser.DROPP, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public DropBackendClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropBackendClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropBackendClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropBackendClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterLoadErrorUrlClauseContext extends AlterSystemClauseContext {
public PropertyClauseContext properties;
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LOAD() { return getToken(PLParser.LOAD, 0); }
public TerminalNode ERRORS() { return getToken(PLParser.ERRORS, 0); }
public TerminalNode HUB() { return getToken(PLParser.HUB, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterLoadErrorUrlClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterLoadErrorUrlClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterLoadErrorUrlClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterLoadErrorUrlClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyBackendClauseContext extends AlterSystemClauseContext {
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ModifyBackendClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyBackendClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyBackendClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyBackendClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddBrokerClauseContext extends AlterSystemClauseContext {
public IdentifierOrTextContext name;
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public AddBrokerClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddBrokerClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddBrokerClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddBrokerClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddObserverClauseContext extends AlterSystemClauseContext {
public Token hostPort;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode OBSERVER() { return getToken(PLParser.OBSERVER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public AddObserverClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddObserverClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddObserverClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddObserverClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DecommissionBackendClauseContext extends AlterSystemClauseContext {
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public TerminalNode DECOMMISSION() { return getToken(PLParser.DECOMMISSION, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public DecommissionBackendClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDecommissionBackendClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDecommissionBackendClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDecommissionBackendClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddBackendClauseContext extends AlterSystemClauseContext {
public Token STRING_LITERAL;
public List<Token> hostPorts = new ArrayList<Token>();
public PropertyClauseContext properties;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode BACKEND() { return getToken(PLParser.BACKEND, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AddBackendClauseContext(AlterSystemClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddBackendClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddBackendClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddBackendClause(this);
else return visitor.visitChildren(this);
}
}
public final AlterSystemClauseContext alterSystemClause() throws RecognitionException {
AlterSystemClauseContext _localctx = new AlterSystemClauseContext(_ctx, getState());
enterRule(_localctx, 348, RULE_alterSystemClause);
int _la;
try {
int _alt;
setState(4998);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,640,_ctx) ) {
case 1:
_localctx = new AddBackendClauseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(4900);
match(ADD);
setState(4901);
match(BACKEND);
setState(4902);
((AddBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AddBackendClauseContext)_localctx).hostPorts.add(((AddBackendClauseContext)_localctx).STRING_LITERAL);
setState(4907);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,632,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4903);
match(COMMA);
setState(4904);
((AddBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AddBackendClauseContext)_localctx).hostPorts.add(((AddBackendClauseContext)_localctx).STRING_LITERAL);
}
}
}
setState(4909);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,632,_ctx);
}
setState(4911);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,633,_ctx) ) {
case 1:
{
setState(4910);
((AddBackendClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 2:
_localctx = new DropBackendClauseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(4913);
_la = _input.LA(1);
if ( !(_la==DROP || _la==DROPP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4914);
match(BACKEND);
setState(4915);
((DropBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DropBackendClauseContext)_localctx).hostPorts.add(((DropBackendClauseContext)_localctx).STRING_LITERAL);
setState(4920);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,634,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4916);
match(COMMA);
setState(4917);
((DropBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DropBackendClauseContext)_localctx).hostPorts.add(((DropBackendClauseContext)_localctx).STRING_LITERAL);
}
}
}
setState(4922);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,634,_ctx);
}
}
break;
case 3:
_localctx = new DecommissionBackendClauseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(4923);
match(DECOMMISSION);
setState(4924);
match(BACKEND);
setState(4925);
((DecommissionBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DecommissionBackendClauseContext)_localctx).hostPorts.add(((DecommissionBackendClauseContext)_localctx).STRING_LITERAL);
setState(4930);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,635,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4926);
match(COMMA);
setState(4927);
((DecommissionBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DecommissionBackendClauseContext)_localctx).hostPorts.add(((DecommissionBackendClauseContext)_localctx).STRING_LITERAL);
}
}
}
setState(4932);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,635,_ctx);
}
}
break;
case 4:
_localctx = new AddObserverClauseContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(4933);
match(ADD);
setState(4934);
match(OBSERVER);
setState(4935);
((AddObserverClauseContext)_localctx).hostPort = match(STRING_LITERAL);
}
break;
case 5:
_localctx = new DropObserverClauseContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(4936);
match(DROP);
setState(4937);
match(OBSERVER);
setState(4938);
((DropObserverClauseContext)_localctx).hostPort = match(STRING_LITERAL);
}
break;
case 6:
_localctx = new AddFollowerClauseContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(4939);
match(ADD);
setState(4940);
match(FOLLOWER);
setState(4941);
((AddFollowerClauseContext)_localctx).hostPort = match(STRING_LITERAL);
}
break;
case 7:
_localctx = new DropFollowerClauseContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(4942);
match(DROP);
setState(4943);
match(FOLLOWER);
setState(4944);
((DropFollowerClauseContext)_localctx).hostPort = match(STRING_LITERAL);
}
break;
case 8:
_localctx = new AddBrokerClauseContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(4945);
match(ADD);
setState(4946);
match(BROKER);
setState(4947);
((AddBrokerClauseContext)_localctx).name = identifierOrText();
setState(4948);
((AddBrokerClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AddBrokerClauseContext)_localctx).hostPorts.add(((AddBrokerClauseContext)_localctx).STRING_LITERAL);
setState(4953);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,636,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4949);
match(COMMA);
setState(4950);
((AddBrokerClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((AddBrokerClauseContext)_localctx).hostPorts.add(((AddBrokerClauseContext)_localctx).STRING_LITERAL);
}
}
}
setState(4955);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,636,_ctx);
}
}
break;
case 9:
_localctx = new DropBrokerClauseContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(4956);
match(DROP);
setState(4957);
match(BROKER);
setState(4958);
((DropBrokerClauseContext)_localctx).name = identifierOrText();
setState(4959);
((DropBrokerClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DropBrokerClauseContext)_localctx).hostPorts.add(((DropBrokerClauseContext)_localctx).STRING_LITERAL);
setState(4964);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,637,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(4960);
match(COMMA);
setState(4961);
((DropBrokerClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DropBrokerClauseContext)_localctx).hostPorts.add(((DropBrokerClauseContext)_localctx).STRING_LITERAL);
}
}
}
setState(4966);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,637,_ctx);
}
}
break;
case 10:
_localctx = new DropAllBrokerClauseContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(4967);
match(DROP);
setState(4968);
match(ALL);
setState(4969);
match(BROKER);
setState(4970);
((DropAllBrokerClauseContext)_localctx).name = identifierOrText();
}
break;
case 11:
_localctx = new AlterLoadErrorUrlClauseContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(4971);
match(SET);
setState(4972);
match(LOAD);
setState(4973);
match(ERRORS);
setState(4974);
match(HUB);
setState(4976);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,638,_ctx) ) {
case 1:
{
setState(4975);
((AlterLoadErrorUrlClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 12:
_localctx = new ModifyBackendClauseContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(4978);
match(MODIFY);
setState(4979);
match(BACKEND);
setState(4980);
((ModifyBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((ModifyBackendClauseContext)_localctx).hostPorts.add(((ModifyBackendClauseContext)_localctx).STRING_LITERAL);
setState(4985);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(4981);
match(COMMA);
setState(4982);
((ModifyBackendClauseContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((ModifyBackendClauseContext)_localctx).hostPorts.add(((ModifyBackendClauseContext)_localctx).STRING_LITERAL);
}
}
setState(4987);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(4988);
match(SET);
setState(4989);
match(LEFT_PAREN);
setState(4990);
propertyItemList();
setState(4991);
match(RIGHT_PAREN);
}
break;
case 13:
_localctx = new ModifyFrontendOrBackendHostNameClauseContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(4993);
match(MODIFY);
setState(4994);
_la = _input.LA(1);
if ( !(_la==BACKEND || _la==FRONTEND) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(4995);
((ModifyFrontendOrBackendHostNameClauseContext)_localctx).hostPort = match(STRING_LITERAL);
setState(4996);
match(HOSTNAME);
setState(4997);
((ModifyFrontendOrBackendHostNameClauseContext)_localctx).hostName = match(STRING_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DropRollupClauseContext extends ParserRuleContext {
public IdentifierContext rollupName;
public PropertyClauseContext properties;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public DropRollupClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dropRollupClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropRollupClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropRollupClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropRollupClause(this);
else return visitor.visitChildren(this);
}
}
public final DropRollupClauseContext dropRollupClause() throws RecognitionException {
DropRollupClauseContext _localctx = new DropRollupClauseContext(_ctx, getState());
enterRule(_localctx, 350, RULE_dropRollupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(5000);
((DropRollupClauseContext)_localctx).rollupName = identifier();
setState(5002);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,641,_ctx) ) {
case 1:
{
setState(5001);
((DropRollupClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AddRollupClauseContext extends ParserRuleContext {
public IdentifierContext rollupName;
public IdentifierListContext columns;
public IdentifierListContext dupKeys;
public PropertyClauseContext properties;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public TerminalNode DUPLICATE() { return getToken(PLParser.DUPLICATE, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public FromRollupContext fromRollup() {
return getRuleContext(FromRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AddRollupClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_addRollupClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddRollupClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddRollupClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddRollupClause(this);
else return visitor.visitChildren(this);
}
}
public final AddRollupClauseContext addRollupClause() throws RecognitionException {
AddRollupClauseContext _localctx = new AddRollupClauseContext(_ctx, getState());
enterRule(_localctx, 352, RULE_addRollupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(5004);
((AddRollupClauseContext)_localctx).rollupName = identifier();
setState(5005);
((AddRollupClauseContext)_localctx).columns = identifierList();
setState(5009);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,642,_ctx) ) {
case 1:
{
setState(5006);
match(DUPLICATE);
setState(5007);
match(KEY);
setState(5008);
((AddRollupClauseContext)_localctx).dupKeys = identifierList();
}
break;
}
setState(5012);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,643,_ctx) ) {
case 1:
{
setState(5011);
fromRollup();
}
break;
}
setState(5015);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,644,_ctx) ) {
case 1:
{
setState(5014);
((AddRollupClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTableClauseContext extends ParserRuleContext {
public AlterTableClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterTableClause; }
public AlterTableClauseContext() { }
public void copyFrom(AlterTableClauseContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyDistributionClauseContext extends AlterTableClauseContext {
public IdentifierListContext hashKeys;
public Token autoBucket;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode DISTRIBUTION() { return getToken(PLParser.DISTRIBUTION, 0); }
public TerminalNode DISTRIBUTED() { return getToken(PLParser.DISTRIBUTED, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public TerminalNode HASH() { return getToken(PLParser.HASH, 0); }
public TerminalNode RANDOM() { return getToken(PLParser.RANDOM, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public ModifyDistributionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyDistributionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyDistributionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyDistributionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddColumnClauseContext extends AlterTableClauseContext {
public PropertyClauseContext properties;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public ColumnDefContext columnDef() {
return getRuleContext(ColumnDefContext.class,0);
}
public ColumnPositionContext columnPosition() {
return getRuleContext(ColumnPositionContext.class,0);
}
public ToRollupContext toRollup() {
return getRuleContext(ToRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AddColumnClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddColumnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddColumnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddColumnClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyColumnClauseContext extends AlterTableClauseContext {
public PropertyClauseContext properties;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public ColumnDefContext columnDef() {
return getRuleContext(ColumnDefContext.class,0);
}
public ColumnPositionContext columnPosition() {
return getRuleContext(ColumnPositionContext.class,0);
}
public FromRollupContext fromRollup() {
return getRuleContext(FromRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public ModifyColumnClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyColumnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyColumnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyColumnClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddColumnsClauseContext extends AlterTableClauseContext {
public PropertyClauseContext properties;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<ColumnDefContext> columnDef() {
return getRuleContexts(ColumnDefContext.class);
}
public ColumnDefContext columnDef(int i) {
return getRuleContext(ColumnDefContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ToRollupContext toRollup() {
return getRuleContext(ToRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AddColumnsClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddColumnsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddColumnsClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddColumnsClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReplaceTableClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public ReplaceTableClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReplaceTableClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReplaceTableClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReplaceTableClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropIndexClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropIndexClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropIndexClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropIndexClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropIndexClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropPartitionClauseContext extends AlterTableClauseContext {
public IdentifierContext partitionName;
public IdentifierContext indexName;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode FORCE() { return getToken(PLParser.FORCE, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public DropPartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropPartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropPartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropPartitionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReplacePartitionClauseContext extends AlterTableClauseContext {
public PartitionSpecContext partitions;
public PartitionSpecContext tempPartitions;
public PropertyClauseContext properties;
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode FORCE() { return getToken(PLParser.FORCE, 0); }
public List<PartitionSpecContext> partitionSpec() {
return getRuleContexts(PartitionSpecContext.class);
}
public PartitionSpecContext partitionSpec(int i) {
return getRuleContext(PartitionSpecContext.class,i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public ReplacePartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReplacePartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReplacePartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReplacePartitionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyTableCommentClauseContext extends AlterTableClauseContext {
public Token comment;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ModifyTableCommentClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyTableCommentClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyTableCommentClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyTableCommentClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReorderColumnsClauseContext extends AlterTableClauseContext {
public PropertyClauseContext properties;
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public FromRollupContext fromRollup() {
return getRuleContext(FromRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public ReorderColumnsClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReorderColumnsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReorderColumnsClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReorderColumnsClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropBranchClausesContext extends AlterTableClauseContext {
public DropBranchClauseContext dropBranchClause() {
return getRuleContext(DropBranchClauseContext.class,0);
}
public DropBranchClausesContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropBranchClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropBranchClauses(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropBranchClauses(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddIndexClauseContext extends AlterTableClauseContext {
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public IndexDefContext indexDef() {
return getRuleContext(IndexDefContext.class,0);
}
public AddIndexClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddIndexClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddIndexClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddIndexClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyColumnCommentClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public Token comment;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ModifyColumnCommentClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyColumnCommentClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyColumnCommentClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyColumnCommentClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RenameColumnClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public RenameColumnClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRenameColumnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRenameColumnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRenameColumnClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateOrReplaceTagClausesContext extends AlterTableClauseContext {
public CreateOrReplaceTagClauseContext createOrReplaceTagClause() {
return getRuleContext(CreateOrReplaceTagClauseContext.class,0);
}
public CreateOrReplaceTagClausesContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateOrReplaceTagClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateOrReplaceTagClauses(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateOrReplaceTagClauses(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EnableFeatureClauseContext extends AlterTableClauseContext {
public Token name;
public PropertyClauseContext properties;
public TerminalNode ENABLE() { return getToken(PLParser.ENABLE, 0); }
public TerminalNode FEATURE() { return getToken(PLParser.FEATURE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public EnableFeatureClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterEnableFeatureClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitEnableFeatureClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitEnableFeatureClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateOrReplaceBranchClausesContext extends AlterTableClauseContext {
public CreateOrReplaceBranchClauseContext createOrReplaceBranchClause() {
return getRuleContext(CreateOrReplaceBranchClauseContext.class,0);
}
public CreateOrReplaceBranchClausesContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateOrReplaceBranchClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateOrReplaceBranchClauses(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateOrReplaceBranchClauses(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddPartitionClauseContext extends AlterTableClauseContext {
public PropertyItemListContext partitionProperties;
public IdentifierListContext hashKeys;
public Token autoBucket;
public PropertyClauseContext properties;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public LessThanPartitionDefContext lessThanPartitionDef() {
return getRuleContext(LessThanPartitionDefContext.class,0);
}
public FixedPartitionDefContext fixedPartitionDef() {
return getRuleContext(FixedPartitionDefContext.class,0);
}
public InPartitionDefContext inPartitionDef() {
return getRuleContext(InPartitionDefContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode DISTRIBUTED() { return getToken(PLParser.DISTRIBUTED, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public TerminalNode HASH() { return getToken(PLParser.HASH, 0); }
public TerminalNode RANDOM() { return getToken(PLParser.RANDOM, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public AddPartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAddPartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAddPartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAddPartitionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RenameRollupClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public RenameRollupClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRenameRollupClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRenameRollupClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRenameRollupClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RenamePartitionClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public IdentifierContext newName;
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public RenamePartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRenamePartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRenamePartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRenamePartitionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropColumnClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FromRollupContext fromRollup() {
return getRuleContext(FromRollupContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public DropColumnClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropColumnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropColumnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropColumnClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RenameClauseContext extends AlterTableClauseContext {
public IdentifierContext newName;
public TerminalNode RENAME() { return getToken(PLParser.RENAME, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public RenameClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRenameClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRenameClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRenameClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyPartitionClauseContext extends AlterTableClauseContext {
public IdentifierContext partitionName;
public IdentifierListContext partitionNames;
public PropertyItemListContext partitionProperties;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ModifyPartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyPartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyPartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyPartitionClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ModifyEngineClauseContext extends AlterTableClauseContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode ENGINE() { return getToken(PLParser.ENGINE, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public ModifyEngineClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterModifyEngineClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitModifyEngineClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitModifyEngineClause(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropTagClausesContext extends AlterTableClauseContext {
public DropTagClauseContext dropTagClause() {
return getRuleContext(DropTagClauseContext.class,0);
}
public DropTagClausesContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropTagClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropTagClauses(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropTagClauses(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterMultiPartitionClauseContext extends AlterTableClauseContext {
public PartitionValueListContext from;
public PartitionValueListContext to;
public IdentifierContext unit;
public PropertyClauseContext properties;
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode PARTITIONS() { return getToken(PLParser.PARTITIONS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode INTERVAL() { return getToken(PLParser.INTERVAL, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public List<PartitionValueListContext> partitionValueList() {
return getRuleContexts(PartitionValueListContext.class);
}
public PartitionValueListContext partitionValueList(int i) {
return getRuleContext(PartitionValueListContext.class,i);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AlterMultiPartitionClauseContext(AlterTableClauseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterMultiPartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterMultiPartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterMultiPartitionClause(this);
else return visitor.visitChildren(this);
}
}
public final AlterTableClauseContext alterTableClause() throws RecognitionException {
AlterTableClauseContext _localctx = new AlterTableClauseContext(_ctx, getState());
enterRule(_localctx, 354, RULE_alterTableClause);
int _la;
try {
setState(5259);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,688,_ctx) ) {
case 1:
_localctx = new AddColumnClauseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(5017);
match(ADD);
setState(5018);
match(COLUMN);
setState(5019);
columnDef();
setState(5021);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,645,_ctx) ) {
case 1:
{
setState(5020);
columnPosition();
}
break;
}
setState(5024);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,646,_ctx) ) {
case 1:
{
setState(5023);
toRollup();
}
break;
}
setState(5027);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,647,_ctx) ) {
case 1:
{
setState(5026);
((AddColumnClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 2:
_localctx = new AddColumnsClauseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(5029);
match(ADD);
setState(5030);
match(COLUMN);
setState(5031);
match(LEFT_PAREN);
setState(5032);
columnDef();
setState(5037);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(5033);
match(COMMA);
setState(5034);
columnDef();
}
}
setState(5039);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(5040);
match(RIGHT_PAREN);
setState(5042);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,649,_ctx) ) {
case 1:
{
setState(5041);
toRollup();
}
break;
}
setState(5045);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,650,_ctx) ) {
case 1:
{
setState(5044);
((AddColumnsClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 3:
_localctx = new DropColumnClauseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(5047);
match(DROP);
setState(5048);
match(COLUMN);
setState(5049);
((DropColumnClauseContext)_localctx).name = identifier();
setState(5051);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,651,_ctx) ) {
case 1:
{
setState(5050);
fromRollup();
}
break;
}
setState(5054);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,652,_ctx) ) {
case 1:
{
setState(5053);
((DropColumnClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 4:
_localctx = new ModifyColumnClauseContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(5056);
match(MODIFY);
setState(5057);
match(COLUMN);
setState(5058);
columnDef();
setState(5060);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,653,_ctx) ) {
case 1:
{
setState(5059);
columnPosition();
}
break;
}
setState(5063);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,654,_ctx) ) {
case 1:
{
setState(5062);
fromRollup();
}
break;
}
setState(5066);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,655,_ctx) ) {
case 1:
{
setState(5065);
((ModifyColumnClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 5:
_localctx = new ReorderColumnsClauseContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(5068);
match(ORDER);
setState(5069);
match(BY);
setState(5070);
identifierList();
setState(5072);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,656,_ctx) ) {
case 1:
{
setState(5071);
fromRollup();
}
break;
}
setState(5075);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,657,_ctx) ) {
case 1:
{
setState(5074);
((ReorderColumnsClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 6:
_localctx = new AddPartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(5077);
match(ADD);
setState(5079);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(5078);
match(TEMPORARY);
}
}
setState(5084);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,659,_ctx) ) {
case 1:
{
setState(5081);
lessThanPartitionDef();
}
break;
case 2:
{
setState(5082);
fixedPartitionDef();
}
break;
case 3:
{
setState(5083);
inPartitionDef();
}
break;
}
setState(5090);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,660,_ctx) ) {
case 1:
{
setState(5086);
match(LEFT_PAREN);
setState(5087);
((AddPartitionClauseContext)_localctx).partitionProperties = propertyItemList();
setState(5088);
match(RIGHT_PAREN);
}
break;
}
setState(5106);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,664,_ctx) ) {
case 1:
{
setState(5092);
match(DISTRIBUTED);
setState(5093);
match(BY);
setState(5097);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HASH:
{
setState(5094);
match(HASH);
setState(5095);
((AddPartitionClauseContext)_localctx).hashKeys = identifierList();
}
break;
case RANDOM:
{
setState(5096);
match(RANDOM);
}
break;
default:
throw new NoViableAltException(this);
}
setState(5104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,663,_ctx) ) {
case 1:
{
setState(5099);
match(BUCKETS);
setState(5102);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
{
setState(5100);
match(INTEGER_VALUE);
}
break;
case AUTO:
{
setState(5101);
((AddPartitionClauseContext)_localctx).autoBucket = match(AUTO);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
}
setState(5109);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,665,_ctx) ) {
case 1:
{
setState(5108);
((AddPartitionClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 7:
_localctx = new DropPartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(5111);
match(DROP);
setState(5113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(5112);
match(TEMPORARY);
}
}
setState(5115);
match(PARTITION);
setState(5118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5116);
match(IF);
setState(5117);
match(EXISTS);
}
}
setState(5120);
((DropPartitionClauseContext)_localctx).partitionName = identifier();
setState(5122);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,668,_ctx) ) {
case 1:
{
setState(5121);
match(FORCE);
}
break;
}
setState(5127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,669,_ctx) ) {
case 1:
{
setState(5124);
match(FROM);
setState(5125);
match(INDEX);
setState(5126);
((DropPartitionClauseContext)_localctx).indexName = identifier();
}
break;
}
}
break;
case 8:
_localctx = new ModifyPartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(5129);
match(MODIFY);
setState(5131);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(5130);
match(TEMPORARY);
}
}
setState(5133);
match(PARTITION);
setState(5136);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5134);
match(IF);
setState(5135);
match(EXISTS);
}
}
setState(5143);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,672,_ctx) ) {
case 1:
{
setState(5138);
((ModifyPartitionClauseContext)_localctx).partitionName = identifier();
}
break;
case 2:
{
setState(5139);
((ModifyPartitionClauseContext)_localctx).partitionNames = identifierList();
}
break;
case 3:
{
setState(5140);
match(LEFT_PAREN);
setState(5141);
match(ASTERISK);
setState(5142);
match(RIGHT_PAREN);
}
break;
}
setState(5145);
match(SET);
setState(5146);
match(LEFT_PAREN);
setState(5147);
((ModifyPartitionClauseContext)_localctx).partitionProperties = propertyItemList();
setState(5148);
match(RIGHT_PAREN);
}
break;
case 9:
_localctx = new ReplacePartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(5150);
match(REPLACE);
setState(5152);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION || _la==PARTITIONS || _la==TEMPORARY) {
{
setState(5151);
((ReplacePartitionClauseContext)_localctx).partitions = partitionSpec();
}
}
setState(5154);
match(WITH);
setState(5156);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,674,_ctx) ) {
case 1:
{
setState(5155);
((ReplacePartitionClauseContext)_localctx).tempPartitions = partitionSpec();
}
break;
}
setState(5159);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,675,_ctx) ) {
case 1:
{
setState(5158);
match(FORCE);
}
break;
}
setState(5162);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,676,_ctx) ) {
case 1:
{
setState(5161);
((ReplacePartitionClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 10:
_localctx = new ReplaceTableClauseContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(5164);
match(REPLACE);
setState(5165);
match(WITH);
setState(5166);
match(TABLE);
setState(5167);
((ReplaceTableClauseContext)_localctx).name = identifier();
setState(5169);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,677,_ctx) ) {
case 1:
{
setState(5168);
((ReplaceTableClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 11:
_localctx = new RenameClauseContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(5171);
match(RENAME);
setState(5172);
((RenameClauseContext)_localctx).newName = identifier();
}
break;
case 12:
_localctx = new RenameRollupClauseContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(5173);
match(RENAME);
setState(5174);
match(ROLLUP);
setState(5175);
((RenameRollupClauseContext)_localctx).name = identifier();
setState(5176);
((RenameRollupClauseContext)_localctx).newName = identifier();
}
break;
case 13:
_localctx = new RenamePartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(5178);
match(RENAME);
setState(5179);
match(PARTITION);
setState(5180);
((RenamePartitionClauseContext)_localctx).name = identifier();
setState(5181);
((RenamePartitionClauseContext)_localctx).newName = identifier();
}
break;
case 14:
_localctx = new RenameColumnClauseContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(5183);
match(RENAME);
setState(5184);
match(COLUMN);
setState(5185);
((RenameColumnClauseContext)_localctx).name = identifier();
setState(5186);
((RenameColumnClauseContext)_localctx).newName = identifier();
}
break;
case 15:
_localctx = new AddIndexClauseContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(5188);
match(ADD);
setState(5189);
indexDef();
}
break;
case 16:
_localctx = new DropIndexClauseContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(5190);
match(DROP);
setState(5191);
match(INDEX);
setState(5194);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5192);
match(IF);
setState(5193);
match(EXISTS);
}
}
setState(5196);
((DropIndexClauseContext)_localctx).name = identifier();
}
break;
case 17:
_localctx = new EnableFeatureClauseContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(5197);
match(ENABLE);
setState(5198);
match(FEATURE);
setState(5199);
((EnableFeatureClauseContext)_localctx).name = match(STRING_LITERAL);
setState(5202);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,679,_ctx) ) {
case 1:
{
setState(5200);
match(WITH);
setState(5201);
((EnableFeatureClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 18:
_localctx = new ModifyDistributionClauseContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(5204);
match(MODIFY);
setState(5205);
match(DISTRIBUTION);
setState(5220);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,683,_ctx) ) {
case 1:
{
setState(5206);
match(DISTRIBUTED);
setState(5207);
match(BY);
setState(5211);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HASH:
{
setState(5208);
match(HASH);
setState(5209);
((ModifyDistributionClauseContext)_localctx).hashKeys = identifierList();
}
break;
case RANDOM:
{
setState(5210);
match(RANDOM);
}
break;
default:
throw new NoViableAltException(this);
}
setState(5218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,682,_ctx) ) {
case 1:
{
setState(5213);
match(BUCKETS);
setState(5216);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
{
setState(5214);
match(INTEGER_VALUE);
}
break;
case AUTO:
{
setState(5215);
((ModifyDistributionClauseContext)_localctx).autoBucket = match(AUTO);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
}
}
break;
case 19:
_localctx = new ModifyTableCommentClauseContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(5222);
match(MODIFY);
setState(5223);
match(COMMENT);
setState(5224);
((ModifyTableCommentClauseContext)_localctx).comment = match(STRING_LITERAL);
}
break;
case 20:
_localctx = new ModifyColumnCommentClauseContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(5225);
match(MODIFY);
setState(5226);
match(COLUMN);
setState(5227);
((ModifyColumnCommentClauseContext)_localctx).name = identifier();
setState(5228);
match(COMMENT);
setState(5229);
((ModifyColumnCommentClauseContext)_localctx).comment = match(STRING_LITERAL);
}
break;
case 21:
_localctx = new ModifyEngineClauseContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(5231);
match(MODIFY);
setState(5232);
match(ENGINE);
setState(5233);
match(TO);
setState(5234);
((ModifyEngineClauseContext)_localctx).name = identifier();
setState(5236);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,684,_ctx) ) {
case 1:
{
setState(5235);
((ModifyEngineClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 22:
_localctx = new AlterMultiPartitionClauseContext(_localctx);
enterOuterAlt(_localctx, 22);
{
setState(5238);
match(ADD);
setState(5240);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(5239);
match(TEMPORARY);
}
}
setState(5242);
match(PARTITIONS);
setState(5243);
match(FROM);
setState(5244);
((AlterMultiPartitionClauseContext)_localctx).from = partitionValueList();
setState(5245);
match(TO);
setState(5246);
((AlterMultiPartitionClauseContext)_localctx).to = partitionValueList();
setState(5247);
match(INTERVAL);
setState(5248);
match(INTEGER_VALUE);
setState(5250);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,686,_ctx) ) {
case 1:
{
setState(5249);
((AlterMultiPartitionClauseContext)_localctx).unit = identifier();
}
break;
}
setState(5253);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,687,_ctx) ) {
case 1:
{
setState(5252);
((AlterMultiPartitionClauseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 23:
_localctx = new CreateOrReplaceTagClausesContext(_localctx);
enterOuterAlt(_localctx, 23);
{
setState(5255);
createOrReplaceTagClause();
}
break;
case 24:
_localctx = new CreateOrReplaceBranchClausesContext(_localctx);
enterOuterAlt(_localctx, 24);
{
setState(5256);
createOrReplaceBranchClause();
}
break;
case 25:
_localctx = new DropBranchClausesContext(_localctx);
enterOuterAlt(_localctx, 25);
{
setState(5257);
dropBranchClause();
}
break;
case 26:
_localctx = new DropTagClausesContext(_localctx);
enterOuterAlt(_localctx, 26);
{
setState(5258);
dropTagClause();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateOrReplaceTagClauseContext extends ParserRuleContext {
public IdentifierContext name;
public TagOptionsContext ops;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode TAG() { return getToken(PLParser.TAG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TagOptionsContext tagOptions() {
return getRuleContext(TagOptionsContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public CreateOrReplaceTagClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createOrReplaceTagClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateOrReplaceTagClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateOrReplaceTagClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateOrReplaceTagClause(this);
else return visitor.visitChildren(this);
}
}
public final CreateOrReplaceTagClauseContext createOrReplaceTagClause() throws RecognitionException {
CreateOrReplaceTagClauseContext _localctx = new CreateOrReplaceTagClauseContext(_ctx, getState());
enterRule(_localctx, 356, RULE_createOrReplaceTagClause);
int _la;
try {
setState(5280);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,691,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(5261);
match(CREATE);
setState(5262);
match(TAG);
setState(5266);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5263);
match(IF);
setState(5264);
match(NOT);
setState(5265);
match(EXISTS);
}
}
setState(5268);
((CreateOrReplaceTagClauseContext)_localctx).name = identifier();
setState(5269);
((CreateOrReplaceTagClauseContext)_localctx).ops = tagOptions();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(5273);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(5271);
match(CREATE);
setState(5272);
match(OR);
}
}
setState(5275);
match(REPLACE);
setState(5276);
match(TAG);
setState(5277);
((CreateOrReplaceTagClauseContext)_localctx).name = identifier();
setState(5278);
((CreateOrReplaceTagClauseContext)_localctx).ops = tagOptions();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateOrReplaceBranchClauseContext extends ParserRuleContext {
public IdentifierContext name;
public BranchOptionsContext ops;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode BRANCH() { return getToken(PLParser.BRANCH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public BranchOptionsContext branchOptions() {
return getRuleContext(BranchOptionsContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public CreateOrReplaceBranchClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createOrReplaceBranchClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateOrReplaceBranchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateOrReplaceBranchClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateOrReplaceBranchClause(this);
else return visitor.visitChildren(this);
}
}
public final CreateOrReplaceBranchClauseContext createOrReplaceBranchClause() throws RecognitionException {
CreateOrReplaceBranchClauseContext _localctx = new CreateOrReplaceBranchClauseContext(_ctx, getState());
enterRule(_localctx, 358, RULE_createOrReplaceBranchClause);
int _la;
try {
setState(5301);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,694,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(5282);
match(CREATE);
setState(5283);
match(BRANCH);
setState(5287);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5284);
match(IF);
setState(5285);
match(NOT);
setState(5286);
match(EXISTS);
}
}
setState(5289);
((CreateOrReplaceBranchClauseContext)_localctx).name = identifier();
setState(5290);
((CreateOrReplaceBranchClauseContext)_localctx).ops = branchOptions();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(5294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(5292);
match(CREATE);
setState(5293);
match(OR);
}
}
setState(5296);
match(REPLACE);
setState(5297);
match(BRANCH);
setState(5298);
((CreateOrReplaceBranchClauseContext)_localctx).name = identifier();
setState(5299);
((CreateOrReplaceBranchClauseContext)_localctx).ops = branchOptions();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TagOptionsContext extends ParserRuleContext {
public Token version;
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode OF() { return getToken(PLParser.OF, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public RetainTimeContext retainTime() {
return getRuleContext(RetainTimeContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TagOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tagOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTagOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTagOptions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTagOptions(this);
else return visitor.visitChildren(this);
}
}
public final TagOptionsContext tagOptions() throws RecognitionException {
TagOptionsContext _localctx = new TagOptionsContext(_ctx, getState());
enterRule(_localctx, 360, RULE_tagOptions);
try {
enterOuterAlt(_localctx, 1);
{
setState(5307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,695,_ctx) ) {
case 1:
{
setState(5303);
match(AS);
setState(5304);
match(OF);
setState(5305);
match(VERSION);
setState(5306);
((TagOptionsContext)_localctx).version = match(INTEGER_VALUE);
}
break;
}
setState(5310);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,696,_ctx) ) {
case 1:
{
setState(5309);
retainTime();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BranchOptionsContext extends ParserRuleContext {
public Token version;
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode OF() { return getToken(PLParser.OF, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public RetainTimeContext retainTime() {
return getRuleContext(RetainTimeContext.class,0);
}
public RetentionSnapshotContext retentionSnapshot() {
return getRuleContext(RetentionSnapshotContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public BranchOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_branchOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBranchOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBranchOptions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBranchOptions(this);
else return visitor.visitChildren(this);
}
}
public final BranchOptionsContext branchOptions() throws RecognitionException {
BranchOptionsContext _localctx = new BranchOptionsContext(_ctx, getState());
enterRule(_localctx, 362, RULE_branchOptions);
try {
enterOuterAlt(_localctx, 1);
{
setState(5316);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,697,_ctx) ) {
case 1:
{
setState(5312);
match(AS);
setState(5313);
match(OF);
setState(5314);
match(VERSION);
setState(5315);
((BranchOptionsContext)_localctx).version = match(INTEGER_VALUE);
}
break;
}
setState(5319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,698,_ctx) ) {
case 1:
{
setState(5318);
retainTime();
}
break;
}
setState(5322);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,699,_ctx) ) {
case 1:
{
setState(5321);
retentionSnapshot();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RetainTimeContext extends ParserRuleContext {
public TerminalNode RETAIN() { return getToken(PLParser.RETAIN, 0); }
public TimeValueWithUnitContext timeValueWithUnit() {
return getRuleContext(TimeValueWithUnitContext.class,0);
}
public RetainTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_retainTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRetainTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRetainTime(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRetainTime(this);
else return visitor.visitChildren(this);
}
}
public final RetainTimeContext retainTime() throws RecognitionException {
RetainTimeContext _localctx = new RetainTimeContext(_ctx, getState());
enterRule(_localctx, 364, RULE_retainTime);
try {
enterOuterAlt(_localctx, 1);
{
setState(5324);
match(RETAIN);
setState(5325);
timeValueWithUnit();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RetentionSnapshotContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public TerminalNode RETENTION() { return getToken(PLParser.RETENTION, 0); }
public MinSnapshotsToKeepContext minSnapshotsToKeep() {
return getRuleContext(MinSnapshotsToKeepContext.class,0);
}
public TimeValueWithUnitContext timeValueWithUnit() {
return getRuleContext(TimeValueWithUnitContext.class,0);
}
public RetentionSnapshotContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_retentionSnapshot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRetentionSnapshot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRetentionSnapshot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRetentionSnapshot(this);
else return visitor.visitChildren(this);
}
}
public final RetentionSnapshotContext retentionSnapshot() throws RecognitionException {
RetentionSnapshotContext _localctx = new RetentionSnapshotContext(_ctx, getState());
enterRule(_localctx, 366, RULE_retentionSnapshot);
try {
setState(5341);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,700,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(5327);
match(WITH);
setState(5328);
match(SNAPSHOT);
setState(5329);
match(RETENTION);
setState(5330);
minSnapshotsToKeep();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(5331);
match(WITH);
setState(5332);
match(SNAPSHOT);
setState(5333);
match(RETENTION);
setState(5334);
timeValueWithUnit();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(5335);
match(WITH);
setState(5336);
match(SNAPSHOT);
setState(5337);
match(RETENTION);
setState(5338);
minSnapshotsToKeep();
setState(5339);
timeValueWithUnit();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MinSnapshotsToKeepContext extends ParserRuleContext {
public Token value;
public TerminalNode SNAPSHOTS() { return getToken(PLParser.SNAPSHOTS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public MinSnapshotsToKeepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minSnapshotsToKeep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMinSnapshotsToKeep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMinSnapshotsToKeep(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMinSnapshotsToKeep(this);
else return visitor.visitChildren(this);
}
}
public final MinSnapshotsToKeepContext minSnapshotsToKeep() throws RecognitionException {
MinSnapshotsToKeepContext _localctx = new MinSnapshotsToKeepContext(_ctx, getState());
enterRule(_localctx, 368, RULE_minSnapshotsToKeep);
try {
enterOuterAlt(_localctx, 1);
{
setState(5343);
((MinSnapshotsToKeepContext)_localctx).value = match(INTEGER_VALUE);
setState(5344);
match(SNAPSHOTS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TimeValueWithUnitContext extends ParserRuleContext {
public Token timeValue;
public Token timeUnit;
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode DAYS() { return getToken(PLParser.DAYS, 0); }
public TerminalNode HOURS() { return getToken(PLParser.HOURS, 0); }
public TerminalNode MINUTES() { return getToken(PLParser.MINUTES, 0); }
public TimeValueWithUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeValueWithUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTimeValueWithUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTimeValueWithUnit(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTimeValueWithUnit(this);
else return visitor.visitChildren(this);
}
}
public final TimeValueWithUnitContext timeValueWithUnit() throws RecognitionException {
TimeValueWithUnitContext _localctx = new TimeValueWithUnitContext(_ctx, getState());
enterRule(_localctx, 370, RULE_timeValueWithUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5346);
((TimeValueWithUnitContext)_localctx).timeValue = match(INTEGER_VALUE);
setState(5347);
((TimeValueWithUnitContext)_localctx).timeUnit = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DAYS || _la==HOURS || _la==MINUTES) ) {
((TimeValueWithUnitContext)_localctx).timeUnit = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DropBranchClauseContext extends ParserRuleContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode BRANCH() { return getToken(PLParser.BRANCH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropBranchClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dropBranchClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropBranchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropBranchClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropBranchClause(this);
else return visitor.visitChildren(this);
}
}
public final DropBranchClauseContext dropBranchClause() throws RecognitionException {
DropBranchClauseContext _localctx = new DropBranchClauseContext(_ctx, getState());
enterRule(_localctx, 372, RULE_dropBranchClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5349);
match(DROP);
setState(5350);
match(BRANCH);
setState(5353);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5351);
match(IF);
setState(5352);
match(EXISTS);
}
}
setState(5355);
((DropBranchClauseContext)_localctx).name = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DropTagClauseContext extends ParserRuleContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode TAG() { return getToken(PLParser.TAG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropTagClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dropTagClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropTagClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropTagClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropTagClause(this);
else return visitor.visitChildren(this);
}
}
public final DropTagClauseContext dropTagClause() throws RecognitionException {
DropTagClauseContext _localctx = new DropTagClauseContext(_ctx, getState());
enterRule(_localctx, 374, RULE_dropTagClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5357);
match(DROP);
setState(5358);
match(TAG);
setState(5361);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5359);
match(IF);
setState(5360);
match(EXISTS);
}
}
setState(5363);
((DropTagClauseContext)_localctx).name = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnPositionContext extends ParserRuleContext {
public IdentifierContext position;
public TerminalNode FIRST() { return getToken(PLParser.FIRST, 0); }
public TerminalNode AFTER() { return getToken(PLParser.AFTER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ColumnPositionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnPosition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColumnPosition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColumnPosition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColumnPosition(this);
else return visitor.visitChildren(this);
}
}
public final ColumnPositionContext columnPosition() throws RecognitionException {
ColumnPositionContext _localctx = new ColumnPositionContext(_ctx, getState());
enterRule(_localctx, 376, RULE_columnPosition);
try {
setState(5368);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST:
enterOuterAlt(_localctx, 1);
{
setState(5365);
match(FIRST);
}
break;
case AFTER:
enterOuterAlt(_localctx, 2);
{
setState(5366);
match(AFTER);
setState(5367);
((ColumnPositionContext)_localctx).position = identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ToRollupContext extends ParserRuleContext {
public IdentifierContext rollup;
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ToRollupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_toRollup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterToRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitToRollup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitToRollup(this);
else return visitor.visitChildren(this);
}
}
public final ToRollupContext toRollup() throws RecognitionException {
ToRollupContext _localctx = new ToRollupContext(_ctx, getState());
enterRule(_localctx, 378, RULE_toRollup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5370);
_la = _input.LA(1);
if ( !(_la==IN || _la==TO) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(5371);
((ToRollupContext)_localctx).rollup = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FromRollupContext extends ParserRuleContext {
public IdentifierContext rollup;
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FromRollupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromRollup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFromRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFromRollup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFromRollup(this);
else return visitor.visitChildren(this);
}
}
public final FromRollupContext fromRollup() throws RecognitionException {
FromRollupContext _localctx = new FromRollupContext(_ctx, getState());
enterRule(_localctx, 380, RULE_fromRollup);
try {
enterOuterAlt(_localctx, 1);
{
setState(5373);
match(FROM);
setState(5374);
((FromRollupContext)_localctx).rollup = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedDropStatementContext extends ParserRuleContext {
public UnsupportedDropStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedDropStatement; }
public UnsupportedDropStatementContext() { }
public void copyFrom(UnsupportedDropStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropDatabaseContext extends UnsupportedDropStatementContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode FORCE() { return getToken(PLParser.FORCE, 0); }
public DropDatabaseContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropUserContext extends UnsupportedDropStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropUserContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropWorkloadPolicyContext extends UnsupportedDropStatementContext {
public IdentifierOrTextContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropWorkloadPolicyContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropWorkloadPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropWorkloadPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropWorkloadPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropRowPolicyContext extends UnsupportedDropStatementContext {
public IdentifierContext policyName;
public MultipartIdentifierContext tableName;
public IdentifierContext roleName;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ROW() { return getToken(PLParser.ROW, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public DropRowPolicyContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropRowPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropRowPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropRowPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropFunctionContext extends UnsupportedDropStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public FunctionArgumentsContext functionArguments() {
return getRuleContext(FunctionArgumentsContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public DropFunctionContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropWorkloadGroupContext extends UnsupportedDropStatementContext {
public IdentifierOrTextContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropWorkloadGroupContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropWorkloadGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropWorkloadGroup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropWorkloadGroup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropViewContext extends UnsupportedDropStatementContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropViewContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropView(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropSqlBlockRuleContext extends UnsupportedDropStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode SQL_BLOCK_RULE() { return getToken(PLParser.SQL_BLOCK_RULE, 0); }
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropSqlBlockRuleContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropSqlBlockRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropSqlBlockRule(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropSqlBlockRule(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropIndexContext extends UnsupportedDropStatementContext {
public IdentifierContext name;
public MultipartIdentifierContext tableName;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropIndexContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropRepositoryContext extends UnsupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode REPOSITORY() { return getToken(PLParser.REPOSITORY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DropRepositoryContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropRepository(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropRepository(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropRepository(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropEncryptkeyContext extends UnsupportedDropStatementContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ENCRYPTKEY() { return getToken(PLParser.ENCRYPTKEY, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropEncryptkeyContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropEncryptkey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropEncryptkey(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropEncryptkey(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropStageContext extends UnsupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode STAGE() { return getToken(PLParser.STAGE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropStageContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropStage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropStage(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropStage(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropResourceContext extends UnsupportedDropStatementContext {
public IdentifierOrTextContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropResourceContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropResource(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropResource(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropFileContext extends UnsupportedDropStatementContext {
public Token name;
public IdentifierContext database;
public PropertyClauseContext properties;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode FILE() { return getToken(PLParser.FILE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DropFileContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropFile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropFile(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropCatalogContext extends UnsupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropCatalogContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropTableContext extends UnsupportedDropStatementContext {
public MultipartIdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode FORCE() { return getToken(PLParser.FORCE, 0); }
public DropTableContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropStoragePolicyContext extends UnsupportedDropStatementContext {
public IdentifierContext name;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public DropStoragePolicyContext(UnsupportedDropStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropStoragePolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropStoragePolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropStoragePolicy(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedDropStatementContext unsupportedDropStatement() throws RecognitionException {
UnsupportedDropStatementContext _localctx = new UnsupportedDropStatementContext(_ctx, getState());
enterRule(_localctx, 382, RULE_unsupportedDropStatement);
int _la;
try {
setState(5524);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,726,_ctx) ) {
case 1:
_localctx = new DropDatabaseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(5376);
match(DROP);
setState(5377);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(5380);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5378);
match(IF);
setState(5379);
match(EXISTS);
}
}
setState(5382);
((DropDatabaseContext)_localctx).name = multipartIdentifier();
setState(5384);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,705,_ctx) ) {
case 1:
{
setState(5383);
match(FORCE);
}
break;
}
}
break;
case 2:
_localctx = new DropCatalogContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(5386);
match(DROP);
setState(5387);
match(CATALOG);
setState(5390);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5388);
match(IF);
setState(5389);
match(EXISTS);
}
}
setState(5392);
((DropCatalogContext)_localctx).name = identifier();
}
break;
case 3:
_localctx = new DropFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(5393);
match(DROP);
setState(5395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(5394);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(5397);
match(FUNCTION);
setState(5400);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,708,_ctx) ) {
case 1:
{
setState(5398);
match(IF);
setState(5399);
match(EXISTS);
}
break;
}
setState(5402);
functionIdentifier();
setState(5403);
match(LEFT_PAREN);
setState(5405);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 186)) & ~0x3f) == 0 && ((1L << (_la - 186)) & 143005235300353L) != 0) || ((((_la - 251)) & ~0x3f) == 0 && ((1L << (_la - 251)) & 16870906416594945L) != 0) || _la==DOUBLE || _la==FLOAT || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 4604407840769L) != 0) || _la==MAP || _la==QUANTILE_STATE || _la==SMALLINT || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 20266198328541187L) != 0)) {
{
setState(5404);
functionArguments();
}
}
setState(5407);
match(RIGHT_PAREN);
}
break;
case 4:
_localctx = new DropTableContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(5409);
match(DROP);
setState(5410);
match(TABLE);
setState(5413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5411);
match(IF);
setState(5412);
match(EXISTS);
}
}
setState(5415);
((DropTableContext)_localctx).name = multipartIdentifier();
setState(5417);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,711,_ctx) ) {
case 1:
{
setState(5416);
match(FORCE);
}
break;
}
}
break;
case 5:
_localctx = new DropUserContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(5419);
match(DROP);
setState(5420);
match(USER);
setState(5423);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5421);
match(IF);
setState(5422);
match(EXISTS);
}
}
setState(5425);
userIdentify();
}
break;
case 6:
_localctx = new DropViewContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(5426);
match(DROP);
setState(5427);
match(VIEW);
setState(5430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5428);
match(IF);
setState(5429);
match(EXISTS);
}
}
setState(5432);
((DropViewContext)_localctx).name = multipartIdentifier();
}
break;
case 7:
_localctx = new DropRepositoryContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(5433);
match(DROP);
setState(5434);
match(REPOSITORY);
setState(5435);
((DropRepositoryContext)_localctx).name = identifier();
}
break;
case 8:
_localctx = new DropFileContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(5436);
match(DROP);
setState(5437);
match(FILE);
setState(5438);
((DropFileContext)_localctx).name = match(STRING_LITERAL);
setState(5441);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(5439);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(5440);
((DropFileContext)_localctx).database = identifier();
}
}
setState(5443);
((DropFileContext)_localctx).properties = propertyClause();
}
break;
case 9:
_localctx = new DropIndexContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(5444);
match(DROP);
setState(5445);
match(INDEX);
setState(5448);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5446);
match(IF);
setState(5447);
match(EXISTS);
}
}
setState(5450);
((DropIndexContext)_localctx).name = identifier();
setState(5451);
match(ON);
setState(5452);
((DropIndexContext)_localctx).tableName = multipartIdentifier();
}
break;
case 10:
_localctx = new DropResourceContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(5454);
match(DROP);
setState(5455);
match(RESOURCE);
setState(5458);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5456);
match(IF);
setState(5457);
match(EXISTS);
}
}
setState(5460);
((DropResourceContext)_localctx).name = identifierOrText();
}
break;
case 11:
_localctx = new DropWorkloadGroupContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(5461);
match(DROP);
setState(5462);
match(WORKLOAD);
setState(5463);
match(GROUP);
setState(5466);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5464);
match(IF);
setState(5465);
match(EXISTS);
}
}
setState(5468);
((DropWorkloadGroupContext)_localctx).name = identifierOrText();
}
break;
case 12:
_localctx = new DropWorkloadPolicyContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(5469);
match(DROP);
setState(5470);
match(WORKLOAD);
setState(5471);
match(POLICY);
setState(5474);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5472);
match(IF);
setState(5473);
match(EXISTS);
}
}
setState(5476);
((DropWorkloadPolicyContext)_localctx).name = identifierOrText();
}
break;
case 13:
_localctx = new DropEncryptkeyContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(5477);
match(DROP);
setState(5478);
match(ENCRYPTKEY);
setState(5481);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5479);
match(IF);
setState(5480);
match(EXISTS);
}
}
setState(5483);
((DropEncryptkeyContext)_localctx).name = multipartIdentifier();
}
break;
case 14:
_localctx = new DropSqlBlockRuleContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(5484);
match(DROP);
setState(5485);
match(SQL_BLOCK_RULE);
setState(5488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5486);
match(IF);
setState(5487);
match(EXISTS);
}
}
setState(5490);
identifierSeq();
}
break;
case 15:
_localctx = new DropRowPolicyContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(5491);
match(DROP);
setState(5492);
match(ROW);
setState(5493);
match(POLICY);
setState(5496);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5494);
match(IF);
setState(5495);
match(EXISTS);
}
}
setState(5498);
((DropRowPolicyContext)_localctx).policyName = identifier();
setState(5499);
match(ON);
setState(5500);
((DropRowPolicyContext)_localctx).tableName = multipartIdentifier();
setState(5507);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,723,_ctx) ) {
case 1:
{
setState(5501);
match(FOR);
setState(5505);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(5502);
userIdentify();
}
break;
case ROLE:
{
setState(5503);
match(ROLE);
setState(5504);
((DropRowPolicyContext)_localctx).roleName = identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
case 16:
_localctx = new DropStoragePolicyContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(5509);
match(DROP);
setState(5510);
match(STORAGE);
setState(5511);
match(POLICY);
setState(5514);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5512);
match(IF);
setState(5513);
match(EXISTS);
}
}
setState(5516);
((DropStoragePolicyContext)_localctx).name = identifier();
}
break;
case 17:
_localctx = new DropStageContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(5517);
match(DROP);
setState(5518);
match(STAGE);
setState(5521);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5519);
match(IF);
setState(5520);
match(EXISTS);
}
}
setState(5523);
((DropStageContext)_localctx).name = identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedStatsStatementContext extends ParserRuleContext {
public UnsupportedStatsStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedStatsStatement; }
public UnsupportedStatsStatementContext() { }
public void copyFrom(UnsupportedStatsStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowTableStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierListContext columnList;
public Token tableId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowTableStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowTableStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowTableStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowTableStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowColumnStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierListContext columnList;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode CACHED() { return getToken(PLParser.CACHED, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ShowColumnStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowColumnStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowColumnStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowColumnStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AnalyzeDatabaseContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext name;
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<TerminalNode> WITH() { return getTokens(PLParser.WITH); }
public TerminalNode WITH(int i) {
return getToken(PLParser.WITH, i);
}
public List<AnalyzePropertiesContext> analyzeProperties() {
return getRuleContexts(AnalyzePropertiesContext.class);
}
public AnalyzePropertiesContext analyzeProperties(int i) {
return getRuleContext(AnalyzePropertiesContext.class,i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public AnalyzeDatabaseContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAnalyzeDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAnalyzeDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAnalyzeDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAnalyzeTaskContext extends UnsupportedStatsStatementContext {
public Token jobId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode TASK() { return getToken(PLParser.TASK, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public ShowAnalyzeTaskContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAnalyzeTask(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAnalyzeTask(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAnalyzeTask(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowIndexStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierContext indexId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ShowIndexStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowIndexStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowIndexStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowIndexStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAutoAnalyzeJobsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public TerminalNode JOBS() { return getToken(PLParser.JOBS, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowAutoAnalyzeJobsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAutoAnalyzeJobs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAutoAnalyzeJobs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAutoAnalyzeJobs(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierListContext columns;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public DropStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropCachedStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode CACHED() { return getToken(PLParser.CACHED, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public DropCachedStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropCachedStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropCachedStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropCachedStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class KillAnalyzeJobContext extends UnsupportedStatsStatementContext {
public Token jobId;
public TerminalNode KILL() { return getToken(PLParser.KILL, 0); }
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public KillAnalyzeJobContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterKillAnalyzeJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitKillAnalyzeJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitKillAnalyzeJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropAnalyzeJobContext extends UnsupportedStatsStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public DropAnalyzeJobContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropAnalyzeJob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropAnalyzeJob(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropAnalyzeJob(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAnalyzeContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowAnalyzeContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAnalyze(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAnalyze(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAnalyze(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterColumnStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext name;
public IdentifierContext indexName;
public IdentifierContext columnName;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public AlterColumnStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterColumnStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterColumnStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterColumnStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DropExpiredStatsContext extends UnsupportedStatsStatementContext {
public TerminalNode DROP() { return getToken(PLParser.DROP, 0); }
public TerminalNode EXPIRED() { return getToken(PLParser.EXPIRED, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public DropExpiredStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDropExpiredStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDropExpiredStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDropExpiredStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AnalyzeTableContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext name;
public IdentifierListContext columns;
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public List<TerminalNode> WITH() { return getTokens(PLParser.WITH); }
public TerminalNode WITH(int i) {
return getToken(PLParser.WITH, i);
}
public List<AnalyzePropertiesContext> analyzeProperties() {
return getRuleContexts(AnalyzePropertiesContext.class);
}
public AnalyzePropertiesContext analyzeProperties(int i) {
return getRuleContext(AnalyzePropertiesContext.class,i);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public AnalyzeTableContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAnalyzeTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAnalyzeTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAnalyzeTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowAnalyzeFromJobIdContext extends UnsupportedStatsStatementContext {
public Token jobId;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode ANALYZE() { return getToken(PLParser.ANALYZE, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public WildWhereContext wildWhere() {
return getRuleContext(WildWhereContext.class,0);
}
public ShowAnalyzeFromJobIdContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowAnalyzeFromJobId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowAnalyzeFromJobId(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowAnalyzeFromJobId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterTableStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext name;
public TerminalNode ALTER() { return getToken(PLParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public AlterTableStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAlterTableStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAlterTableStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAlterTableStats(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ShowColumnHistogramStatsContext extends UnsupportedStatsStatementContext {
public MultipartIdentifierContext tableName;
public IdentifierListContext columnList;
public TerminalNode SHOW() { return getToken(PLParser.SHOW, 0); }
public TerminalNode COLUMN() { return getToken(PLParser.COLUMN, 0); }
public TerminalNode HISTOGRAM() { return getToken(PLParser.HISTOGRAM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ShowColumnHistogramStatsContext(UnsupportedStatsStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterShowColumnHistogramStats(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitShowColumnHistogramStats(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitShowColumnHistogramStats(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedStatsStatementContext unsupportedStatsStatement() throws RecognitionException {
UnsupportedStatsStatementContext _localctx = new UnsupportedStatsStatementContext(_ctx, getState());
enterRule(_localctx, 384, RULE_unsupportedStatsStatement);
int _la;
try {
int _alt;
setState(5680);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,749,_ctx) ) {
case 1:
_localctx = new AnalyzeTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(5526);
match(ANALYZE);
setState(5527);
match(TABLE);
setState(5528);
((AnalyzeTableContext)_localctx).name = multipartIdentifier();
setState(5530);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,727,_ctx) ) {
case 1:
{
setState(5529);
partitionSpec();
}
break;
}
setState(5533);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,728,_ctx) ) {
case 1:
{
setState(5532);
((AnalyzeTableContext)_localctx).columns = identifierList();
}
break;
}
setState(5539);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,729,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(5535);
match(WITH);
setState(5536);
analyzeProperties();
}
}
}
setState(5541);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,729,_ctx);
}
setState(5543);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,730,_ctx) ) {
case 1:
{
setState(5542);
propertyClause();
}
break;
}
}
break;
case 2:
_localctx = new AnalyzeDatabaseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(5545);
match(ANALYZE);
setState(5546);
match(DATABASE);
setState(5547);
((AnalyzeDatabaseContext)_localctx).name = multipartIdentifier();
setState(5552);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,731,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(5548);
match(WITH);
setState(5549);
analyzeProperties();
}
}
}
setState(5554);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,731,_ctx);
}
setState(5556);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,732,_ctx) ) {
case 1:
{
setState(5555);
propertyClause();
}
break;
}
}
break;
case 3:
_localctx = new AlterTableStatsContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(5558);
match(ALTER);
setState(5559);
match(TABLE);
setState(5560);
((AlterTableStatsContext)_localctx).name = multipartIdentifier();
setState(5561);
match(SET);
setState(5562);
match(STATS);
setState(5563);
match(LEFT_PAREN);
setState(5564);
propertyItemList();
setState(5565);
match(RIGHT_PAREN);
setState(5567);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,733,_ctx) ) {
case 1:
{
setState(5566);
partitionSpec();
}
break;
}
}
break;
case 4:
_localctx = new AlterColumnStatsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(5569);
match(ALTER);
setState(5570);
match(TABLE);
setState(5571);
((AlterColumnStatsContext)_localctx).name = multipartIdentifier();
setState(5574);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INDEX) {
{
setState(5572);
match(INDEX);
setState(5573);
((AlterColumnStatsContext)_localctx).indexName = identifier();
}
}
setState(5576);
match(MODIFY);
setState(5577);
match(COLUMN);
setState(5578);
((AlterColumnStatsContext)_localctx).columnName = identifier();
setState(5579);
match(SET);
setState(5580);
match(STATS);
setState(5581);
match(LEFT_PAREN);
setState(5582);
propertyItemList();
setState(5583);
match(RIGHT_PAREN);
setState(5585);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,735,_ctx) ) {
case 1:
{
setState(5584);
partitionSpec();
}
break;
}
}
break;
case 5:
_localctx = new DropStatsContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(5587);
match(DROP);
setState(5588);
match(STATS);
setState(5589);
((DropStatsContext)_localctx).tableName = multipartIdentifier();
setState(5591);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,736,_ctx) ) {
case 1:
{
setState(5590);
((DropStatsContext)_localctx).columns = identifierList();
}
break;
}
setState(5594);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,737,_ctx) ) {
case 1:
{
setState(5593);
partitionSpec();
}
break;
}
}
break;
case 6:
_localctx = new DropCachedStatsContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(5596);
match(DROP);
setState(5597);
match(CACHED);
setState(5598);
match(STATS);
setState(5599);
((DropCachedStatsContext)_localctx).tableName = multipartIdentifier();
}
break;
case 7:
_localctx = new DropExpiredStatsContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(5600);
match(DROP);
setState(5601);
match(EXPIRED);
setState(5602);
match(STATS);
}
break;
case 8:
_localctx = new DropAnalyzeJobContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(5603);
match(DROP);
setState(5604);
match(ANALYZE);
setState(5605);
match(JOB);
setState(5606);
match(INTEGER_VALUE);
}
break;
case 9:
_localctx = new KillAnalyzeJobContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(5607);
match(KILL);
setState(5608);
match(ANALYZE);
setState(5609);
((KillAnalyzeJobContext)_localctx).jobId = match(INTEGER_VALUE);
}
break;
case 10:
_localctx = new ShowTableStatsContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(5610);
match(SHOW);
setState(5611);
match(TABLE);
setState(5612);
match(STATS);
setState(5613);
((ShowTableStatsContext)_localctx).tableName = multipartIdentifier();
setState(5615);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,738,_ctx) ) {
case 1:
{
setState(5614);
partitionSpec();
}
break;
}
setState(5618);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,739,_ctx) ) {
case 1:
{
setState(5617);
((ShowTableStatsContext)_localctx).columnList = identifierList();
}
break;
}
}
break;
case 11:
_localctx = new ShowTableStatsContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(5620);
match(SHOW);
setState(5621);
match(TABLE);
setState(5622);
match(STATS);
setState(5623);
((ShowTableStatsContext)_localctx).tableId = match(INTEGER_VALUE);
}
break;
case 12:
_localctx = new ShowIndexStatsContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(5624);
match(SHOW);
setState(5625);
match(INDEX);
setState(5626);
match(STATS);
setState(5627);
((ShowIndexStatsContext)_localctx).tableName = multipartIdentifier();
setState(5628);
((ShowIndexStatsContext)_localctx).indexId = identifier();
}
break;
case 13:
_localctx = new ShowColumnStatsContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(5630);
match(SHOW);
setState(5631);
match(COLUMN);
setState(5633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CACHED) {
{
setState(5632);
match(CACHED);
}
}
setState(5635);
match(STATS);
setState(5636);
((ShowColumnStatsContext)_localctx).tableName = multipartIdentifier();
setState(5638);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,741,_ctx) ) {
case 1:
{
setState(5637);
((ShowColumnStatsContext)_localctx).columnList = identifierList();
}
break;
}
setState(5641);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,742,_ctx) ) {
case 1:
{
setState(5640);
partitionSpec();
}
break;
}
}
break;
case 14:
_localctx = new ShowColumnHistogramStatsContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(5643);
match(SHOW);
setState(5644);
match(COLUMN);
setState(5645);
match(HISTOGRAM);
setState(5646);
((ShowColumnHistogramStatsContext)_localctx).tableName = multipartIdentifier();
setState(5647);
((ShowColumnHistogramStatsContext)_localctx).columnList = identifierList();
}
break;
case 15:
_localctx = new ShowAnalyzeContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(5649);
match(SHOW);
setState(5651);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AUTO) {
{
setState(5650);
match(AUTO);
}
}
setState(5653);
match(ANALYZE);
setState(5655);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,744,_ctx) ) {
case 1:
{
setState(5654);
((ShowAnalyzeContext)_localctx).tableName = multipartIdentifier();
}
break;
}
setState(5658);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,745,_ctx) ) {
case 1:
{
setState(5657);
wildWhere();
}
break;
}
}
break;
case 16:
_localctx = new ShowAnalyzeFromJobIdContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(5660);
match(SHOW);
setState(5661);
match(ANALYZE);
setState(5662);
((ShowAnalyzeFromJobIdContext)_localctx).jobId = match(INTEGER_VALUE);
setState(5664);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,746,_ctx) ) {
case 1:
{
setState(5663);
wildWhere();
}
break;
}
}
break;
case 17:
_localctx = new ShowAutoAnalyzeJobsContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(5666);
match(SHOW);
setState(5667);
match(AUTO);
setState(5668);
match(JOBS);
setState(5670);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,747,_ctx) ) {
case 1:
{
setState(5669);
((ShowAutoAnalyzeJobsContext)_localctx).tableName = multipartIdentifier();
}
break;
}
setState(5673);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,748,_ctx) ) {
case 1:
{
setState(5672);
wildWhere();
}
break;
}
}
break;
case 18:
_localctx = new ShowAnalyzeTaskContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(5675);
match(SHOW);
setState(5676);
match(ANALYZE);
setState(5677);
match(TASK);
setState(5678);
match(STATUS);
setState(5679);
((ShowAnalyzeTaskContext)_localctx).jobId = match(INTEGER_VALUE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnalyzePropertiesContext extends ParserRuleContext {
public Token rows;
public Token percent;
public Token bucket;
public Token periodInSecond;
public Token crontabExpr;
public TerminalNode SYNC() { return getToken(PLParser.SYNC, 0); }
public TerminalNode INCREMENTAL() { return getToken(PLParser.INCREMENTAL, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public TerminalNode SQL() { return getToken(PLParser.SQL, 0); }
public TerminalNode HISTOGRAM() { return getToken(PLParser.HISTOGRAM, 0); }
public TerminalNode SAMPLE() { return getToken(PLParser.SAMPLE, 0); }
public TerminalNode ROWS() { return getToken(PLParser.ROWS, 0); }
public TerminalNode PERCENT() { return getToken(PLParser.PERCENT, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public TerminalNode PERIOD() { return getToken(PLParser.PERIOD, 0); }
public TerminalNode CRON() { return getToken(PLParser.CRON, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public AnalyzePropertiesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_analyzeProperties; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAnalyzeProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAnalyzeProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAnalyzeProperties(this);
else return visitor.visitChildren(this);
}
}
public final AnalyzePropertiesContext analyzeProperties() throws RecognitionException {
AnalyzePropertiesContext _localctx = new AnalyzePropertiesContext(_ctx, getState());
enterRule(_localctx, 386, RULE_analyzeProperties);
try {
setState(5700);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SYNC:
enterOuterAlt(_localctx, 1);
{
setState(5682);
match(SYNC);
}
break;
case INCREMENTAL:
enterOuterAlt(_localctx, 2);
{
setState(5683);
match(INCREMENTAL);
}
break;
case FULL:
enterOuterAlt(_localctx, 3);
{
setState(5684);
match(FULL);
}
break;
case SQL:
enterOuterAlt(_localctx, 4);
{
setState(5685);
match(SQL);
}
break;
case HISTOGRAM:
enterOuterAlt(_localctx, 5);
{
setState(5686);
match(HISTOGRAM);
}
break;
case SAMPLE:
enterOuterAlt(_localctx, 6);
{
{
setState(5687);
match(SAMPLE);
setState(5692);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROWS:
{
{
setState(5688);
match(ROWS);
setState(5689);
((AnalyzePropertiesContext)_localctx).rows = match(INTEGER_VALUE);
}
}
break;
case PERCENT:
{
{
setState(5690);
match(PERCENT);
setState(5691);
((AnalyzePropertiesContext)_localctx).percent = match(INTEGER_VALUE);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case BUCKETS:
enterOuterAlt(_localctx, 7);
{
{
setState(5694);
match(BUCKETS);
setState(5695);
((AnalyzePropertiesContext)_localctx).bucket = match(INTEGER_VALUE);
}
}
break;
case PERIOD:
enterOuterAlt(_localctx, 8);
{
{
setState(5696);
match(PERIOD);
setState(5697);
((AnalyzePropertiesContext)_localctx).periodInSecond = match(INTEGER_VALUE);
}
}
break;
case CRON:
enterOuterAlt(_localctx, 9);
{
{
setState(5698);
match(CRON);
setState(5699);
((AnalyzePropertiesContext)_localctx).crontabExpr = match(STRING_LITERAL);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedCreateStatementContext extends ParserRuleContext {
public UnsupportedCreateStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedCreateStatement; }
public UnsupportedCreateStatementContext() { }
public void copyFrom(UnsupportedCreateStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateStorageVaultContext extends UnsupportedCreateStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateStorageVaultContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateStorageVault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateStorageVault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateStorageVault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateWorkloadPolicyContext extends UnsupportedCreateStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode CONDITIONS() { return getToken(PLParser.CONDITIONS, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public WorkloadPolicyConditionsContext workloadPolicyConditions() {
return getRuleContext(WorkloadPolicyConditionsContext.class,0);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public TerminalNode ACTIONS() { return getToken(PLParser.ACTIONS, 0); }
public WorkloadPolicyActionsContext workloadPolicyActions() {
return getRuleContext(WorkloadPolicyActionsContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateWorkloadPolicyContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateWorkloadPolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateWorkloadPolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateWorkloadPolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateResourceContext extends UnsupportedCreateStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode EXTERNAL() { return getToken(PLParser.EXTERNAL, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateResourceContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateResource(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateResource(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateUserDefineFunctionContext extends UnsupportedCreateStatementContext {
public DataTypeContext returnType;
public DataTypeContext intermediateType;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode RETURNS() { return getToken(PLParser.RETURNS, 0); }
public List<DataTypeContext> dataType() {
return getRuleContexts(DataTypeContext.class);
}
public DataTypeContext dataType(int i) {
return getRuleContext(DataTypeContext.class,i);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public FunctionArgumentsContext functionArguments() {
return getRuleContext(FunctionArgumentsContext.class,0);
}
public TerminalNode INTERMEDIATE() { return getToken(PLParser.INTERMEDIATE, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public TerminalNode AGGREGATE() { return getToken(PLParser.AGGREGATE, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateUserDefineFunctionContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateUserDefineFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateUserDefineFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateUserDefineFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateWorkloadGroupContext extends UnsupportedCreateStatementContext {
public IdentifierOrTextContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode WORKLOAD() { return getToken(PLParser.WORKLOAD, 0); }
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateWorkloadGroupContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateWorkloadGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateWorkloadGroup(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateWorkloadGroup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateStoragePolicyContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateStoragePolicyContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateStoragePolicy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateStoragePolicy(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateStoragePolicy(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateRoleContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public CreateRoleContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateRole(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateRole(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateStageContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode STAGE() { return getToken(PLParser.STAGE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateStageContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateStage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateStage(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateStage(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateIndexContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public MultipartIdentifierContext tableName;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode BITMAP() { return getToken(PLParser.BITMAP, 0); }
public TerminalNode NGRAM_BF() { return getToken(PLParser.NGRAM_BF, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateIndexContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateFileContext extends UnsupportedCreateStatementContext {
public Token name;
public IdentifierContext database;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode FILE() { return getToken(PLParser.FILE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CreateFileContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateFile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateFile(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateRepositoryContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode REPOSITORY() { return getToken(PLParser.REPOSITORY, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public StorageBackendContext storageBackend() {
return getRuleContext(StorageBackendContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode READ() { return getToken(PLParser.READ, 0); }
public TerminalNode ONLY() { return getToken(PLParser.ONLY, 0); }
public CreateRepositoryContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateRepository(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateRepository(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateRepository(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateEncryptkeyContext extends UnsupportedCreateStatementContext {
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ENCRYPTKEY() { return getToken(PLParser.ENCRYPTKEY, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public CreateEncryptkeyContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateEncryptkey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateEncryptkey(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateEncryptkey(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateDatabaseContext extends UnsupportedCreateStatementContext {
public MultipartIdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateDatabaseContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BuildIndexContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public MultipartIdentifierContext tableName;
public TerminalNode BUILD() { return getToken(PLParser.BUILD, 0); }
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public BuildIndexContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBuildIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBuildIndex(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBuildIndex(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateUserContext extends UnsupportedCreateStatementContext {
public Token role;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public GrantUserIdentifyContext grantUserIdentify() {
return getRuleContext(GrantUserIdentifyContext.class,0);
}
public PasswordOptionContext passwordOption() {
return getRuleContext(PasswordOptionContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode SUPERUSER() { return getToken(PLParser.SUPERUSER, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode ROLE() { return getToken(PLParser.ROLE, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public CreateUserContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateCatalogContext extends UnsupportedCreateStatementContext {
public IdentifierContext catalogName;
public IdentifierContext resourceName;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateCatalogContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateAliasFunctionContext extends UnsupportedCreateStatementContext {
public IdentifierSeqContext parameters;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode ALIAS() { return getToken(PLParser.ALIAS, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode PARAMETER() { return getToken(PLParser.PARAMETER, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public FunctionArgumentsContext functionArguments() {
return getRuleContext(FunctionArgumentsContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public CreateAliasFunctionContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateAliasFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateAliasFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateAliasFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateSqlBlockRuleContext extends UnsupportedCreateStatementContext {
public IdentifierContext name;
public PropertyClauseContext properties;
public TerminalNode CREATE() { return getToken(PLParser.CREATE, 0); }
public TerminalNode SQL_BLOCK_RULE() { return getToken(PLParser.SQL_BLOCK_RULE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public CreateSqlBlockRuleContext(UnsupportedCreateStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCreateSqlBlockRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCreateSqlBlockRule(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCreateSqlBlockRule(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedCreateStatementContext unsupportedCreateStatement() throws RecognitionException {
UnsupportedCreateStatementContext _localctx = new UnsupportedCreateStatementContext(_ctx, getState());
enterRule(_localctx, 388, RULE_unsupportedCreateStatement);
int _la;
try {
setState(5976);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,798,_ctx) ) {
case 1:
_localctx = new CreateDatabaseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(5702);
match(CREATE);
setState(5703);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(5707);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5704);
match(IF);
setState(5705);
match(NOT);
setState(5706);
match(EXISTS);
}
}
setState(5709);
((CreateDatabaseContext)_localctx).name = multipartIdentifier();
setState(5711);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,753,_ctx) ) {
case 1:
{
setState(5710);
((CreateDatabaseContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 2:
_localctx = new CreateCatalogContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(5713);
match(CREATE);
setState(5714);
match(CATALOG);
setState(5718);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5715);
match(IF);
setState(5716);
match(NOT);
setState(5717);
match(EXISTS);
}
}
setState(5720);
((CreateCatalogContext)_localctx).catalogName = identifier();
setState(5724);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,755,_ctx) ) {
case 1:
{
setState(5721);
match(WITH);
setState(5722);
match(RESOURCE);
setState(5723);
((CreateCatalogContext)_localctx).resourceName = identifier();
}
break;
}
setState(5728);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,756,_ctx) ) {
case 1:
{
setState(5726);
match(COMMENT);
setState(5727);
match(STRING_LITERAL);
}
break;
}
setState(5731);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,757,_ctx) ) {
case 1:
{
setState(5730);
((CreateCatalogContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 3:
_localctx = new CreateUserDefineFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(5733);
match(CREATE);
setState(5735);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(5734);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(5738);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AGGREGATE || _la==TABLES) {
{
setState(5737);
_la = _input.LA(1);
if ( !(_la==AGGREGATE || _la==TABLES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(5740);
match(FUNCTION);
setState(5744);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,760,_ctx) ) {
case 1:
{
setState(5741);
match(IF);
setState(5742);
match(NOT);
setState(5743);
match(EXISTS);
}
break;
}
setState(5746);
functionIdentifier();
setState(5747);
match(LEFT_PAREN);
setState(5749);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 186)) & ~0x3f) == 0 && ((1L << (_la - 186)) & 143005235300353L) != 0) || ((((_la - 251)) & ~0x3f) == 0 && ((1L << (_la - 251)) & 16870906416594945L) != 0) || _la==DOUBLE || _la==FLOAT || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 4604407840769L) != 0) || _la==MAP || _la==QUANTILE_STATE || _la==SMALLINT || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 20266198328541187L) != 0)) {
{
setState(5748);
functionArguments();
}
}
setState(5751);
match(RIGHT_PAREN);
setState(5752);
match(RETURNS);
setState(5753);
((CreateUserDefineFunctionContext)_localctx).returnType = dataType();
setState(5756);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,762,_ctx) ) {
case 1:
{
setState(5754);
match(INTERMEDIATE);
setState(5755);
((CreateUserDefineFunctionContext)_localctx).intermediateType = dataType();
}
break;
}
setState(5759);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,763,_ctx) ) {
case 1:
{
setState(5758);
((CreateUserDefineFunctionContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 4:
_localctx = new CreateAliasFunctionContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(5761);
match(CREATE);
setState(5763);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(5762);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(5765);
match(ALIAS);
setState(5766);
match(FUNCTION);
setState(5770);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,765,_ctx) ) {
case 1:
{
setState(5767);
match(IF);
setState(5768);
match(NOT);
setState(5769);
match(EXISTS);
}
break;
}
setState(5772);
functionIdentifier();
setState(5773);
match(LEFT_PAREN);
setState(5775);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 186)) & ~0x3f) == 0 && ((1L << (_la - 186)) & 143005235300353L) != 0) || ((((_la - 251)) & ~0x3f) == 0 && ((1L << (_la - 251)) & 16870906416594945L) != 0) || _la==DOUBLE || _la==FLOAT || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 4604407840769L) != 0) || _la==MAP || _la==QUANTILE_STATE || _la==SMALLINT || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 20266198328541187L) != 0)) {
{
setState(5774);
functionArguments();
}
}
setState(5777);
match(RIGHT_PAREN);
setState(5778);
match(WITH);
setState(5779);
match(PARAMETER);
setState(5780);
match(LEFT_PAREN);
setState(5782);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3927138875067072511L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731775120419L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761490469167143L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & 9222670387358137151L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -7342142259167539995L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305842422950835435L) != 0) || _la==IDENTIFIER || _la==BACKQUOTED_IDENTIFIER) {
{
setState(5781);
((CreateAliasFunctionContext)_localctx).parameters = identifierSeq();
}
}
setState(5784);
match(RIGHT_PAREN);
setState(5785);
match(AS);
setState(5786);
expression();
}
break;
case 5:
_localctx = new CreateUserContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(5788);
match(CREATE);
setState(5789);
match(USER);
setState(5793);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5790);
match(IF);
setState(5791);
match(NOT);
setState(5792);
match(EXISTS);
}
}
setState(5795);
grantUserIdentify();
setState(5800);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,769,_ctx) ) {
case 1:
{
setState(5796);
match(SUPERUSER);
}
break;
case 2:
{
setState(5797);
match(DEFAULT);
setState(5798);
match(ROLE);
setState(5799);
((CreateUserContext)_localctx).role = match(STRING_LITERAL);
}
break;
}
setState(5802);
passwordOption();
setState(5805);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,770,_ctx) ) {
case 1:
{
setState(5803);
match(COMMENT);
setState(5804);
match(STRING_LITERAL);
}
break;
}
}
break;
case 6:
_localctx = new CreateRepositoryContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(5807);
match(CREATE);
setState(5810);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==READ) {
{
setState(5808);
match(READ);
setState(5809);
match(ONLY);
}
}
setState(5812);
match(REPOSITORY);
setState(5813);
((CreateRepositoryContext)_localctx).name = identifier();
setState(5814);
match(WITH);
setState(5815);
storageBackend();
}
break;
case 7:
_localctx = new CreateRoleContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(5817);
match(CREATE);
setState(5818);
match(ROLE);
setState(5822);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5819);
match(IF);
setState(5820);
match(NOT);
setState(5821);
match(EXISTS);
}
}
setState(5824);
((CreateRoleContext)_localctx).name = identifier();
setState(5827);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,773,_ctx) ) {
case 1:
{
setState(5825);
match(COMMENT);
setState(5826);
match(STRING_LITERAL);
}
break;
}
}
break;
case 8:
_localctx = new CreateFileContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(5829);
match(CREATE);
setState(5830);
match(FILE);
setState(5831);
((CreateFileContext)_localctx).name = match(STRING_LITERAL);
setState(5834);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(5832);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(5833);
((CreateFileContext)_localctx).database = identifier();
}
}
setState(5836);
((CreateFileContext)_localctx).properties = propertyClause();
}
break;
case 9:
_localctx = new CreateIndexContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(5837);
match(CREATE);
setState(5838);
match(INDEX);
setState(5842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5839);
match(IF);
setState(5840);
match(NOT);
setState(5841);
match(EXISTS);
}
}
setState(5844);
((CreateIndexContext)_localctx).name = identifier();
setState(5845);
match(ON);
setState(5846);
((CreateIndexContext)_localctx).tableName = multipartIdentifier();
setState(5847);
identifierList();
setState(5850);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,776,_ctx) ) {
case 1:
{
setState(5848);
match(USING);
setState(5849);
_la = _input.LA(1);
if ( !(_la==BITMAP || _la==INVERTED || _la==NGRAM_BF) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(5853);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,777,_ctx) ) {
case 1:
{
setState(5852);
((CreateIndexContext)_localctx).properties = propertyClause();
}
break;
}
setState(5857);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,778,_ctx) ) {
case 1:
{
setState(5855);
match(COMMENT);
setState(5856);
match(STRING_LITERAL);
}
break;
}
}
break;
case 10:
_localctx = new CreateResourceContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(5859);
match(CREATE);
setState(5861);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL) {
{
setState(5860);
match(EXTERNAL);
}
}
setState(5863);
match(RESOURCE);
setState(5867);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5864);
match(IF);
setState(5865);
match(NOT);
setState(5866);
match(EXISTS);
}
}
setState(5869);
((CreateResourceContext)_localctx).name = identifierOrText();
setState(5871);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,781,_ctx) ) {
case 1:
{
setState(5870);
((CreateResourceContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 11:
_localctx = new CreateStorageVaultContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(5873);
match(CREATE);
setState(5874);
match(STORAGE);
setState(5875);
match(VAULT);
setState(5879);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5876);
match(IF);
setState(5877);
match(NOT);
setState(5878);
match(EXISTS);
}
}
setState(5881);
((CreateStorageVaultContext)_localctx).name = identifierOrText();
setState(5883);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,783,_ctx) ) {
case 1:
{
setState(5882);
((CreateStorageVaultContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 12:
_localctx = new CreateWorkloadGroupContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(5885);
match(CREATE);
setState(5886);
match(WORKLOAD);
setState(5887);
match(GROUP);
setState(5891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5888);
match(IF);
setState(5889);
match(NOT);
setState(5890);
match(EXISTS);
}
}
setState(5893);
((CreateWorkloadGroupContext)_localctx).name = identifierOrText();
setState(5895);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,785,_ctx) ) {
case 1:
{
setState(5894);
((CreateWorkloadGroupContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 13:
_localctx = new CreateWorkloadPolicyContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(5897);
match(CREATE);
setState(5898);
match(WORKLOAD);
setState(5899);
match(POLICY);
setState(5903);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5900);
match(IF);
setState(5901);
match(NOT);
setState(5902);
match(EXISTS);
}
}
setState(5905);
((CreateWorkloadPolicyContext)_localctx).name = identifierOrText();
setState(5911);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,787,_ctx) ) {
case 1:
{
setState(5906);
match(CONDITIONS);
setState(5907);
match(LEFT_PAREN);
setState(5908);
workloadPolicyConditions();
setState(5909);
match(RIGHT_PAREN);
}
break;
}
setState(5918);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,788,_ctx) ) {
case 1:
{
setState(5913);
match(ACTIONS);
setState(5914);
match(LEFT_PAREN);
setState(5915);
workloadPolicyActions();
setState(5916);
match(RIGHT_PAREN);
}
break;
}
setState(5921);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,789,_ctx) ) {
case 1:
{
setState(5920);
((CreateWorkloadPolicyContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 14:
_localctx = new CreateEncryptkeyContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(5923);
match(CREATE);
setState(5924);
match(ENCRYPTKEY);
setState(5928);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5925);
match(IF);
setState(5926);
match(NOT);
setState(5927);
match(EXISTS);
}
}
setState(5930);
multipartIdentifier();
setState(5931);
match(AS);
setState(5932);
match(STRING_LITERAL);
}
break;
case 15:
_localctx = new CreateSqlBlockRuleContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(5934);
match(CREATE);
setState(5935);
match(SQL_BLOCK_RULE);
setState(5939);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5936);
match(IF);
setState(5937);
match(NOT);
setState(5938);
match(EXISTS);
}
}
setState(5941);
((CreateSqlBlockRuleContext)_localctx).name = identifier();
setState(5943);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,792,_ctx) ) {
case 1:
{
setState(5942);
((CreateSqlBlockRuleContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 16:
_localctx = new CreateStoragePolicyContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(5945);
match(CREATE);
setState(5946);
match(STORAGE);
setState(5947);
match(POLICY);
setState(5951);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5948);
match(IF);
setState(5949);
match(NOT);
setState(5950);
match(EXISTS);
}
}
setState(5953);
((CreateStoragePolicyContext)_localctx).name = identifier();
setState(5955);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,794,_ctx) ) {
case 1:
{
setState(5954);
((CreateStoragePolicyContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
case 17:
_localctx = new BuildIndexContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(5957);
match(BUILD);
setState(5958);
match(INDEX);
setState(5959);
((BuildIndexContext)_localctx).name = identifier();
setState(5960);
match(ON);
setState(5961);
((BuildIndexContext)_localctx).tableName = multipartIdentifier();
setState(5963);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,795,_ctx) ) {
case 1:
{
setState(5962);
partitionSpec();
}
break;
}
}
break;
case 18:
_localctx = new CreateStageContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(5965);
match(CREATE);
setState(5966);
match(STAGE);
setState(5970);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(5967);
match(IF);
setState(5968);
match(NOT);
setState(5969);
match(EXISTS);
}
}
setState(5972);
((CreateStageContext)_localctx).name = identifier();
setState(5974);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,797,_ctx) ) {
case 1:
{
setState(5973);
((CreateStageContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WorkloadPolicyActionsContext extends ParserRuleContext {
public List<WorkloadPolicyActionContext> workloadPolicyAction() {
return getRuleContexts(WorkloadPolicyActionContext.class);
}
public WorkloadPolicyActionContext workloadPolicyAction(int i) {
return getRuleContext(WorkloadPolicyActionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public WorkloadPolicyActionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_workloadPolicyActions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWorkloadPolicyActions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWorkloadPolicyActions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWorkloadPolicyActions(this);
else return visitor.visitChildren(this);
}
}
public final WorkloadPolicyActionsContext workloadPolicyActions() throws RecognitionException {
WorkloadPolicyActionsContext _localctx = new WorkloadPolicyActionsContext(_ctx, getState());
enterRule(_localctx, 390, RULE_workloadPolicyActions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5978);
workloadPolicyAction();
setState(5983);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(5979);
match(COMMA);
setState(5980);
workloadPolicyAction();
}
}
setState(5985);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WorkloadPolicyActionContext extends ParserRuleContext {
public TerminalNode SET_SESSION_VARIABLE() { return getToken(PLParser.SET_SESSION_VARIABLE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public WorkloadPolicyActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_workloadPolicyAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWorkloadPolicyAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWorkloadPolicyAction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWorkloadPolicyAction(this);
else return visitor.visitChildren(this);
}
}
public final WorkloadPolicyActionContext workloadPolicyAction() throws RecognitionException {
WorkloadPolicyActionContext _localctx = new WorkloadPolicyActionContext(_ctx, getState());
enterRule(_localctx, 392, RULE_workloadPolicyAction);
int _la;
try {
setState(5992);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,801,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(5986);
match(SET_SESSION_VARIABLE);
setState(5987);
match(STRING_LITERAL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(5988);
identifier();
setState(5990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING_LITERAL) {
{
setState(5989);
match(STRING_LITERAL);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WorkloadPolicyConditionsContext extends ParserRuleContext {
public List<WorkloadPolicyConditionContext> workloadPolicyCondition() {
return getRuleContexts(WorkloadPolicyConditionContext.class);
}
public WorkloadPolicyConditionContext workloadPolicyCondition(int i) {
return getRuleContext(WorkloadPolicyConditionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public WorkloadPolicyConditionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_workloadPolicyConditions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWorkloadPolicyConditions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWorkloadPolicyConditions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWorkloadPolicyConditions(this);
else return visitor.visitChildren(this);
}
}
public final WorkloadPolicyConditionsContext workloadPolicyConditions() throws RecognitionException {
WorkloadPolicyConditionsContext _localctx = new WorkloadPolicyConditionsContext(_ctx, getState());
enterRule(_localctx, 394, RULE_workloadPolicyConditions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(5994);
workloadPolicyCondition();
setState(5999);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(5995);
match(COMMA);
setState(5996);
workloadPolicyCondition();
}
}
setState(6001);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WorkloadPolicyConditionContext extends ParserRuleContext {
public IdentifierContext metricName;
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public WorkloadPolicyConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_workloadPolicyCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWorkloadPolicyCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWorkloadPolicyCondition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWorkloadPolicyCondition(this);
else return visitor.visitChildren(this);
}
}
public final WorkloadPolicyConditionContext workloadPolicyCondition() throws RecognitionException {
WorkloadPolicyConditionContext _localctx = new WorkloadPolicyConditionContext(_ctx, getState());
enterRule(_localctx, 396, RULE_workloadPolicyCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(6002);
((WorkloadPolicyConditionContext)_localctx).metricName = identifier();
setState(6003);
comparisonOperator();
setState(6006);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUBTRACT:
case INTEGER_VALUE:
case EXPONENT_VALUE:
case DECIMAL_VALUE:
{
setState(6004);
number();
}
break;
case STRING_LITERAL:
{
setState(6005);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StorageBackendContext extends ParserRuleContext {
public IdentifierContext brokerName;
public PropertyClauseContext properties;
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode LOCATION() { return getToken(PLParser.LOCATION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public TerminalNode S3() { return getToken(PLParser.S3, 0); }
public TerminalNode HDFS() { return getToken(PLParser.HDFS, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public StorageBackendContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_storageBackend; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStorageBackend(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStorageBackend(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStorageBackend(this);
else return visitor.visitChildren(this);
}
}
public final StorageBackendContext storageBackend() throws RecognitionException {
StorageBackendContext _localctx = new StorageBackendContext(_ctx, getState());
enterRule(_localctx, 398, RULE_storageBackend);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6008);
_la = _input.LA(1);
if ( !(_la==BROKER || _la==HDFS || _la==LOCAL || _la==S3) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6010);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3927138875067072511L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731775120419L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761490469167143L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & 9222670387358137151L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -7342142259167539995L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305842422950835435L) != 0) || _la==IDENTIFIER || _la==BACKQUOTED_IDENTIFIER) {
{
setState(6009);
((StorageBackendContext)_localctx).brokerName = identifier();
}
}
setState(6012);
match(ON);
setState(6013);
match(LOCATION);
setState(6014);
match(STRING_LITERAL);
setState(6016);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,805,_ctx) ) {
case 1:
{
setState(6015);
((StorageBackendContext)_localctx).properties = propertyClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PasswordOptionContext extends ParserRuleContext {
public Token historyDefault;
public Token historyValue;
public Token expireDefault;
public Token expireNever;
public Token expireValue;
public Token expireTimeUnit;
public Token reuseDefault;
public Token reuseValue;
public Token attemptsValue;
public Token lockUnbounded;
public Token lockValue;
public Token lockTimeUint;
public TerminalNode PASSWORD_HISTORY() { return getToken(PLParser.PASSWORD_HISTORY, 0); }
public TerminalNode PASSWORD_EXPIRE() { return getToken(PLParser.PASSWORD_EXPIRE, 0); }
public TerminalNode PASSWORD_REUSE() { return getToken(PLParser.PASSWORD_REUSE, 0); }
public List<TerminalNode> INTERVAL() { return getTokens(PLParser.INTERVAL); }
public TerminalNode INTERVAL(int i) {
return getToken(PLParser.INTERVAL, i);
}
public TerminalNode FAILED_LOGIN_ATTEMPTS() { return getToken(PLParser.FAILED_LOGIN_ATTEMPTS, 0); }
public TerminalNode PASSWORD_LOCK_TIME() { return getToken(PLParser.PASSWORD_LOCK_TIME, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public TerminalNode ACCOUNT_LOCK() { return getToken(PLParser.ACCOUNT_LOCK, 0); }
public TerminalNode ACCOUNT_UNLOCK() { return getToken(PLParser.ACCOUNT_UNLOCK, 0); }
public List<TerminalNode> DAY() { return getTokens(PLParser.DAY); }
public TerminalNode DAY(int i) {
return getToken(PLParser.DAY, i);
}
public List<TerminalNode> DEFAULT() { return getTokens(PLParser.DEFAULT); }
public TerminalNode DEFAULT(int i) {
return getToken(PLParser.DEFAULT, i);
}
public TerminalNode NEVER() { return getToken(PLParser.NEVER, 0); }
public TerminalNode UNBOUNDED() { return getToken(PLParser.UNBOUNDED, 0); }
public List<TerminalNode> HOUR() { return getTokens(PLParser.HOUR); }
public TerminalNode HOUR(int i) {
return getToken(PLParser.HOUR, i);
}
public List<TerminalNode> SECOND() { return getTokens(PLParser.SECOND); }
public TerminalNode SECOND(int i) {
return getToken(PLParser.SECOND, i);
}
public PasswordOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_passwordOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPasswordOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPasswordOption(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPasswordOption(this);
else return visitor.visitChildren(this);
}
}
public final PasswordOptionContext passwordOption() throws RecognitionException {
PasswordOptionContext _localctx = new PasswordOptionContext(_ctx, getState());
enterRule(_localctx, 400, RULE_passwordOption);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6023);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,807,_ctx) ) {
case 1:
{
setState(6018);
match(PASSWORD_HISTORY);
setState(6021);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
{
setState(6019);
((PasswordOptionContext)_localctx).historyDefault = match(DEFAULT);
}
break;
case INTEGER_VALUE:
{
setState(6020);
((PasswordOptionContext)_localctx).historyValue = match(INTEGER_VALUE);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
setState(6033);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,809,_ctx) ) {
case 1:
{
setState(6025);
match(PASSWORD_EXPIRE);
setState(6031);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
{
setState(6026);
((PasswordOptionContext)_localctx).expireDefault = match(DEFAULT);
}
break;
case NEVER:
{
setState(6027);
((PasswordOptionContext)_localctx).expireNever = match(NEVER);
}
break;
case INTERVAL:
{
setState(6028);
match(INTERVAL);
setState(6029);
((PasswordOptionContext)_localctx).expireValue = match(INTEGER_VALUE);
setState(6030);
((PasswordOptionContext)_localctx).expireTimeUnit = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DAY || _la==HOUR || _la==SECOND) ) {
((PasswordOptionContext)_localctx).expireTimeUnit = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
setState(6042);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,811,_ctx) ) {
case 1:
{
setState(6035);
match(PASSWORD_REUSE);
setState(6036);
match(INTERVAL);
setState(6040);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
{
setState(6037);
((PasswordOptionContext)_localctx).reuseDefault = match(DEFAULT);
}
break;
case INTEGER_VALUE:
{
setState(6038);
((PasswordOptionContext)_localctx).reuseValue = match(INTEGER_VALUE);
setState(6039);
match(DAY);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
setState(6046);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,812,_ctx) ) {
case 1:
{
setState(6044);
match(FAILED_LOGIN_ATTEMPTS);
setState(6045);
((PasswordOptionContext)_localctx).attemptsValue = match(INTEGER_VALUE);
}
break;
}
setState(6054);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,814,_ctx) ) {
case 1:
{
setState(6048);
match(PASSWORD_LOCK_TIME);
setState(6052);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNBOUNDED:
{
setState(6049);
((PasswordOptionContext)_localctx).lockUnbounded = match(UNBOUNDED);
}
break;
case INTEGER_VALUE:
{
setState(6050);
((PasswordOptionContext)_localctx).lockValue = match(INTEGER_VALUE);
setState(6051);
((PasswordOptionContext)_localctx).lockTimeUint = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DAY || _la==HOUR || _la==SECOND) ) {
((PasswordOptionContext)_localctx).lockTimeUint = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
setState(6057);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,815,_ctx) ) {
case 1:
{
setState(6056);
_la = _input.LA(1);
if ( !(_la==ACCOUNT_LOCK || _la==ACCOUNT_UNLOCK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionArgumentsContext extends ParserRuleContext {
public List<FunctionArgumentContext> functionArgument() {
return getRuleContexts(FunctionArgumentContext.class);
}
public FunctionArgumentContext functionArgument(int i) {
return getRuleContext(FunctionArgumentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public FunctionArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionArguments(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionArguments(this);
else return visitor.visitChildren(this);
}
}
public final FunctionArgumentsContext functionArguments() throws RecognitionException {
FunctionArgumentsContext _localctx = new FunctionArgumentsContext(_ctx, getState());
enterRule(_localctx, 402, RULE_functionArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6059);
functionArgument();
setState(6064);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6060);
match(COMMA);
setState(6061);
functionArgument();
}
}
setState(6066);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionArgumentContext extends ParserRuleContext {
public TerminalNode DOTDOTDOT() { return getToken(PLParser.DOTDOTDOT, 0); }
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public FunctionArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionArgument(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionArgument(this);
else return visitor.visitChildren(this);
}
}
public final FunctionArgumentContext functionArgument() throws RecognitionException {
FunctionArgumentContext _localctx = new FunctionArgumentContext(_ctx, getState());
enterRule(_localctx, 404, RULE_functionArgument);
try {
setState(6069);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOTDOTDOT:
enterOuterAlt(_localctx, 1);
{
setState(6067);
match(DOTDOTDOT);
}
break;
case AGG_STATE:
case ALL:
case ARRAY:
case BIGINT:
case BITMAP:
case BOOLEAN:
case CHAR:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DOUBLE:
case FLOAT:
case HLL:
case INT:
case INTEGER:
case IPV4:
case IPV6:
case JSON:
case JSONB:
case LARGEINT:
case MAP:
case QUANTILE_STATE:
case SMALLINT:
case STRING:
case STRUCT:
case TEXT:
case TIME:
case TINYINT:
case VARCHAR:
case VARIANT:
enterOuterAlt(_localctx, 2);
{
setState(6068);
dataType();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedSetStatementContext extends ParserRuleContext {
public UnsupportedSetStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedSetStatement; }
public UnsupportedSetStatementContext() { }
public void copyFrom(UnsupportedSetStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetTransactionContext extends UnsupportedSetStatementContext {
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public TransactionAccessModeContext transactionAccessMode() {
return getRuleContext(TransactionAccessModeContext.class,0);
}
public IsolationLevelContext isolationLevel() {
return getRuleContext(IsolationLevelContext.class,0);
}
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public SetTransactionContext(UnsupportedSetStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetTransaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetTransaction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetTransaction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetUserPropertiesContext extends UnsupportedSetStatementContext {
public IdentifierOrTextContext user;
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode PROPERTY() { return getToken(PLParser.PROPERTY, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public SetUserPropertiesContext(UnsupportedSetStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetUserProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetUserProperties(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetUserProperties(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetDefaultStorageVaultContext extends UnsupportedSetStatementContext {
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public SetDefaultStorageVaultContext(UnsupportedSetStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetDefaultStorageVault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetDefaultStorageVault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetDefaultStorageVault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetOptionsContext extends UnsupportedSetStatementContext {
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public List<OptionWithTypeContext> optionWithType() {
return getRuleContexts(OptionWithTypeContext.class);
}
public OptionWithTypeContext optionWithType(int i) {
return getRuleContext(OptionWithTypeContext.class,i);
}
public List<OptionWithoutTypeContext> optionWithoutType() {
return getRuleContexts(OptionWithoutTypeContext.class);
}
public OptionWithoutTypeContext optionWithoutType(int i) {
return getRuleContext(OptionWithoutTypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public SetOptionsContext(UnsupportedSetStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetOptions(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetOptions(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedSetStatementContext unsupportedSetStatement() throws RecognitionException {
UnsupportedSetStatementContext _localctx = new UnsupportedSetStatementContext(_ctx, getState());
enterRule(_localctx, 406, RULE_unsupportedSetStatement);
int _la;
try {
int _alt;
setState(6117);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,824,_ctx) ) {
case 1:
_localctx = new SetOptionsContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6071);
match(SET);
setState(6074);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,818,_ctx) ) {
case 1:
{
setState(6072);
optionWithType();
}
break;
case 2:
{
setState(6073);
optionWithoutType();
}
break;
}
setState(6083);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,820,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6076);
match(COMMA);
setState(6079);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,819,_ctx) ) {
case 1:
{
setState(6077);
optionWithType();
}
break;
case 2:
{
setState(6078);
optionWithoutType();
}
break;
}
}
}
}
setState(6085);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,820,_ctx);
}
}
break;
case 2:
_localctx = new SetDefaultStorageVaultContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6086);
match(SET);
setState(6087);
identifier();
setState(6088);
match(AS);
setState(6089);
match(DEFAULT);
setState(6090);
match(STORAGE);
setState(6091);
match(VAULT);
}
break;
case 3:
_localctx = new SetUserPropertiesContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(6093);
match(SET);
setState(6094);
match(PROPERTY);
setState(6097);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(6095);
match(FOR);
setState(6096);
((SetUserPropertiesContext)_localctx).user = identifierOrText();
}
}
setState(6099);
propertyItemList();
}
break;
case 4:
_localctx = new SetTransactionContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(6100);
match(SET);
setState(6102);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(6101);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(6104);
match(TRANSACTION);
setState(6115);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,823,_ctx) ) {
case 1:
{
setState(6105);
transactionAccessMode();
}
break;
case 2:
{
setState(6106);
isolationLevel();
}
break;
case 3:
{
setState(6107);
transactionAccessMode();
setState(6108);
match(COMMA);
setState(6109);
isolationLevel();
}
break;
case 4:
{
setState(6111);
isolationLevel();
setState(6112);
match(COMMA);
setState(6113);
transactionAccessMode();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OptionWithTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public OptionWithTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionWithType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOptionWithType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOptionWithType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOptionWithType(this);
else return visitor.visitChildren(this);
}
}
public final OptionWithTypeContext optionWithType() throws RecognitionException {
OptionWithTypeContext _localctx = new OptionWithTypeContext(_ctx, getState());
enterRule(_localctx, 408, RULE_optionWithType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6119);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6120);
identifier();
setState(6121);
match(EQ);
setState(6124);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_PAREN:
case LEFT_BRACKET:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case ADD:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BINARY:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATABASE:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXISTS:
case EXPIRED:
case EXTERNAL:
case EXTRACT:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IF:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEY:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LEFT:
case LESS:
case LEVEL:
case LIKE:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NOT:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLACEHOLDER:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REGEXP:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RIGHT:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case ASTERISK:
case TILDE:
case LOGICALNOT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case ATSIGN:
case DOUBLEATSIGN:
case STRING_LITERAL:
case INTEGER_VALUE:
case EXPONENT_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6122);
expression();
}
break;
case DEFAULT:
{
setState(6123);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OptionWithoutTypeContext extends ParserRuleContext {
public OptionWithoutTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionWithoutType; }
public OptionWithoutTypeContext() { }
public void copyFrom(OptionWithoutTypeContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetNamesContext extends OptionWithoutTypeContext {
public TerminalNode NAMES() { return getToken(PLParser.NAMES, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SetNamesContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetNames(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetNames(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetNames(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetCharsetContext extends OptionWithoutTypeContext {
public IdentifierOrTextContext charsetName;
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode CHARSET() { return getToken(PLParser.CHARSET, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public SetCharsetContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetCharset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetCharset(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetCharset(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetCollateContext extends OptionWithoutTypeContext {
public IdentifierOrTextContext charsetName;
public IdentifierOrTextContext collateName;
public TerminalNode NAMES() { return getToken(PLParser.NAMES, 0); }
public List<TerminalNode> DEFAULT() { return getTokens(PLParser.DEFAULT); }
public TerminalNode DEFAULT(int i) {
return getToken(PLParser.DEFAULT, i);
}
public List<IdentifierOrTextContext> identifierOrText() {
return getRuleContexts(IdentifierOrTextContext.class);
}
public IdentifierOrTextContext identifierOrText(int i) {
return getRuleContext(IdentifierOrTextContext.class,i);
}
public TerminalNode COLLATE() { return getToken(PLParser.COLLATE, 0); }
public SetCollateContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetCollate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetCollate(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetCollate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetPasswordContext extends OptionWithoutTypeContext {
public List<TerminalNode> PASSWORD() { return getTokens(PLParser.PASSWORD); }
public TerminalNode PASSWORD(int i) {
return getToken(PLParser.PASSWORD, i);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SetPasswordContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetPassword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetPassword(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetPassword(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetVariableWithoutTypeContext extends OptionWithoutTypeContext {
public VariableContext variable() {
return getRuleContext(VariableContext.class,0);
}
public SetVariableWithoutTypeContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetVariableWithoutType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetVariableWithoutType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetVariableWithoutType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetLdapAdminPasswordContext extends OptionWithoutTypeContext {
public TerminalNode LDAP_ADMIN_PASSWORD() { return getToken(PLParser.LDAP_ADMIN_PASSWORD, 0); }
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode PASSWORD() { return getToken(PLParser.PASSWORD, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SetLdapAdminPasswordContext(OptionWithoutTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetLdapAdminPassword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetLdapAdminPassword(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetLdapAdminPassword(this);
else return visitor.visitChildren(this);
}
}
public final OptionWithoutTypeContext optionWithoutType() throws RecognitionException {
OptionWithoutTypeContext _localctx = new OptionWithoutTypeContext(_ctx, getState());
enterRule(_localctx, 410, RULE_optionWithoutType);
int _la;
try {
setState(6171);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,833,_ctx) ) {
case 1:
_localctx = new SetNamesContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6126);
match(NAMES);
setState(6127);
match(EQ);
setState(6128);
expression();
}
break;
case 2:
_localctx = new SetCharsetContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6132);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHAR:
{
setState(6129);
match(CHAR);
setState(6130);
match(SET);
}
break;
case CHARSET:
{
setState(6131);
match(CHARSET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(6136);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6134);
((SetCharsetContext)_localctx).charsetName = identifierOrText();
}
break;
case DEFAULT:
{
setState(6135);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 3:
_localctx = new SetCollateContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(6138);
match(NAMES);
setState(6141);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6139);
((SetCollateContext)_localctx).charsetName = identifierOrText();
}
break;
case DEFAULT:
{
setState(6140);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(6146);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,829,_ctx) ) {
case 1:
{
setState(6143);
match(COLLATE);
setState(6144);
((SetCollateContext)_localctx).collateName = identifierOrText();
}
break;
case 2:
{
setState(6145);
match(DEFAULT);
}
break;
}
}
break;
case 4:
_localctx = new SetPasswordContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(6148);
match(PASSWORD);
setState(6151);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(6149);
match(FOR);
setState(6150);
userIdentify();
}
}
setState(6153);
match(EQ);
setState(6159);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(6154);
match(STRING_LITERAL);
}
break;
case PASSWORD:
{
{
setState(6155);
match(PASSWORD);
setState(6156);
match(LEFT_PAREN);
setState(6157);
match(STRING_LITERAL);
setState(6158);
match(RIGHT_PAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 5:
_localctx = new SetLdapAdminPasswordContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(6161);
match(LDAP_ADMIN_PASSWORD);
setState(6162);
match(EQ);
setState(6168);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(6163);
match(STRING_LITERAL);
}
break;
case PASSWORD:
{
{
setState(6164);
match(PASSWORD);
setState(6165);
match(LEFT_PAREN);
setState(6166);
match(STRING_LITERAL);
setState(6167);
match(RIGHT_PAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 6:
_localctx = new SetVariableWithoutTypeContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(6170);
variable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariableContext extends ParserRuleContext {
public VariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variable; }
public VariableContext() { }
public void copyFrom(VariableContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetUserVariableContext extends VariableContext {
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SetUserVariableContext(VariableContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetUserVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetUserVariable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetUserVariable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetSystemVariableContext extends VariableContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode DOUBLEATSIGN() { return getToken(PLParser.DOUBLEATSIGN, 0); }
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public SetSystemVariableContext(VariableContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetSystemVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetSystemVariable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetSystemVariable(this);
else return visitor.visitChildren(this);
}
}
public final VariableContext variable() throws RecognitionException {
VariableContext _localctx = new VariableContext(_ctx, getState());
enterRule(_localctx, 412, RULE_variable);
int _la;
try {
setState(6191);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case DOUBLEATSIGN:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
_localctx = new SetSystemVariableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6178);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOUBLEATSIGN) {
{
setState(6173);
match(DOUBLEATSIGN);
setState(6176);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,834,_ctx) ) {
case 1:
{
setState(6174);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6175);
match(DOT);
}
break;
}
}
}
setState(6180);
identifier();
setState(6181);
match(EQ);
setState(6184);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_PAREN:
case LEFT_BRACKET:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case ADD:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BINARY:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATABASE:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXISTS:
case EXPIRED:
case EXTERNAL:
case EXTRACT:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IF:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEY:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LEFT:
case LESS:
case LEVEL:
case LIKE:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NOT:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLACEHOLDER:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REGEXP:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RIGHT:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case ASTERISK:
case TILDE:
case LOGICALNOT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case ATSIGN:
case DOUBLEATSIGN:
case STRING_LITERAL:
case INTEGER_VALUE:
case EXPONENT_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6182);
expression();
}
break;
case DEFAULT:
{
setState(6183);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case ATSIGN:
_localctx = new SetUserVariableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6186);
match(ATSIGN);
setState(6187);
identifier();
setState(6188);
match(EQ);
setState(6189);
expression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TransactionAccessModeContext extends ParserRuleContext {
public TerminalNode READ() { return getToken(PLParser.READ, 0); }
public TerminalNode ONLY() { return getToken(PLParser.ONLY, 0); }
public TerminalNode WRITE() { return getToken(PLParser.WRITE, 0); }
public TransactionAccessModeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transactionAccessMode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTransactionAccessMode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTransactionAccessMode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTransactionAccessMode(this);
else return visitor.visitChildren(this);
}
}
public final TransactionAccessModeContext transactionAccessMode() throws RecognitionException {
TransactionAccessModeContext _localctx = new TransactionAccessModeContext(_ctx, getState());
enterRule(_localctx, 414, RULE_transactionAccessMode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6193);
match(READ);
setState(6194);
_la = _input.LA(1);
if ( !(_la==ONLY || _la==WRITE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IsolationLevelContext extends ParserRuleContext {
public TerminalNode ISOLATION() { return getToken(PLParser.ISOLATION, 0); }
public TerminalNode LEVEL() { return getToken(PLParser.LEVEL, 0); }
public TerminalNode READ() { return getToken(PLParser.READ, 0); }
public TerminalNode UNCOMMITTED() { return getToken(PLParser.UNCOMMITTED, 0); }
public TerminalNode COMMITTED() { return getToken(PLParser.COMMITTED, 0); }
public TerminalNode REPEATABLE() { return getToken(PLParser.REPEATABLE, 0); }
public TerminalNode SERIALIZABLE() { return getToken(PLParser.SERIALIZABLE, 0); }
public IsolationLevelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_isolationLevel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIsolationLevel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIsolationLevel(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIsolationLevel(this);
else return visitor.visitChildren(this);
}
}
public final IsolationLevelContext isolationLevel() throws RecognitionException {
IsolationLevelContext _localctx = new IsolationLevelContext(_ctx, getState());
enterRule(_localctx, 416, RULE_isolationLevel);
try {
enterOuterAlt(_localctx, 1);
{
setState(6196);
match(ISOLATION);
setState(6197);
match(LEVEL);
setState(6205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,838,_ctx) ) {
case 1:
{
{
setState(6198);
match(READ);
setState(6199);
match(UNCOMMITTED);
}
}
break;
case 2:
{
{
setState(6200);
match(READ);
setState(6201);
match(COMMITTED);
}
}
break;
case 3:
{
{
setState(6202);
match(REPEATABLE);
setState(6203);
match(READ);
}
}
break;
case 4:
{
{
setState(6204);
match(SERIALIZABLE);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupoortedUnsetStatementContext extends ParserRuleContext {
public TerminalNode UNSET() { return getToken(PLParser.UNSET, 0); }
public TerminalNode VARIABLE() { return getToken(PLParser.VARIABLE, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public UnsupoortedUnsetStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupoortedUnsetStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnsupoortedUnsetStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnsupoortedUnsetStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnsupoortedUnsetStatement(this);
else return visitor.visitChildren(this);
}
}
public final UnsupoortedUnsetStatementContext unsupoortedUnsetStatement() throws RecognitionException {
UnsupoortedUnsetStatementContext _localctx = new UnsupoortedUnsetStatementContext(_ctx, getState());
enterRule(_localctx, 418, RULE_unsupoortedUnsetStatement);
int _la;
try {
setState(6220);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,841,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6207);
match(UNSET);
setState(6209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==LOCAL || _la==SESSION) {
{
setState(6208);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(6211);
match(VARIABLE);
setState(6214);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(6212);
match(ALL);
}
break;
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6213);
identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6216);
match(UNSET);
setState(6217);
match(DEFAULT);
setState(6218);
match(STORAGE);
setState(6219);
match(VAULT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedUseStatementContext extends ParserRuleContext {
public UnsupportedUseStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedUseStatement; }
public UnsupportedUseStatementContext() { }
public void copyFrom(UnsupportedUseStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UseCloudClusterContext extends UnsupportedUseStatementContext {
public IdentifierContext catalog;
public IdentifierContext database;
public IdentifierContext cluster;
public TerminalNode USE() { return getToken(PLParser.USE, 0); }
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public UseCloudClusterContext(UnsupportedUseStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUseCloudCluster(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUseCloudCluster(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUseCloudCluster(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UseDatabaseContext extends UnsupportedUseStatementContext {
public IdentifierContext catalog;
public IdentifierContext database;
public TerminalNode USE() { return getToken(PLParser.USE, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public UseDatabaseContext(UnsupportedUseStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUseDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUseDatabase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUseDatabase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SwitchCatalogContext extends UnsupportedUseStatementContext {
public IdentifierContext catalog;
public TerminalNode SWITCH() { return getToken(PLParser.SWITCH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SwitchCatalogContext(UnsupportedUseStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSwitchCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSwitchCatalog(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSwitchCatalog(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedUseStatementContext unsupportedUseStatement() throws RecognitionException {
UnsupportedUseStatementContext _localctx = new UnsupportedUseStatementContext(_ctx, getState());
enterRule(_localctx, 420, RULE_unsupportedUseStatement);
int _la;
try {
setState(6242);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,845,_ctx) ) {
case 1:
_localctx = new UseDatabaseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6222);
match(USE);
setState(6226);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,842,_ctx) ) {
case 1:
{
setState(6223);
((UseDatabaseContext)_localctx).catalog = identifier();
setState(6224);
match(DOT);
}
break;
}
setState(6228);
((UseDatabaseContext)_localctx).database = identifier();
}
break;
case 2:
_localctx = new UseCloudClusterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6229);
match(USE);
setState(6236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3927138875067072511L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731775120419L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761490469167143L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & 9222670387358137151L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -7342142259167539995L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305842422950835435L) != 0) || _la==IDENTIFIER || _la==BACKQUOTED_IDENTIFIER) {
{
setState(6233);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,843,_ctx) ) {
case 1:
{
setState(6230);
((UseCloudClusterContext)_localctx).catalog = identifier();
setState(6231);
match(DOT);
}
break;
}
setState(6235);
((UseCloudClusterContext)_localctx).database = identifier();
}
}
setState(6238);
match(ATSIGN);
setState(6239);
((UseCloudClusterContext)_localctx).cluster = identifier();
}
break;
case 3:
_localctx = new SwitchCatalogContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(6240);
match(SWITCH);
setState(6241);
((SwitchCatalogContext)_localctx).catalog = identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedDmlStatementContext extends ParserRuleContext {
public UnsupportedDmlStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedDmlStatement; }
public UnsupportedDmlStatementContext() { }
public void copyFrom(UnsupportedDmlStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CopyIntoContext extends UnsupportedDmlStatementContext {
public MultipartIdentifierContext name;
public IdentifierListContext columns;
public PropertyClauseContext properties;
public TerminalNode COPY() { return getToken(PLParser.COPY, 0); }
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public List<TerminalNode> FROM() { return getTokens(PLParser.FROM); }
public TerminalNode FROM(int i) {
return getToken(PLParser.FROM, i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public StageAndPatternContext stageAndPattern() {
return getRuleContext(StageAndPatternContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode SELECT() { return getToken(PLParser.SELECT, 0); }
public SelectColumnClauseContext selectColumnClause() {
return getRuleContext(SelectColumnClauseContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public CopyIntoContext(UnsupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCopyInto(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCopyInto(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCopyInto(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TruncateTableContext extends UnsupportedDmlStatementContext {
public TerminalNode TRUNCATE() { return getToken(PLParser.TRUNCATE, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public SpecifiedPartitionContext specifiedPartition() {
return getRuleContext(SpecifiedPartitionContext.class,0);
}
public TruncateTableContext(UnsupportedDmlStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTruncateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTruncateTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTruncateTable(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedDmlStatementContext unsupportedDmlStatement() throws RecognitionException {
UnsupportedDmlStatementContext _localctx = new UnsupportedDmlStatementContext(_ctx, getState());
enterRule(_localctx, 422, RULE_unsupportedDmlStatement);
int _la;
try {
setState(6273);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TRUNCATE:
_localctx = new TruncateTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6244);
match(TRUNCATE);
setState(6245);
match(TABLE);
setState(6246);
multipartIdentifier();
setState(6248);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,846,_ctx) ) {
case 1:
{
setState(6247);
specifiedPartition();
}
break;
}
}
break;
case COPY:
_localctx = new CopyIntoContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6250);
match(COPY);
setState(6251);
match(INTO);
setState(6252);
((CopyIntoContext)_localctx).name = multipartIdentifier();
setState(6254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(6253);
((CopyIntoContext)_localctx).columns = identifierList();
}
}
setState(6256);
match(FROM);
setState(6268);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATSIGN:
{
setState(6257);
stageAndPattern();
}
break;
case LEFT_PAREN:
{
{
setState(6258);
match(LEFT_PAREN);
setState(6259);
match(SELECT);
setState(6260);
selectColumnClause();
setState(6261);
match(FROM);
setState(6262);
stageAndPattern();
setState(6264);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(6263);
whereClause();
}
}
setState(6266);
match(RIGHT_PAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(6271);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,850,_ctx) ) {
case 1:
{
setState(6270);
((CopyIntoContext)_localctx).properties = propertyClause();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StageAndPatternContext extends ParserRuleContext {
public IdentifierContext stage;
public Token pattern;
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public TerminalNode TILDE() { return getToken(PLParser.TILDE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public StageAndPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stageAndPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStageAndPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStageAndPattern(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStageAndPattern(this);
else return visitor.visitChildren(this);
}
}
public final StageAndPatternContext stageAndPattern() throws RecognitionException {
StageAndPatternContext _localctx = new StageAndPatternContext(_ctx, getState());
enterRule(_localctx, 424, RULE_stageAndPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(6275);
match(ATSIGN);
setState(6278);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6276);
((StageAndPatternContext)_localctx).stage = identifier();
}
break;
case TILDE:
{
setState(6277);
match(TILDE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(6283);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,853,_ctx) ) {
case 1:
{
setState(6280);
match(LEFT_PAREN);
setState(6281);
((StageAndPatternContext)_localctx).pattern = match(STRING_LITERAL);
setState(6282);
match(RIGHT_PAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsupportedDescribeStatementContext extends ParserRuleContext {
public UnsupportedDescribeStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedDescribeStatement; }
public UnsupportedDescribeStatementContext() { }
public void copyFrom(UnsupportedDescribeStatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DescribeTableValuedFunctionContext extends UnsupportedDescribeStatementContext {
public IdentifierContext tvfName;
public PropertyItemListContext properties;
public ExplainCommandContext explainCommand() {
return getRuleContext(ExplainCommandContext.class,0);
}
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public DescribeTableValuedFunctionContext(UnsupportedDescribeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDescribeTableValuedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDescribeTableValuedFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDescribeTableValuedFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DescribeTableContext extends UnsupportedDescribeStatementContext {
public ExplainCommandContext explainCommand() {
return getRuleContext(ExplainCommandContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public SpecifiedPartitionContext specifiedPartition() {
return getRuleContext(SpecifiedPartitionContext.class,0);
}
public DescribeTableContext(UnsupportedDescribeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDescribeTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDescribeTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDescribeTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DescribeTableAllContext extends UnsupportedDescribeStatementContext {
public ExplainCommandContext explainCommand() {
return getRuleContext(ExplainCommandContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public DescribeTableAllContext(UnsupportedDescribeStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDescribeTableAll(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDescribeTableAll(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDescribeTableAll(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedDescribeStatementContext unsupportedDescribeStatement() throws RecognitionException {
UnsupportedDescribeStatementContext _localctx = new UnsupportedDescribeStatementContext(_ctx, getState());
enterRule(_localctx, 426, RULE_unsupportedDescribeStatement);
int _la;
try {
setState(6304);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,856,_ctx) ) {
case 1:
_localctx = new DescribeTableValuedFunctionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6285);
explainCommand();
setState(6286);
match(FUNCTION);
setState(6287);
((DescribeTableValuedFunctionContext)_localctx).tvfName = identifier();
setState(6288);
match(LEFT_PAREN);
setState(6290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3918131675812331519L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731842229283L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489932296231L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701645201671361L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -2730456240740152091L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305560947974124779L) != 0) || ((((_la - 714)) & ~0x3f) == 0 && ((1L << (_la - 714)) & 1761L) != 0)) {
{
setState(6289);
((DescribeTableValuedFunctionContext)_localctx).properties = propertyItemList();
}
}
setState(6292);
match(RIGHT_PAREN);
setState(6293);
tableAlias();
}
break;
case 2:
_localctx = new DescribeTableAllContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6295);
explainCommand();
setState(6296);
multipartIdentifier();
setState(6297);
match(ALL);
}
break;
case 3:
_localctx = new DescribeTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(6299);
explainCommand();
setState(6300);
multipartIdentifier();
setState(6302);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,855,_ctx) ) {
case 1:
{
setState(6301);
specifiedPartition();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstraintContext extends ParserRuleContext {
public IdentifierListContext slots;
public MultipartIdentifierContext referenceTable;
public IdentifierListContext referencedSlots;
public TerminalNode PRIMARY() { return getToken(PLParser.PRIMARY, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public TerminalNode UNIQUE() { return getToken(PLParser.UNIQUE, 0); }
public TerminalNode FOREIGN() { return getToken(PLParser.FOREIGN, 0); }
public TerminalNode REFERENCES() { return getToken(PLParser.REFERENCES, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitConstraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintContext constraint() throws RecognitionException {
ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
enterRule(_localctx, 428, RULE_constraint);
try {
setState(6318);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRIMARY:
enterOuterAlt(_localctx, 1);
{
setState(6306);
match(PRIMARY);
setState(6307);
match(KEY);
setState(6308);
((ConstraintContext)_localctx).slots = identifierList();
}
break;
case UNIQUE:
enterOuterAlt(_localctx, 2);
{
setState(6309);
match(UNIQUE);
setState(6310);
((ConstraintContext)_localctx).slots = identifierList();
}
break;
case FOREIGN:
enterOuterAlt(_localctx, 3);
{
setState(6311);
match(FOREIGN);
setState(6312);
match(KEY);
setState(6313);
((ConstraintContext)_localctx).slots = identifierList();
setState(6314);
match(REFERENCES);
setState(6315);
((ConstraintContext)_localctx).referenceTable = multipartIdentifier();
setState(6316);
((ConstraintContext)_localctx).referencedSlots = identifierList();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionSpecContext extends ParserRuleContext {
public IdentifierListContext partitions;
public ErrorCapturingIdentifierContext partition;
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode PARTITIONS() { return getToken(PLParser.PARTITIONS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PartitionSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionSpec(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionSpec(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecContext partitionSpec() throws RecognitionException {
PartitionSpecContext _localctx = new PartitionSpecContext(_ctx, getState());
enterRule(_localctx, 430, RULE_partitionSpec);
int _la;
try {
setState(6334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,860,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6321);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(6320);
match(TEMPORARY);
}
}
setState(6323);
_la = _input.LA(1);
if ( !(_la==PARTITION || _la==PARTITIONS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6324);
((PartitionSpecContext)_localctx).partitions = identifierList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6326);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(6325);
match(TEMPORARY);
}
}
setState(6328);
match(PARTITION);
setState(6329);
((PartitionSpecContext)_localctx).partition = errorCapturingIdentifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(6330);
_la = _input.LA(1);
if ( !(_la==PARTITION || _la==PARTITIONS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6331);
match(LEFT_PAREN);
setState(6332);
match(ASTERISK);
setState(6333);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionTableContext extends ParserRuleContext {
public Token autoPartition;
public IdentityOrFunctionListContext partitionList;
public PartitionsDefContext partitions;
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public IdentityOrFunctionListContext identityOrFunctionList() {
return getRuleContext(IdentityOrFunctionListContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public TerminalNode RANGE() { return getToken(PLParser.RANGE, 0); }
public TerminalNode LIST() { return getToken(PLParser.LIST, 0); }
public PartitionsDefContext partitionsDef() {
return getRuleContext(PartitionsDefContext.class,0);
}
public PartitionTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionTable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionTable(this);
else return visitor.visitChildren(this);
}
}
public final PartitionTableContext partitionTable() throws RecognitionException {
PartitionTableContext _localctx = new PartitionTableContext(_ctx, getState());
enterRule(_localctx, 432, RULE_partitionTable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(6337);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AUTO) {
{
setState(6336);
((PartitionTableContext)_localctx).autoPartition = match(AUTO);
}
}
setState(6339);
match(PARTITION);
setState(6340);
match(BY);
setState(6342);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIST || _la==RANGE) {
{
setState(6341);
_la = _input.LA(1);
if ( !(_la==LIST || _la==RANGE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(6344);
((PartitionTableContext)_localctx).partitionList = identityOrFunctionList();
{
setState(6345);
match(LEFT_PAREN);
setState(6347);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==PARTITION) {
{
setState(6346);
((PartitionTableContext)_localctx).partitions = partitionsDef();
}
}
setState(6349);
match(RIGHT_PAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentityOrFunctionListContext extends ParserRuleContext {
public IdentityOrFunctionContext identityOrFunction;
public List<IdentityOrFunctionContext> partitions = new ArrayList<IdentityOrFunctionContext>();
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<IdentityOrFunctionContext> identityOrFunction() {
return getRuleContexts(IdentityOrFunctionContext.class);
}
public IdentityOrFunctionContext identityOrFunction(int i) {
return getRuleContext(IdentityOrFunctionContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public IdentityOrFunctionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identityOrFunctionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentityOrFunctionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentityOrFunctionList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentityOrFunctionList(this);
else return visitor.visitChildren(this);
}
}
public final IdentityOrFunctionListContext identityOrFunctionList() throws RecognitionException {
IdentityOrFunctionListContext _localctx = new IdentityOrFunctionListContext(_ctx, getState());
enterRule(_localctx, 434, RULE_identityOrFunctionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6351);
match(LEFT_PAREN);
setState(6352);
identityOrFunction();
setState(6357);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6353);
match(COMMA);
setState(6354);
((IdentityOrFunctionListContext)_localctx).identityOrFunction = identityOrFunction();
((IdentityOrFunctionListContext)_localctx).partitions.add(((IdentityOrFunctionListContext)_localctx).identityOrFunction);
}
}
setState(6359);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6360);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentityOrFunctionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FunctionCallExpressionContext functionCallExpression() {
return getRuleContext(FunctionCallExpressionContext.class,0);
}
public IdentityOrFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identityOrFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentityOrFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentityOrFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentityOrFunction(this);
else return visitor.visitChildren(this);
}
}
public final IdentityOrFunctionContext identityOrFunction() throws RecognitionException {
IdentityOrFunctionContext _localctx = new IdentityOrFunctionContext(_ctx, getState());
enterRule(_localctx, 436, RULE_identityOrFunction);
try {
enterOuterAlt(_localctx, 1);
{
setState(6364);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,865,_ctx) ) {
case 1:
{
setState(6362);
identifier();
}
break;
case 2:
{
setState(6363);
functionCallExpression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DataDescContext extends ParserRuleContext {
public Token STRING_LITERAL;
public List<Token> filePaths = new ArrayList<Token>();
public List<Token> filePath = new ArrayList<Token>();
public IdentifierContext targetTableName;
public Token comma;
public Token separator;
public IdentifierOrTextContext format;
public IdentifierOrTextContext compressType;
public IdentifierListContext columns;
public ColFromPathContext columnsFromPath;
public ColMappingListContext columnMapping;
public PreFilterClauseContext preFilter;
public WhereClauseContext where;
public DeleteOnClauseContext deleteOn;
public SequenceColClauseContext sequenceColumn;
public IdentifierContext sourceTableName;
public IdentifierListContext partition;
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode INFILE() { return getToken(PLParser.INFILE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public List<TerminalNode> TABLE() { return getTokens(PLParser.TABLE); }
public TerminalNode TABLE(int i) {
return getToken(PLParser.TABLE, i);
}
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MergeTypeContext mergeType() {
return getRuleContext(MergeTypeContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public List<TerminalNode> TERMINATED() { return getTokens(PLParser.TERMINATED); }
public TerminalNode TERMINATED(int i) {
return getToken(PLParser.TERMINATED, i);
}
public List<TerminalNode> BY() { return getTokens(PLParser.BY); }
public TerminalNode BY(int i) {
return getToken(PLParser.BY, i);
}
public TerminalNode LINES() { return getToken(PLParser.LINES, 0); }
public TerminalNode FORMAT() { return getToken(PLParser.FORMAT, 0); }
public List<TerminalNode> AS() { return getTokens(PLParser.AS); }
public TerminalNode AS(int i) {
return getToken(PLParser.AS, i);
}
public TerminalNode COMPRESS_TYPE() { return getToken(PLParser.COMPRESS_TYPE, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public List<IdentifierOrTextContext> identifierOrText() {
return getRuleContexts(IdentifierOrTextContext.class);
}
public IdentifierOrTextContext identifierOrText(int i) {
return getRuleContext(IdentifierOrTextContext.class,i);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ColFromPathContext colFromPath() {
return getRuleContext(ColFromPathContext.class,0);
}
public ColMappingListContext colMappingList() {
return getRuleContext(ColMappingListContext.class,0);
}
public PreFilterClauseContext preFilterClause() {
return getRuleContext(PreFilterClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public DeleteOnClauseContext deleteOnClause() {
return getRuleContext(DeleteOnClauseContext.class,0);
}
public SequenceColClauseContext sequenceColClause() {
return getRuleContext(SequenceColClauseContext.class,0);
}
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public DataDescContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataDesc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDataDesc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDataDesc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDataDesc(this);
else return visitor.visitChildren(this);
}
}
public final DataDescContext dataDesc() throws RecognitionException {
DataDescContext _localctx = new DataDescContext(_ctx, getState());
enterRule(_localctx, 438, RULE_dataDesc);
int _la;
try {
setState(6465);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,889,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==APPEND || _la==DELETE || _la==MERGE || _la==WITH) {
{
setState(6367);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(6366);
match(WITH);
}
}
setState(6369);
mergeType();
}
}
setState(6372);
match(DATA);
setState(6373);
match(INFILE);
setState(6374);
match(LEFT_PAREN);
setState(6375);
((DataDescContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DataDescContext)_localctx).filePaths.add(((DataDescContext)_localctx).STRING_LITERAL);
setState(6380);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6376);
match(COMMA);
setState(6377);
((DataDescContext)_localctx).STRING_LITERAL = match(STRING_LITERAL);
((DataDescContext)_localctx).filePath.add(((DataDescContext)_localctx).STRING_LITERAL);
}
}
setState(6382);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6383);
match(RIGHT_PAREN);
setState(6384);
match(INTO);
setState(6385);
match(TABLE);
setState(6386);
((DataDescContext)_localctx).targetTableName = identifier();
setState(6388);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION || _la==PARTITIONS || _la==TEMPORARY) {
{
setState(6387);
partitionSpec();
}
}
setState(6394);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,870,_ctx) ) {
case 1:
{
setState(6390);
match(COLUMNS);
setState(6391);
match(TERMINATED);
setState(6392);
match(BY);
setState(6393);
((DataDescContext)_localctx).comma = match(STRING_LITERAL);
}
break;
}
setState(6400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LINES) {
{
setState(6396);
match(LINES);
setState(6397);
match(TERMINATED);
setState(6398);
match(BY);
setState(6399);
((DataDescContext)_localctx).separator = match(STRING_LITERAL);
}
}
setState(6405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FORMAT) {
{
setState(6402);
match(FORMAT);
setState(6403);
match(AS);
setState(6404);
((DataDescContext)_localctx).format = identifierOrText();
}
}
setState(6410);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMPRESS_TYPE) {
{
setState(6407);
match(COMPRESS_TYPE);
setState(6408);
match(AS);
setState(6409);
((DataDescContext)_localctx).compressType = identifierOrText();
}
}
setState(6413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(6412);
((DataDescContext)_localctx).columns = identifierList();
}
}
setState(6416);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLUMNS) {
{
setState(6415);
((DataDescContext)_localctx).columnsFromPath = colFromPath();
}
}
setState(6419);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SET) {
{
setState(6418);
((DataDescContext)_localctx).columnMapping = colMappingList();
}
}
setState(6422);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRECEDING) {
{
setState(6421);
((DataDescContext)_localctx).preFilter = preFilterClause();
}
}
setState(6425);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(6424);
((DataDescContext)_localctx).where = whereClause();
}
}
setState(6428);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DELETE) {
{
setState(6427);
((DataDescContext)_localctx).deleteOn = deleteOnClause();
}
}
setState(6431);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(6430);
((DataDescContext)_localctx).sequenceColumn = sequenceColClause();
}
}
setState(6434);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROPERTIES) {
{
setState(6433);
propertyClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6440);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==APPEND || _la==DELETE || _la==MERGE || _la==WITH) {
{
setState(6437);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(6436);
match(WITH);
}
}
setState(6439);
mergeType();
}
}
setState(6442);
match(DATA);
setState(6443);
match(FROM);
setState(6444);
match(TABLE);
setState(6445);
((DataDescContext)_localctx).sourceTableName = identifier();
setState(6446);
match(INTO);
setState(6447);
match(TABLE);
setState(6448);
((DataDescContext)_localctx).targetTableName = identifier();
setState(6451);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(6449);
match(PARTITION);
setState(6450);
((DataDescContext)_localctx).partition = identifierList();
}
}
setState(6454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SET) {
{
setState(6453);
((DataDescContext)_localctx).columnMapping = colMappingList();
}
}
setState(6457);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(6456);
((DataDescContext)_localctx).where = whereClause();
}
}
setState(6460);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DELETE) {
{
setState(6459);
((DataDescContext)_localctx).deleteOn = deleteOnClause();
}
}
setState(6463);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROPERTIES) {
{
setState(6462);
propertyClause();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BuildModeContext extends ParserRuleContext {
public TerminalNode BUILD() { return getToken(PLParser.BUILD, 0); }
public TerminalNode IMMEDIATE() { return getToken(PLParser.IMMEDIATE, 0); }
public TerminalNode DEFERRED() { return getToken(PLParser.DEFERRED, 0); }
public BuildModeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_buildMode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBuildMode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBuildMode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBuildMode(this);
else return visitor.visitChildren(this);
}
}
public final BuildModeContext buildMode() throws RecognitionException {
BuildModeContext _localctx = new BuildModeContext(_ctx, getState());
enterRule(_localctx, 440, RULE_buildMode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6467);
match(BUILD);
setState(6468);
_la = _input.LA(1);
if ( !(_la==DEFERRED || _la==IMMEDIATE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshTriggerContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode MANUAL() { return getToken(PLParser.MANUAL, 0); }
public TerminalNode SCHEDULE() { return getToken(PLParser.SCHEDULE, 0); }
public RefreshScheduleContext refreshSchedule() {
return getRuleContext(RefreshScheduleContext.class,0);
}
public TerminalNode COMMIT() { return getToken(PLParser.COMMIT, 0); }
public RefreshTriggerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_refreshTrigger; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshTrigger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshTrigger(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshTrigger(this);
else return visitor.visitChildren(this);
}
}
public final RefreshTriggerContext refreshTrigger() throws RecognitionException {
RefreshTriggerContext _localctx = new RefreshTriggerContext(_ctx, getState());
enterRule(_localctx, 442, RULE_refreshTrigger);
try {
setState(6477);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,890,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6470);
match(ON);
setState(6471);
match(MANUAL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6472);
match(ON);
setState(6473);
match(SCHEDULE);
setState(6474);
refreshSchedule();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(6475);
match(ON);
setState(6476);
match(COMMIT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshScheduleContext extends ParserRuleContext {
public IdentifierContext refreshUnit;
public TerminalNode EVERY() { return getToken(PLParser.EVERY, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STARTS() { return getToken(PLParser.STARTS, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public RefreshScheduleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_refreshSchedule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshSchedule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshSchedule(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshSchedule(this);
else return visitor.visitChildren(this);
}
}
public final RefreshScheduleContext refreshSchedule() throws RecognitionException {
RefreshScheduleContext _localctx = new RefreshScheduleContext(_ctx, getState());
enterRule(_localctx, 444, RULE_refreshSchedule);
try {
enterOuterAlt(_localctx, 1);
{
setState(6479);
match(EVERY);
setState(6480);
match(INTEGER_VALUE);
setState(6481);
((RefreshScheduleContext)_localctx).refreshUnit = identifier();
setState(6484);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,891,_ctx) ) {
case 1:
{
setState(6482);
match(STARTS);
setState(6483);
match(STRING_LITERAL);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RefreshMethodContext extends ParserRuleContext {
public TerminalNode COMPLETE() { return getToken(PLParser.COMPLETE, 0); }
public TerminalNode AUTO() { return getToken(PLParser.AUTO, 0); }
public RefreshMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_refreshMethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRefreshMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRefreshMethod(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRefreshMethod(this);
else return visitor.visitChildren(this);
}
}
public final RefreshMethodContext refreshMethod() throws RecognitionException {
RefreshMethodContext _localctx = new RefreshMethodContext(_ctx, getState());
enterRule(_localctx, 446, RULE_refreshMethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6486);
_la = _input.LA(1);
if ( !(_la==AUTO || _la==COMPLETE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MvPartitionContext extends ParserRuleContext {
public IdentifierContext partitionKey;
public FunctionCallExpressionContext partitionExpr;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FunctionCallExpressionContext functionCallExpression() {
return getRuleContext(FunctionCallExpressionContext.class,0);
}
public MvPartitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mvPartition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMvPartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMvPartition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMvPartition(this);
else return visitor.visitChildren(this);
}
}
public final MvPartitionContext mvPartition() throws RecognitionException {
MvPartitionContext _localctx = new MvPartitionContext(_ctx, getState());
enterRule(_localctx, 448, RULE_mvPartition);
try {
setState(6490);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,892,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6488);
((MvPartitionContext)_localctx).partitionKey = identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6489);
((MvPartitionContext)_localctx).partitionExpr = functionCallExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierOrTextContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public IdentifierOrTextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierOrText; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifierOrText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifierOrText(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifierOrText(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierOrTextContext identifierOrText() throws RecognitionException {
IdentifierOrTextContext _localctx = new IdentifierOrTextContext(_ctx, getState());
enterRule(_localctx, 450, RULE_identifierOrText);
try {
setState(6494);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(6492);
identifier();
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(6493);
match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierOrTextOrAsteriskContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public IdentifierOrTextOrAsteriskContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierOrTextOrAsterisk; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifierOrTextOrAsterisk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifierOrTextOrAsterisk(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifierOrTextOrAsterisk(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierOrTextOrAsteriskContext identifierOrTextOrAsterisk() throws RecognitionException {
IdentifierOrTextOrAsteriskContext _localctx = new IdentifierOrTextOrAsteriskContext(_ctx, getState());
enterRule(_localctx, 452, RULE_identifierOrTextOrAsterisk);
try {
setState(6499);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(6496);
identifier();
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(6497);
match(STRING_LITERAL);
}
break;
case ASTERISK:
enterOuterAlt(_localctx, 3);
{
setState(6498);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultipartIdentifierOrAsteriskContext extends ParserRuleContext {
public IdentifierOrAsteriskContext identifierOrAsterisk;
public List<IdentifierOrAsteriskContext> parts = new ArrayList<IdentifierOrAsteriskContext>();
public List<IdentifierOrAsteriskContext> identifierOrAsterisk() {
return getRuleContexts(IdentifierOrAsteriskContext.class);
}
public IdentifierOrAsteriskContext identifierOrAsterisk(int i) {
return getRuleContext(IdentifierOrAsteriskContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(PLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(PLParser.DOT, i);
}
public MultipartIdentifierOrAsteriskContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifierOrAsterisk; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMultipartIdentifierOrAsterisk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMultipartIdentifierOrAsterisk(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMultipartIdentifierOrAsterisk(this);
else return visitor.visitChildren(this);
}
}
public final MultipartIdentifierOrAsteriskContext multipartIdentifierOrAsterisk() throws RecognitionException {
MultipartIdentifierOrAsteriskContext _localctx = new MultipartIdentifierOrAsteriskContext(_ctx, getState());
enterRule(_localctx, 454, RULE_multipartIdentifierOrAsterisk);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6501);
((MultipartIdentifierOrAsteriskContext)_localctx).identifierOrAsterisk = identifierOrAsterisk();
((MultipartIdentifierOrAsteriskContext)_localctx).parts.add(((MultipartIdentifierOrAsteriskContext)_localctx).identifierOrAsterisk);
setState(6506);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(6502);
match(DOT);
setState(6503);
((MultipartIdentifierOrAsteriskContext)_localctx).identifierOrAsterisk = identifierOrAsterisk();
((MultipartIdentifierOrAsteriskContext)_localctx).parts.add(((MultipartIdentifierOrAsteriskContext)_localctx).identifierOrAsterisk);
}
}
setState(6508);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierOrAsteriskContext extends ParserRuleContext {
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public IdentifierOrAsteriskContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierOrAsterisk; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifierOrAsterisk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifierOrAsterisk(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifierOrAsterisk(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierOrAsteriskContext identifierOrAsterisk() throws RecognitionException {
IdentifierOrAsteriskContext _localctx = new IdentifierOrAsteriskContext(_ctx, getState());
enterRule(_localctx, 456, RULE_identifierOrAsterisk);
try {
setState(6511);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(6509);
identifierOrText();
}
break;
case ASTERISK:
enterOuterAlt(_localctx, 2);
{
setState(6510);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UserIdentifyContext extends ParserRuleContext {
public IdentifierOrTextContext user;
public IdentifierOrTextContext host;
public List<IdentifierOrTextContext> identifierOrText() {
return getRuleContexts(IdentifierOrTextContext.class);
}
public IdentifierOrTextContext identifierOrText(int i) {
return getRuleContext(IdentifierOrTextContext.class,i);
}
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public UserIdentifyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_userIdentify; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUserIdentify(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUserIdentify(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUserIdentify(this);
else return visitor.visitChildren(this);
}
}
public final UserIdentifyContext userIdentify() throws RecognitionException {
UserIdentifyContext _localctx = new UserIdentifyContext(_ctx, getState());
enterRule(_localctx, 458, RULE_userIdentify);
try {
enterOuterAlt(_localctx, 1);
{
setState(6513);
((UserIdentifyContext)_localctx).user = identifierOrText();
setState(6522);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,898,_ctx) ) {
case 1:
{
setState(6514);
match(ATSIGN);
setState(6520);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case STRING_LITERAL:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6515);
((UserIdentifyContext)_localctx).host = identifierOrText();
}
break;
case LEFT_PAREN:
{
setState(6516);
match(LEFT_PAREN);
setState(6517);
((UserIdentifyContext)_localctx).host = identifierOrText();
setState(6518);
match(RIGHT_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GrantUserIdentifyContext extends ParserRuleContext {
public UserIdentifyContext userIdentify() {
return getRuleContext(UserIdentifyContext.class,0);
}
public TerminalNode IDENTIFIED() { return getToken(PLParser.IDENTIFIED, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode PASSWORD() { return getToken(PLParser.PASSWORD, 0); }
public GrantUserIdentifyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_grantUserIdentify; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGrantUserIdentify(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGrantUserIdentify(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGrantUserIdentify(this);
else return visitor.visitChildren(this);
}
}
public final GrantUserIdentifyContext grantUserIdentify() throws RecognitionException {
GrantUserIdentifyContext _localctx = new GrantUserIdentifyContext(_ctx, getState());
enterRule(_localctx, 460, RULE_grantUserIdentify);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6524);
userIdentify();
setState(6531);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,900,_ctx) ) {
case 1:
{
setState(6525);
match(IDENTIFIED);
setState(6526);
match(BY);
setState(6528);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PASSWORD) {
{
setState(6527);
match(PASSWORD);
}
}
setState(6530);
match(STRING_LITERAL);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExplainContext extends ParserRuleContext {
public Token level;
public ExplainCommandContext explainCommand() {
return getRuleContext(ExplainCommandContext.class,0);
}
public PlanTypeContext planType() {
return getRuleContext(PlanTypeContext.class,0);
}
public TerminalNode PROCESS() { return getToken(PLParser.PROCESS, 0); }
public TerminalNode VERBOSE() { return getToken(PLParser.VERBOSE, 0); }
public TerminalNode TREE() { return getToken(PLParser.TREE, 0); }
public TerminalNode GRAPH() { return getToken(PLParser.GRAPH, 0); }
public TerminalNode PLAN() { return getToken(PLParser.PLAN, 0); }
public TerminalNode DUMP() { return getToken(PLParser.DUMP, 0); }
public ExplainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explain; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExplain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExplain(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExplain(this);
else return visitor.visitChildren(this);
}
}
public final ExplainContext explain() throws RecognitionException {
ExplainContext _localctx = new ExplainContext(_ctx, getState());
enterRule(_localctx, 462, RULE_explain);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6533);
explainCommand();
setState(6535);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==ANALYZED || _la==DISTRIBUTED || ((((_la - 451)) & ~0x3f) == 0 && ((1L << (_la - 451)) & 9042383626895361L) != 0) || _la==PHYSICAL || _la==REWRITTEN || _la==SHAPE) {
{
setState(6534);
planType();
}
}
setState(6538);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DUMP || _la==GRAPH || _la==PLAN || _la==TREE || _la==VERBOSE) {
{
setState(6537);
((ExplainContext)_localctx).level = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DUMP || _la==GRAPH || _la==PLAN || _la==TREE || _la==VERBOSE) ) {
((ExplainContext)_localctx).level = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(6541);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROCESS) {
{
setState(6540);
match(PROCESS);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExplainCommandContext extends ParserRuleContext {
public TerminalNode EXPLAIN() { return getToken(PLParser.EXPLAIN, 0); }
public TerminalNode DESC() { return getToken(PLParser.DESC, 0); }
public TerminalNode DESCRIBE() { return getToken(PLParser.DESCRIBE, 0); }
public ExplainCommandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explainCommand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExplainCommand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExplainCommand(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExplainCommand(this);
else return visitor.visitChildren(this);
}
}
public final ExplainCommandContext explainCommand() throws RecognitionException {
ExplainCommandContext _localctx = new ExplainCommandContext(_ctx, getState());
enterRule(_localctx, 464, RULE_explainCommand);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6543);
_la = _input.LA(1);
if ( !(((((_la - 310)) & ~0x3f) == 0 && ((1L << (_la - 310)) & 549755813891L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PlanTypeContext extends ParserRuleContext {
public TerminalNode PARSED() { return getToken(PLParser.PARSED, 0); }
public TerminalNode ANALYZED() { return getToken(PLParser.ANALYZED, 0); }
public TerminalNode REWRITTEN() { return getToken(PLParser.REWRITTEN, 0); }
public TerminalNode LOGICAL() { return getToken(PLParser.LOGICAL, 0); }
public TerminalNode OPTIMIZED() { return getToken(PLParser.OPTIMIZED, 0); }
public TerminalNode PHYSICAL() { return getToken(PLParser.PHYSICAL, 0); }
public TerminalNode SHAPE() { return getToken(PLParser.SHAPE, 0); }
public TerminalNode MEMO() { return getToken(PLParser.MEMO, 0); }
public TerminalNode DISTRIBUTED() { return getToken(PLParser.DISTRIBUTED, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public PlanTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_planType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPlanType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPlanType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPlanType(this);
else return visitor.visitChildren(this);
}
}
public final PlanTypeContext planType() throws RecognitionException {
PlanTypeContext _localctx = new PlanTypeContext(_ctx, getState());
enterRule(_localctx, 466, RULE_planType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6545);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANALYZED || _la==DISTRIBUTED || ((((_la - 451)) & ~0x3f) == 0 && ((1L << (_la - 451)) & 9042383626895361L) != 0) || _la==PHYSICAL || _la==REWRITTEN || _la==SHAPE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReplayCommandContext extends ParserRuleContext {
public TerminalNode PLAN() { return getToken(PLParser.PLAN, 0); }
public TerminalNode REPLAYER() { return getToken(PLParser.REPLAYER, 0); }
public ReplayTypeContext replayType() {
return getRuleContext(ReplayTypeContext.class,0);
}
public ReplayCommandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_replayCommand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReplayCommand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReplayCommand(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReplayCommand(this);
else return visitor.visitChildren(this);
}
}
public final ReplayCommandContext replayCommand() throws RecognitionException {
ReplayCommandContext _localctx = new ReplayCommandContext(_ctx, getState());
enterRule(_localctx, 468, RULE_replayCommand);
try {
enterOuterAlt(_localctx, 1);
{
setState(6547);
match(PLAN);
setState(6548);
match(REPLAYER);
setState(6549);
replayType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReplayTypeContext extends ParserRuleContext {
public Token filePath;
public TerminalNode DUMP() { return getToken(PLParser.DUMP, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode PLAY() { return getToken(PLParser.PLAY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public ReplayTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_replayType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterReplayType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitReplayType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitReplayType(this);
else return visitor.visitChildren(this);
}
}
public final ReplayTypeContext replayType() throws RecognitionException {
ReplayTypeContext _localctx = new ReplayTypeContext(_ctx, getState());
enterRule(_localctx, 470, RULE_replayType);
try {
setState(6555);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DUMP:
enterOuterAlt(_localctx, 1);
{
setState(6551);
match(DUMP);
setState(6552);
query();
}
break;
case PLAY:
enterOuterAlt(_localctx, 2);
{
setState(6553);
match(PLAY);
setState(6554);
((ReplayTypeContext)_localctx).filePath = match(STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MergeTypeContext extends ParserRuleContext {
public TerminalNode APPEND() { return getToken(PLParser.APPEND, 0); }
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode MERGE() { return getToken(PLParser.MERGE, 0); }
public MergeTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMergeType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMergeType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMergeType(this);
else return visitor.visitChildren(this);
}
}
public final MergeTypeContext mergeType() throws RecognitionException {
MergeTypeContext _localctx = new MergeTypeContext(_ctx, getState());
enterRule(_localctx, 472, RULE_mergeType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6557);
_la = _input.LA(1);
if ( !(_la==APPEND || _la==DELETE || _la==MERGE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PreFilterClauseContext extends ParserRuleContext {
public TerminalNode PRECEDING() { return getToken(PLParser.PRECEDING, 0); }
public TerminalNode FILTER() { return getToken(PLParser.FILTER, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PreFilterClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preFilterClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPreFilterClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPreFilterClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPreFilterClause(this);
else return visitor.visitChildren(this);
}
}
public final PreFilterClauseContext preFilterClause() throws RecognitionException {
PreFilterClauseContext _localctx = new PreFilterClauseContext(_ctx, getState());
enterRule(_localctx, 474, RULE_preFilterClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6559);
match(PRECEDING);
setState(6560);
match(FILTER);
setState(6561);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DeleteOnClauseContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(PLParser.DELETE, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public DeleteOnClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteOnClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDeleteOnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDeleteOnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDeleteOnClause(this);
else return visitor.visitChildren(this);
}
}
public final DeleteOnClauseContext deleteOnClause() throws RecognitionException {
DeleteOnClauseContext _localctx = new DeleteOnClauseContext(_ctx, getState());
enterRule(_localctx, 476, RULE_deleteOnClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6563);
match(DELETE);
setState(6564);
match(ON);
setState(6565);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SequenceColClauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SequenceColClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sequenceColClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSequenceColClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSequenceColClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSequenceColClause(this);
else return visitor.visitChildren(this);
}
}
public final SequenceColClauseContext sequenceColClause() throws RecognitionException {
SequenceColClauseContext _localctx = new SequenceColClauseContext(_ctx, getState());
enterRule(_localctx, 478, RULE_sequenceColClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6567);
match(ORDER);
setState(6568);
match(BY);
setState(6569);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColFromPathContext extends ParserRuleContext {
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode PATH() { return getToken(PLParser.PATH, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ColFromPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_colFromPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColFromPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColFromPath(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColFromPath(this);
else return visitor.visitChildren(this);
}
}
public final ColFromPathContext colFromPath() throws RecognitionException {
ColFromPathContext _localctx = new ColFromPathContext(_ctx, getState());
enterRule(_localctx, 480, RULE_colFromPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(6571);
match(COLUMNS);
setState(6572);
match(FROM);
setState(6573);
match(PATH);
setState(6574);
match(AS);
setState(6575);
identifierList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColMappingListContext extends ParserRuleContext {
public MappingExprContext mappingExpr;
public List<MappingExprContext> mappingSet = new ArrayList<MappingExprContext>();
public TerminalNode SET() { return getToken(PLParser.SET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<MappingExprContext> mappingExpr() {
return getRuleContexts(MappingExprContext.class);
}
public MappingExprContext mappingExpr(int i) {
return getRuleContext(MappingExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ColMappingListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_colMappingList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColMappingList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColMappingList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColMappingList(this);
else return visitor.visitChildren(this);
}
}
public final ColMappingListContext colMappingList() throws RecognitionException {
ColMappingListContext _localctx = new ColMappingListContext(_ctx, getState());
enterRule(_localctx, 482, RULE_colMappingList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6577);
match(SET);
setState(6578);
match(LEFT_PAREN);
setState(6579);
((ColMappingListContext)_localctx).mappingExpr = mappingExpr();
((ColMappingListContext)_localctx).mappingSet.add(((ColMappingListContext)_localctx).mappingExpr);
setState(6584);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6580);
match(COMMA);
setState(6581);
((ColMappingListContext)_localctx).mappingExpr = mappingExpr();
((ColMappingListContext)_localctx).mappingSet.add(((ColMappingListContext)_localctx).mappingExpr);
}
}
setState(6586);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6587);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MappingExprContext extends ParserRuleContext {
public IdentifierContext mappingCol;
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MappingExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mappingExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMappingExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMappingExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMappingExpr(this);
else return visitor.visitChildren(this);
}
}
public final MappingExprContext mappingExpr() throws RecognitionException {
MappingExprContext _localctx = new MappingExprContext(_ctx, getState());
enterRule(_localctx, 484, RULE_mappingExpr);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(6589);
((MappingExprContext)_localctx).mappingCol = identifier();
setState(6590);
match(EQ);
setState(6591);
expression();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithRemoteStorageSystemContext extends ParserRuleContext {
public PropertyItemListContext brokerProperties;
public IdentifierOrTextContext brokerName;
public ResourceDescContext resourceDesc() {
return getRuleContext(ResourceDescContext.class,0);
}
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode S3() { return getToken(PLParser.S3, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode HDFS() { return getToken(PLParser.HDFS, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public WithRemoteStorageSystemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withRemoteStorageSystem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWithRemoteStorageSystem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWithRemoteStorageSystem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWithRemoteStorageSystem(this);
else return visitor.visitChildren(this);
}
}
public final WithRemoteStorageSystemContext withRemoteStorageSystem() throws RecognitionException {
WithRemoteStorageSystemContext _localctx = new WithRemoteStorageSystemContext(_ctx, getState());
enterRule(_localctx, 486, RULE_withRemoteStorageSystem);
try {
setState(6621);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,907,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6593);
resourceDesc();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6594);
match(WITH);
setState(6595);
match(S3);
setState(6596);
match(LEFT_PAREN);
setState(6597);
((WithRemoteStorageSystemContext)_localctx).brokerProperties = propertyItemList();
setState(6598);
match(RIGHT_PAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(6600);
match(WITH);
setState(6601);
match(HDFS);
setState(6602);
match(LEFT_PAREN);
setState(6603);
((WithRemoteStorageSystemContext)_localctx).brokerProperties = propertyItemList();
setState(6604);
match(RIGHT_PAREN);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(6606);
match(WITH);
setState(6607);
match(LOCAL);
setState(6608);
match(LEFT_PAREN);
setState(6609);
((WithRemoteStorageSystemContext)_localctx).brokerProperties = propertyItemList();
setState(6610);
match(RIGHT_PAREN);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(6612);
match(WITH);
setState(6613);
match(BROKER);
setState(6614);
((WithRemoteStorageSystemContext)_localctx).brokerName = identifierOrText();
setState(6619);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,906,_ctx) ) {
case 1:
{
setState(6615);
match(LEFT_PAREN);
setState(6616);
((WithRemoteStorageSystemContext)_localctx).brokerProperties = propertyItemList();
setState(6617);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ResourceDescContext extends ParserRuleContext {
public IdentifierOrTextContext resourceName;
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ResourceDescContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resourceDesc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterResourceDesc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitResourceDesc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitResourceDesc(this);
else return visitor.visitChildren(this);
}
}
public final ResourceDescContext resourceDesc() throws RecognitionException {
ResourceDescContext _localctx = new ResourceDescContext(_ctx, getState());
enterRule(_localctx, 488, RULE_resourceDesc);
try {
enterOuterAlt(_localctx, 1);
{
setState(6623);
match(WITH);
setState(6624);
match(RESOURCE);
setState(6625);
((ResourceDescContext)_localctx).resourceName = identifierOrText();
setState(6630);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,908,_ctx) ) {
case 1:
{
setState(6626);
match(LEFT_PAREN);
setState(6627);
propertyItemList();
setState(6628);
match(RIGHT_PAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MysqlDataDescContext extends ParserRuleContext {
public Token filePath;
public MultipartIdentifierContext tableName;
public IdentifierListContext partition;
public Token comma;
public Token separator;
public IdentifierListContext columns;
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode INFILE() { return getToken(PLParser.INFILE, 0); }
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public TerminalNode TABLE() { return getToken(PLParser.TABLE, 0); }
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public List<TerminalNode> TERMINATED() { return getTokens(PLParser.TERMINATED); }
public TerminalNode TERMINATED(int i) {
return getToken(PLParser.TERMINATED, i);
}
public List<TerminalNode> BY() { return getTokens(PLParser.BY); }
public TerminalNode BY(int i) {
return getToken(PLParser.BY, i);
}
public TerminalNode LINES() { return getToken(PLParser.LINES, 0); }
public SkipLinesContext skipLines() {
return getRuleContext(SkipLinesContext.class,0);
}
public ColMappingListContext colMappingList() {
return getRuleContext(ColMappingListContext.class,0);
}
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public MysqlDataDescContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mysqlDataDesc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMysqlDataDesc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMysqlDataDesc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMysqlDataDesc(this);
else return visitor.visitChildren(this);
}
}
public final MysqlDataDescContext mysqlDataDesc() throws RecognitionException {
MysqlDataDescContext _localctx = new MysqlDataDescContext(_ctx, getState());
enterRule(_localctx, 490, RULE_mysqlDataDesc);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6632);
match(DATA);
setState(6634);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(6633);
match(LOCAL);
}
}
setState(6636);
match(INFILE);
setState(6637);
((MysqlDataDescContext)_localctx).filePath = match(STRING_LITERAL);
setState(6638);
match(INTO);
setState(6639);
match(TABLE);
setState(6640);
((MysqlDataDescContext)_localctx).tableName = multipartIdentifier();
setState(6643);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,910,_ctx) ) {
case 1:
{
setState(6641);
match(PARTITION);
setState(6642);
((MysqlDataDescContext)_localctx).partition = identifierList();
}
break;
}
setState(6649);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,911,_ctx) ) {
case 1:
{
setState(6645);
match(COLUMNS);
setState(6646);
match(TERMINATED);
setState(6647);
match(BY);
setState(6648);
((MysqlDataDescContext)_localctx).comma = match(STRING_LITERAL);
}
break;
}
setState(6655);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,912,_ctx) ) {
case 1:
{
setState(6651);
match(LINES);
setState(6652);
match(TERMINATED);
setState(6653);
match(BY);
setState(6654);
((MysqlDataDescContext)_localctx).separator = match(STRING_LITERAL);
}
break;
}
setState(6658);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,913,_ctx) ) {
case 1:
{
setState(6657);
skipLines();
}
break;
}
setState(6661);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,914,_ctx) ) {
case 1:
{
setState(6660);
((MysqlDataDescContext)_localctx).columns = identifierList();
}
break;
}
setState(6664);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,915,_ctx) ) {
case 1:
{
setState(6663);
colMappingList();
}
break;
}
setState(6667);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,916,_ctx) ) {
case 1:
{
setState(6666);
propertyClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SkipLinesContext extends ParserRuleContext {
public Token lines;
public TerminalNode IGNORE() { return getToken(PLParser.IGNORE, 0); }
public TerminalNode LINES() { return getToken(PLParser.LINES, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode ROWS() { return getToken(PLParser.ROWS, 0); }
public SkipLinesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_skipLines; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSkipLines(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSkipLines(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSkipLines(this);
else return visitor.visitChildren(this);
}
}
public final SkipLinesContext skipLines() throws RecognitionException {
SkipLinesContext _localctx = new SkipLinesContext(_ctx, getState());
enterRule(_localctx, 492, RULE_skipLines);
try {
setState(6675);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,917,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6669);
match(IGNORE);
setState(6670);
((SkipLinesContext)_localctx).lines = match(INTEGER_VALUE);
setState(6671);
match(LINES);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6672);
match(IGNORE);
setState(6673);
((SkipLinesContext)_localctx).lines = match(INTEGER_VALUE);
setState(6674);
match(ROWS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OutFileClauseContext extends ParserRuleContext {
public ConstantContext filePath;
public IdentifierContext format;
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public TerminalNode OUTFILE() { return getToken(PLParser.OUTFILE, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TerminalNode FORMAT() { return getToken(PLParser.FORMAT, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OutFileClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outFileClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOutFileClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOutFileClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOutFileClause(this);
else return visitor.visitChildren(this);
}
}
public final OutFileClauseContext outFileClause() throws RecognitionException {
OutFileClauseContext _localctx = new OutFileClauseContext(_ctx, getState());
enterRule(_localctx, 494, RULE_outFileClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6677);
match(INTO);
setState(6678);
match(OUTFILE);
setState(6679);
((OutFileClauseContext)_localctx).filePath = constant();
setState(6683);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,918,_ctx) ) {
case 1:
{
setState(6680);
match(FORMAT);
setState(6681);
match(AS);
setState(6682);
((OutFileClauseContext)_localctx).format = identifier();
}
break;
}
setState(6686);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,919,_ctx) ) {
case 1:
{
setState(6685);
propertyClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryContext extends ParserRuleContext {
public QueryTermContext queryTerm() {
return getRuleContext(QueryTermContext.class,0);
}
public QueryOrganizationContext queryOrganization() {
return getRuleContext(QueryOrganizationContext.class,0);
}
public CteContext cte() {
return getRuleContext(CteContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQuery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 496, RULE_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6689);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(6688);
cte();
}
}
setState(6691);
queryTerm(0);
setState(6692);
queryOrganization();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryTermContext extends ParserRuleContext {
public QueryTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryTerm; }
public QueryTermContext() { }
public void copyFrom(QueryTermContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QueryTermDefaultContext extends QueryTermContext {
public QueryPrimaryContext queryPrimary() {
return getRuleContext(QueryPrimaryContext.class,0);
}
public QueryTermDefaultContext(QueryTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQueryTermDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQueryTermDefault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQueryTermDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetOperationContext extends QueryTermContext {
public QueryTermContext left;
public Token operator;
public QueryTermContext right;
public List<QueryTermContext> queryTerm() {
return getRuleContexts(QueryTermContext.class);
}
public QueryTermContext queryTerm(int i) {
return getRuleContext(QueryTermContext.class,i);
}
public TerminalNode INTERSECT() { return getToken(PLParser.INTERSECT, 0); }
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public TerminalNode UNION() { return getToken(PLParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(PLParser.EXCEPT, 0); }
public TerminalNode MINUS() { return getToken(PLParser.MINUS, 0); }
public SetOperationContext(QueryTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetOperation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetOperation(this);
else return visitor.visitChildren(this);
}
}
public final QueryTermContext queryTerm() throws RecognitionException {
return queryTerm(0);
}
private QueryTermContext queryTerm(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
QueryTermContext _localctx = new QueryTermContext(_ctx, _parentState);
QueryTermContext _prevctx = _localctx;
int _startState = 498;
enterRecursionRule(_localctx, 498, RULE_queryTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new QueryTermDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(6695);
queryPrimary();
}
_ctx.stop = _input.LT(-1);
setState(6711);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,924,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(6709);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,923,_ctx) ) {
case 1:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(6697);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(6698);
((SetOperationContext)_localctx).operator = match(INTERSECT);
setState(6700);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(6699);
setQuantifier();
}
}
setState(6702);
((SetOperationContext)_localctx).right = queryTerm(3);
}
break;
case 2:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(6703);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(6704);
((SetOperationContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==MINUS || _la==UNION) ) {
((SetOperationContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(6706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(6705);
setQuantifier();
}
}
setState(6708);
((SetOperationContext)_localctx).right = queryTerm(2);
}
break;
}
}
}
setState(6713);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,924,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SetQuantifierContext extends ParserRuleContext {
public TerminalNode DISTINCT() { return getToken(PLParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public SetQuantifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setQuantifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSetQuantifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSetQuantifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSetQuantifier(this);
else return visitor.visitChildren(this);
}
}
public final SetQuantifierContext setQuantifier() throws RecognitionException {
SetQuantifierContext _localctx = new SetQuantifierContext(_ctx, getState());
enterRule(_localctx, 500, RULE_setQuantifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6714);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryPrimaryContext extends ParserRuleContext {
public QueryPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryPrimary; }
public QueryPrimaryContext() { }
public void copyFrom(QueryPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubqueryContext extends QueryPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SubqueryContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSubquery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSubquery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValuesTableContext extends QueryPrimaryContext {
public InlineTableContext inlineTable() {
return getRuleContext(InlineTableContext.class,0);
}
public ValuesTableContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterValuesTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitValuesTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitValuesTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QueryPrimaryDefaultContext extends QueryPrimaryContext {
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public QueryPrimaryDefaultContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQueryPrimaryDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQueryPrimaryDefault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQueryPrimaryDefault(this);
else return visitor.visitChildren(this);
}
}
public final QueryPrimaryContext queryPrimary() throws RecognitionException {
QueryPrimaryContext _localctx = new QueryPrimaryContext(_ctx, getState());
enterRule(_localctx, 502, RULE_queryPrimary);
try {
setState(6722);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
_localctx = new QueryPrimaryDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6716);
querySpecification();
}
break;
case LEFT_PAREN:
_localctx = new SubqueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6717);
match(LEFT_PAREN);
setState(6718);
query();
setState(6719);
match(RIGHT_PAREN);
}
break;
case VALUES:
_localctx = new ValuesTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(6721);
inlineTable();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuerySpecificationContext extends ParserRuleContext {
public QuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySpecification; }
public QuerySpecificationContext() { }
public void copyFrom(QuerySpecificationContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RegularQuerySpecificationContext extends QuerySpecificationContext {
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public QueryOrganizationContext queryOrganization() {
return getRuleContext(QueryOrganizationContext.class,0);
}
public IntoClauseContext intoClause() {
return getRuleContext(IntoClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public AggClauseContext aggClause() {
return getRuleContext(AggClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public RegularQuerySpecificationContext(QuerySpecificationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRegularQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRegularQuerySpecification(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRegularQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 504, RULE_querySpecification);
try {
_localctx = new RegularQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6724);
selectClause();
setState(6726);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,926,_ctx) ) {
case 1:
{
setState(6725);
intoClause();
}
break;
}
setState(6729);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,927,_ctx) ) {
case 1:
{
setState(6728);
fromClause();
}
break;
}
setState(6732);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,928,_ctx) ) {
case 1:
{
setState(6731);
whereClause();
}
break;
}
setState(6735);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,929,_ctx) ) {
case 1:
{
setState(6734);
aggClause();
}
break;
}
setState(6738);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,930,_ctx) ) {
case 1:
{
setState(6737);
havingClause();
}
break;
}
setState(6740);
if (!(doris_legacy_SQL_syntax)) throw new FailedPredicateException(this, "doris_legacy_SQL_syntax");
setState(6741);
queryOrganization();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CteContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public List<AliasQueryContext> aliasQuery() {
return getRuleContexts(AliasQueryContext.class);
}
public AliasQueryContext aliasQuery(int i) {
return getRuleContext(AliasQueryContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cte; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCte(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCte(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCte(this);
else return visitor.visitChildren(this);
}
}
public final CteContext cte() throws RecognitionException {
CteContext _localctx = new CteContext(_ctx, getState());
enterRule(_localctx, 506, RULE_cte);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6743);
match(WITH);
setState(6744);
aliasQuery();
setState(6749);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6745);
match(COMMA);
setState(6746);
aliasQuery();
}
}
setState(6751);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AliasQueryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public AliasQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliasQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAliasQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAliasQuery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAliasQuery(this);
else return visitor.visitChildren(this);
}
}
public final AliasQueryContext aliasQuery() throws RecognitionException {
AliasQueryContext _localctx = new AliasQueryContext(_ctx, getState());
enterRule(_localctx, 508, RULE_aliasQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6752);
identifier();
setState(6754);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(6753);
columnAliases();
}
}
setState(6756);
match(AS);
setState(6757);
match(LEFT_PAREN);
setState(6758);
query();
setState(6759);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnAliasesContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ColumnAliasesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnAliases; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColumnAliases(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColumnAliases(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColumnAliases(this);
else return visitor.visitChildren(this);
}
}
public final ColumnAliasesContext columnAliases() throws RecognitionException {
ColumnAliasesContext _localctx = new ColumnAliasesContext(_ctx, getState());
enterRule(_localctx, 510, RULE_columnAliases);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6761);
match(LEFT_PAREN);
setState(6762);
identifier();
setState(6767);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6763);
match(COMMA);
setState(6764);
identifier();
}
}
setState(6769);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6770);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(PLParser.SELECT, 0); }
public SelectColumnClauseContext selectColumnClause() {
return getRuleContext(SelectColumnClauseContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(PLParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSelectClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 512, RULE_selectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6772);
match(SELECT);
setState(6774);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(6773);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(6776);
selectColumnClause();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectColumnClauseContext extends ParserRuleContext {
public NamedExpressionSeqContext namedExpressionSeq() {
return getRuleContext(NamedExpressionSeqContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode EXCEPT() { return getToken(PLParser.EXCEPT, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SelectColumnClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectColumnClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSelectColumnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSelectColumnClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSelectColumnClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectColumnClauseContext selectColumnClause() throws RecognitionException {
SelectColumnClauseContext _localctx = new SelectColumnClauseContext(_ctx, getState());
enterRule(_localctx, 514, RULE_selectColumnClause);
try {
setState(6785);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,935,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6778);
namedExpressionSeq();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6779);
match(ASTERISK);
setState(6780);
match(EXCEPT);
setState(6781);
match(LEFT_PAREN);
setState(6782);
namedExpressionSeq();
setState(6783);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhereClauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(PLParser.WHERE, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWhereClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 516, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6787);
match(WHERE);
setState(6788);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public RelationsContext relations() {
return getRuleContext(RelationsContext.class,0);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFromClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 518, RULE_fromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6790);
match(FROM);
setState(6791);
relations();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntoClauseContext extends ParserRuleContext {
public TerminalNode INTO() { return getToken(PLParser.INTO, 0); }
public List<TableRowContext> tableRow() {
return getRuleContexts(TableRowContext.class);
}
public TableRowContext tableRow(int i) {
return getRuleContext(TableRowContext.class,i);
}
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public BulkCollectClauseContext bulkCollectClause() {
return getRuleContext(BulkCollectClauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public IntoClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intoClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIntoClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIntoClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIntoClause(this);
else return visitor.visitChildren(this);
}
}
public final IntoClauseContext intoClause() throws RecognitionException {
IntoClauseContext _localctx = new IntoClauseContext(_ctx, getState());
enterRule(_localctx, 520, RULE_intoClause);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(6794);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BULK) {
{
setState(6793);
bulkCollectClause();
}
}
setState(6796);
match(INTO);
setState(6799);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,937,_ctx) ) {
case 1:
{
setState(6797);
tableRow();
}
break;
case 2:
{
setState(6798);
identifier();
}
break;
}
setState(6808);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,939,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6801);
match(COMMA);
setState(6804);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,938,_ctx) ) {
case 1:
{
setState(6802);
tableRow();
}
break;
case 2:
{
setState(6803);
identifier();
}
break;
}
}
}
}
setState(6810);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,939,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BulkCollectClauseContext extends ParserRuleContext {
public TerminalNode BULK() { return getToken(PLParser.BULK, 0); }
public TerminalNode COLLECT() { return getToken(PLParser.COLLECT, 0); }
public BulkCollectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bulkCollectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBulkCollectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBulkCollectClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBulkCollectClause(this);
else return visitor.visitChildren(this);
}
}
public final BulkCollectClauseContext bulkCollectClause() throws RecognitionException {
BulkCollectClauseContext _localctx = new BulkCollectClauseContext(_ctx, getState());
enterRule(_localctx, 522, RULE_bulkCollectClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6811);
match(BULK);
setState(6812);
match(COLLECT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableRowContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TableRowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableRow; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTableRow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTableRow(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTableRow(this);
else return visitor.visitChildren(this);
}
}
public final TableRowContext tableRow() throws RecognitionException {
TableRowContext _localctx = new TableRowContext(_ctx, getState());
enterRule(_localctx, 524, RULE_tableRow);
try {
enterOuterAlt(_localctx, 1);
{
setState(6814);
identifier();
setState(6815);
match(LEFT_PAREN);
setState(6816);
match(INTEGER_VALUE);
setState(6817);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationsContext extends ParserRuleContext {
public List<RelationContext> relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public RelationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRelations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRelations(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRelations(this);
else return visitor.visitChildren(this);
}
}
public final RelationsContext relations() throws RecognitionException {
RelationsContext _localctx = new RelationsContext(_ctx, getState());
enterRule(_localctx, 526, RULE_relations);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(6819);
relation();
setState(6824);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,940,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6820);
match(COMMA);
setState(6821);
relation();
}
}
}
setState(6826);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,940,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationContext extends ParserRuleContext {
public RelationPrimaryContext relationPrimary() {
return getRuleContext(RelationPrimaryContext.class,0);
}
public List<JoinRelationContext> joinRelation() {
return getRuleContexts(JoinRelationContext.class);
}
public JoinRelationContext joinRelation(int i) {
return getRuleContext(JoinRelationContext.class,i);
}
public RelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRelation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRelation(this);
else return visitor.visitChildren(this);
}
}
public final RelationContext relation() throws RecognitionException {
RelationContext _localctx = new RelationContext(_ctx, getState());
enterRule(_localctx, 528, RULE_relation);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(6827);
relationPrimary();
setState(6831);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,941,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6828);
joinRelation();
}
}
}
setState(6833);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,941,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JoinRelationContext extends ParserRuleContext {
public RelationPrimaryContext right;
public TerminalNode JOIN() { return getToken(PLParser.JOIN, 0); }
public RelationPrimaryContext relationPrimary() {
return getRuleContext(RelationPrimaryContext.class,0);
}
public JoinTypeContext joinType() {
return getRuleContext(JoinTypeContext.class,0);
}
public DistributeTypeContext distributeType() {
return getRuleContext(DistributeTypeContext.class,0);
}
public JoinCriteriaContext joinCriteria() {
return getRuleContext(JoinCriteriaContext.class,0);
}
public JoinRelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinRelation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterJoinRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitJoinRelation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitJoinRelation(this);
else return visitor.visitChildren(this);
}
}
public final JoinRelationContext joinRelation() throws RecognitionException {
JoinRelationContext _localctx = new JoinRelationContext(_ctx, getState());
enterRule(_localctx, 530, RULE_joinRelation);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(6834);
joinType();
}
setState(6835);
match(JOIN);
setState(6837);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,942,_ctx) ) {
case 1:
{
setState(6836);
distributeType();
}
break;
}
setState(6839);
((JoinRelationContext)_localctx).right = relationPrimary();
setState(6841);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,943,_ctx) ) {
case 1:
{
setState(6840);
joinCriteria();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DistributeTypeContext extends ParserRuleContext {
public DistributeTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_distributeType; }
public DistributeTypeContext() { }
public void copyFrom(DistributeTypeContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CommentDistributeTypeContext extends DistributeTypeContext {
public TerminalNode HINT_START() { return getToken(PLParser.HINT_START, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode HINT_END() { return getToken(PLParser.HINT_END, 0); }
public CommentDistributeTypeContext(DistributeTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCommentDistributeType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCommentDistributeType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCommentDistributeType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BracketDistributeTypeContext extends DistributeTypeContext {
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public BracketDistributeTypeContext(DistributeTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBracketDistributeType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBracketDistributeType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBracketDistributeType(this);
else return visitor.visitChildren(this);
}
}
public final DistributeTypeContext distributeType() throws RecognitionException {
DistributeTypeContext _localctx = new DistributeTypeContext(_ctx, getState());
enterRule(_localctx, 532, RULE_distributeType);
try {
setState(6851);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LEFT_BRACKET:
_localctx = new BracketDistributeTypeContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6843);
match(LEFT_BRACKET);
setState(6844);
identifier();
setState(6845);
match(RIGHT_BRACKET);
}
break;
case HINT_START:
_localctx = new CommentDistributeTypeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6847);
match(HINT_START);
setState(6848);
identifier();
setState(6849);
match(HINT_END);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationHintContext extends ParserRuleContext {
public RelationHintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationHint; }
public RelationHintContext() { }
public void copyFrom(RelationHintContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BracketRelationHintContext extends RelationHintContext {
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public BracketRelationHintContext(RelationHintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBracketRelationHint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBracketRelationHint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBracketRelationHint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CommentRelationHintContext extends RelationHintContext {
public TerminalNode HINT_START() { return getToken(PLParser.HINT_START, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode HINT_END() { return getToken(PLParser.HINT_END, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public CommentRelationHintContext(RelationHintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCommentRelationHint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCommentRelationHint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCommentRelationHint(this);
else return visitor.visitChildren(this);
}
}
public final RelationHintContext relationHint() throws RecognitionException {
RelationHintContext _localctx = new RelationHintContext(_ctx, getState());
enterRule(_localctx, 534, RULE_relationHint);
int _la;
try {
setState(6875);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LEFT_BRACKET:
_localctx = new BracketRelationHintContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(6853);
match(LEFT_BRACKET);
setState(6854);
identifier();
setState(6859);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6855);
match(COMMA);
setState(6856);
identifier();
}
}
setState(6861);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6862);
match(RIGHT_BRACKET);
}
break;
case HINT_START:
_localctx = new CommentRelationHintContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(6864);
match(HINT_START);
setState(6865);
identifier();
setState(6870);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6866);
match(COMMA);
setState(6867);
identifier();
}
}
setState(6872);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6873);
match(HINT_END);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AggClauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(PLParser.GROUP, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public GroupingElementContext groupingElement() {
return getRuleContext(GroupingElementContext.class,0);
}
public AggClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAggClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAggClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAggClause(this);
else return visitor.visitChildren(this);
}
}
public final AggClauseContext aggClause() throws RecognitionException {
AggClauseContext _localctx = new AggClauseContext(_ctx, getState());
enterRule(_localctx, 536, RULE_aggClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6877);
match(GROUP);
setState(6878);
match(BY);
setState(6879);
groupingElement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GroupingElementContext extends ParserRuleContext {
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode CUBE() { return getToken(PLParser.CUBE, 0); }
public TerminalNode GROUPING() { return getToken(PLParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(PLParser.SETS, 0); }
public List<GroupingSetContext> groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public TerminalNode WITH() { return getToken(PLParser.WITH, 0); }
public GroupingElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGroupingElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGroupingElement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGroupingElement(this);
else return visitor.visitChildren(this);
}
}
public final GroupingElementContext groupingElement() throws RecognitionException {
GroupingElementContext _localctx = new GroupingElementContext(_ctx, getState());
enterRule(_localctx, 538, RULE_groupingElement);
int _la;
try {
int _alt;
setState(6932);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,955,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6881);
match(ROLLUP);
setState(6882);
match(LEFT_PAREN);
setState(6891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(6883);
expression();
setState(6888);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6884);
match(COMMA);
setState(6885);
expression();
}
}
setState(6890);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(6893);
match(RIGHT_PAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6894);
match(CUBE);
setState(6895);
match(LEFT_PAREN);
setState(6904);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(6896);
expression();
setState(6901);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6897);
match(COMMA);
setState(6898);
expression();
}
}
setState(6903);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(6906);
match(RIGHT_PAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(6907);
match(GROUPING);
setState(6908);
match(SETS);
setState(6909);
match(LEFT_PAREN);
setState(6910);
groupingSet();
setState(6915);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6911);
match(COMMA);
setState(6912);
groupingSet();
}
}
setState(6917);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6918);
match(RIGHT_PAREN);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(6920);
expression();
setState(6925);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,953,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6921);
match(COMMA);
setState(6922);
expression();
}
}
}
setState(6927);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,953,_ctx);
}
setState(6930);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,954,_ctx) ) {
case 1:
{
setState(6928);
match(WITH);
setState(6929);
match(ROLLUP);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GroupingSetContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public GroupingSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterGroupingSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitGroupingSet(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitGroupingSet(this);
else return visitor.visitChildren(this);
}
}
public final GroupingSetContext groupingSet() throws RecognitionException {
GroupingSetContext _localctx = new GroupingSetContext(_ctx, getState());
enterRule(_localctx, 540, RULE_groupingSet);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6934);
match(LEFT_PAREN);
setState(6943);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(6935);
expression();
setState(6940);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(6936);
match(COMMA);
setState(6937);
expression();
}
}
setState(6942);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(6945);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(PLParser.HAVING, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHavingClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 542, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(6947);
match(HAVING);
setState(6948);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectHintContext extends ParserRuleContext {
public HintStatementContext hintStatement;
public List<HintStatementContext> hintStatements = new ArrayList<HintStatementContext>();
public TerminalNode HINT_END() { return getToken(PLParser.HINT_END, 0); }
public List<HintStatementContext> hintStatement() {
return getRuleContexts(HintStatementContext.class);
}
public HintStatementContext hintStatement(int i) {
return getRuleContext(HintStatementContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public SelectHintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectHint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSelectHint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSelectHint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSelectHint(this);
else return visitor.visitChildren(this);
}
}
public final SelectHintContext selectHint() throws RecognitionException {
SelectHintContext _localctx = new SelectHintContext(_ctx, getState());
enterRule(_localctx, 544, RULE_selectHint);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(6950);
((SelectHintContext)_localctx).hintStatement = hintStatement();
((SelectHintContext)_localctx).hintStatements.add(((SelectHintContext)_localctx).hintStatement);
setState(6957);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,959,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6952);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(6951);
match(COMMA);
}
}
setState(6954);
((SelectHintContext)_localctx).hintStatement = hintStatement();
((SelectHintContext)_localctx).hintStatements.add(((SelectHintContext)_localctx).hintStatement);
}
}
}
setState(6959);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,959,_ctx);
}
setState(6960);
match(HINT_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HintStatementContext extends ParserRuleContext {
public IdentifierContext hintName;
public HintAssignmentContext hintAssignment;
public List<HintAssignmentContext> parameters = new ArrayList<HintAssignmentContext>();
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<HintAssignmentContext> hintAssignment() {
return getRuleContexts(HintAssignmentContext.class);
}
public HintAssignmentContext hintAssignment(int i) {
return getRuleContext(HintAssignmentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public HintStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hintStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHintStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHintStatement(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHintStatement(this);
else return visitor.visitChildren(this);
}
}
public final HintStatementContext hintStatement() throws RecognitionException {
HintStatementContext _localctx = new HintStatementContext(_ctx, getState());
enterRule(_localctx, 546, RULE_hintStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(6962);
((HintStatementContext)_localctx).hintName = identifier();
setState(6976);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(6963);
match(LEFT_PAREN);
setState(6964);
((HintStatementContext)_localctx).hintAssignment = hintAssignment();
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).hintAssignment);
setState(6971);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3917005775905488895L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731842229283L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489932296231L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701645201671361L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -2730456240740152091L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305560947974124779L) != 0) || ((((_la - 714)) & ~0x3f) == 0 && ((1L << (_la - 714)) & 1761L) != 0)) {
{
{
setState(6966);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(6965);
match(COMMA);
}
}
setState(6968);
((HintStatementContext)_localctx).hintAssignment = hintAssignment();
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).hintAssignment);
}
}
setState(6973);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(6974);
match(RIGHT_PAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HintAssignmentContext extends ParserRuleContext {
public IdentifierOrTextContext key;
public ConstantContext constantValue;
public IdentifierContext identifierValue;
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public HintAssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hintAssignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterHintAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitHintAssignment(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitHintAssignment(this);
else return visitor.visitChildren(this);
}
}
public final HintAssignmentContext hintAssignment() throws RecognitionException {
HintAssignmentContext _localctx = new HintAssignmentContext(_ctx, getState());
enterRule(_localctx, 548, RULE_hintAssignment);
int _la;
try {
setState(6987);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,965,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(6978);
((HintAssignmentContext)_localctx).key = identifierOrText();
setState(6984);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(6979);
match(EQ);
setState(6982);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,963,_ctx) ) {
case 1:
{
setState(6980);
((HintAssignmentContext)_localctx).constantValue = constant();
}
break;
case 2:
{
setState(6981);
((HintAssignmentContext)_localctx).identifierValue = identifier();
}
break;
}
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(6986);
constant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UpdateAssignmentContext extends ParserRuleContext {
public MultipartIdentifierContext col;
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public UpdateAssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateAssignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUpdateAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUpdateAssignment(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUpdateAssignment(this);
else return visitor.visitChildren(this);
}
}
public final UpdateAssignmentContext updateAssignment() throws RecognitionException {
UpdateAssignmentContext _localctx = new UpdateAssignmentContext(_ctx, getState());
enterRule(_localctx, 550, RULE_updateAssignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(6989);
((UpdateAssignmentContext)_localctx).col = multipartIdentifier();
setState(6990);
match(EQ);
setState(6993);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_PAREN:
case LEFT_BRACKET:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case ADD:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BINARY:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATABASE:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXISTS:
case EXPIRED:
case EXTERNAL:
case EXTRACT:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IF:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEY:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LEFT:
case LESS:
case LEVEL:
case LIKE:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NOT:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLACEHOLDER:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REGEXP:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RIGHT:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case ASTERISK:
case TILDE:
case LOGICALNOT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case ATSIGN:
case DOUBLEATSIGN:
case STRING_LITERAL:
case INTEGER_VALUE:
case EXPONENT_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(6991);
expression();
}
break;
case DEFAULT:
{
setState(6992);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UpdateAssignmentSeqContext extends ParserRuleContext {
public UpdateAssignmentContext updateAssignment;
public List<UpdateAssignmentContext> assignments = new ArrayList<UpdateAssignmentContext>();
public List<UpdateAssignmentContext> updateAssignment() {
return getRuleContexts(UpdateAssignmentContext.class);
}
public UpdateAssignmentContext updateAssignment(int i) {
return getRuleContext(UpdateAssignmentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public UpdateAssignmentSeqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateAssignmentSeq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUpdateAssignmentSeq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUpdateAssignmentSeq(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUpdateAssignmentSeq(this);
else return visitor.visitChildren(this);
}
}
public final UpdateAssignmentSeqContext updateAssignmentSeq() throws RecognitionException {
UpdateAssignmentSeqContext _localctx = new UpdateAssignmentSeqContext(_ctx, getState());
enterRule(_localctx, 552, RULE_updateAssignmentSeq);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(6995);
((UpdateAssignmentSeqContext)_localctx).updateAssignment = updateAssignment();
((UpdateAssignmentSeqContext)_localctx).assignments.add(((UpdateAssignmentSeqContext)_localctx).updateAssignment);
setState(7000);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,967,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(6996);
match(COMMA);
setState(6997);
((UpdateAssignmentSeqContext)_localctx).updateAssignment = updateAssignment();
((UpdateAssignmentSeqContext)_localctx).assignments.add(((UpdateAssignmentSeqContext)_localctx).updateAssignment);
}
}
}
setState(7002);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,967,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LateralViewContext extends ParserRuleContext {
public IdentifierContext functionName;
public IdentifierContext tableName;
public IdentifierContext identifier;
public List<IdentifierContext> columnNames = new ArrayList<IdentifierContext>();
public TerminalNode LATERAL() { return getToken(PLParser.LATERAL, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public LateralViewContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lateralView; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLateralView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLateralView(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLateralView(this);
else return visitor.visitChildren(this);
}
}
public final LateralViewContext lateralView() throws RecognitionException {
LateralViewContext _localctx = new LateralViewContext(_ctx, getState());
enterRule(_localctx, 554, RULE_lateralView);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7003);
match(LATERAL);
setState(7004);
match(VIEW);
setState(7005);
((LateralViewContext)_localctx).functionName = identifier();
setState(7006);
match(LEFT_PAREN);
setState(7015);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(7007);
expression();
setState(7012);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7008);
match(COMMA);
setState(7009);
expression();
}
}
setState(7014);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(7017);
match(RIGHT_PAREN);
setState(7018);
((LateralViewContext)_localctx).tableName = identifier();
setState(7019);
match(AS);
setState(7020);
((LateralViewContext)_localctx).identifier = identifier();
((LateralViewContext)_localctx).columnNames.add(((LateralViewContext)_localctx).identifier);
setState(7025);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,970,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7021);
match(COMMA);
setState(7022);
((LateralViewContext)_localctx).identifier = identifier();
((LateralViewContext)_localctx).columnNames.add(((LateralViewContext)_localctx).identifier);
}
}
}
setState(7027);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,970,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryOrganizationContext extends ParserRuleContext {
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public QueryOrganizationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOrganization; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQueryOrganization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQueryOrganization(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQueryOrganization(this);
else return visitor.visitChildren(this);
}
}
public final QueryOrganizationContext queryOrganization() throws RecognitionException {
QueryOrganizationContext _localctx = new QueryOrganizationContext(_ctx, getState());
enterRule(_localctx, 556, RULE_queryOrganization);
try {
enterOuterAlt(_localctx, 1);
{
setState(7029);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,971,_ctx) ) {
case 1:
{
setState(7028);
sortClause();
}
break;
}
setState(7032);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,972,_ctx) ) {
case 1:
{
setState(7031);
limitClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortClauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public List<SortItemContext> sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public SortClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSortClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSortClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSortClause(this);
else return visitor.visitChildren(this);
}
}
public final SortClauseContext sortClause() throws RecognitionException {
SortClauseContext _localctx = new SortClauseContext(_ctx, getState());
enterRule(_localctx, 558, RULE_sortClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7034);
match(ORDER);
setState(7035);
match(BY);
setState(7036);
sortItem();
setState(7041);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,973,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7037);
match(COMMA);
setState(7038);
sortItem();
}
}
}
setState(7043);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,973,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortItemContext extends ParserRuleContext {
public Token ordering;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NULLS() { return getToken(PLParser.NULLS, 0); }
public TerminalNode FIRST() { return getToken(PLParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(PLParser.LAST, 0); }
public TerminalNode ASC() { return getToken(PLParser.ASC, 0); }
public TerminalNode DESC() { return getToken(PLParser.DESC, 0); }
public SortItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSortItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSortItem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSortItem(this);
else return visitor.visitChildren(this);
}
}
public final SortItemContext sortItem() throws RecognitionException {
SortItemContext _localctx = new SortItemContext(_ctx, getState());
enterRule(_localctx, 560, RULE_sortItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7044);
expression();
setState(7046);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,974,_ctx) ) {
case 1:
{
setState(7045);
((SortItemContext)_localctx).ordering = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
((SortItemContext)_localctx).ordering = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(7050);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,975,_ctx) ) {
case 1:
{
setState(7048);
match(NULLS);
setState(7049);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LimitClauseContext extends ParserRuleContext {
public Token limit;
public Token offset;
public TerminalNode LIMIT() { return getToken(PLParser.LIMIT, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public TerminalNode OFFSET() { return getToken(PLParser.OFFSET, 0); }
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public LimitClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLimitClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLimitClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLimitClause(this);
else return visitor.visitChildren(this);
}
}
public final LimitClauseContext limitClause() throws RecognitionException {
LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
enterRule(_localctx, 562, RULE_limitClause);
try {
setState(7062);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,976,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(7052);
match(LIMIT);
setState(7053);
((LimitClauseContext)_localctx).limit = match(INTEGER_VALUE);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
{
setState(7054);
match(LIMIT);
setState(7055);
((LimitClauseContext)_localctx).limit = match(INTEGER_VALUE);
setState(7056);
match(OFFSET);
setState(7057);
((LimitClauseContext)_localctx).offset = match(INTEGER_VALUE);
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
{
setState(7058);
match(LIMIT);
setState(7059);
((LimitClauseContext)_localctx).offset = match(INTEGER_VALUE);
setState(7060);
match(COMMA);
setState(7061);
((LimitClauseContext)_localctx).limit = match(INTEGER_VALUE);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionClauseContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PartitionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionClause(this);
else return visitor.visitChildren(this);
}
}
public final PartitionClauseContext partitionClause() throws RecognitionException {
PartitionClauseContext _localctx = new PartitionClauseContext(_ctx, getState());
enterRule(_localctx, 564, RULE_partitionClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7064);
match(PARTITION);
setState(7065);
match(BY);
setState(7066);
expression();
setState(7071);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7067);
match(COMMA);
setState(7068);
expression();
}
}
setState(7073);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JoinTypeContext extends ParserRuleContext {
public TerminalNode INNER() { return getToken(PLParser.INNER, 0); }
public TerminalNode CROSS() { return getToken(PLParser.CROSS, 0); }
public TerminalNode LEFT() { return getToken(PLParser.LEFT, 0); }
public TerminalNode OUTER() { return getToken(PLParser.OUTER, 0); }
public TerminalNode RIGHT() { return getToken(PLParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(PLParser.FULL, 0); }
public TerminalNode SEMI() { return getToken(PLParser.SEMI, 0); }
public TerminalNode ANTI() { return getToken(PLParser.ANTI, 0); }
public JoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterJoinType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitJoinType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitJoinType(this);
else return visitor.visitChildren(this);
}
}
public final JoinTypeContext joinType() throws RecognitionException {
JoinTypeContext _localctx = new JoinTypeContext(_ctx, getState());
enterRule(_localctx, 566, RULE_joinType);
int _la;
try {
setState(7098);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,982,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7075);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(7074);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7077);
match(CROSS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(7078);
match(LEFT);
setState(7080);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(7079);
match(OUTER);
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(7082);
match(RIGHT);
setState(7084);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(7083);
match(OUTER);
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(7086);
match(FULL);
setState(7088);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(7087);
match(OUTER);
}
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(7090);
match(LEFT);
setState(7091);
match(SEMI);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(7092);
match(RIGHT);
setState(7093);
match(SEMI);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(7094);
match(LEFT);
setState(7095);
match(ANTI);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(7096);
match(RIGHT);
setState(7097);
match(ANTI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JoinCriteriaContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public JoinCriteriaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinCriteria; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterJoinCriteria(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitJoinCriteria(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitJoinCriteria(this);
else return visitor.visitChildren(this);
}
}
public final JoinCriteriaContext joinCriteria() throws RecognitionException {
JoinCriteriaContext _localctx = new JoinCriteriaContext(_ctx, getState());
enterRule(_localctx, 568, RULE_joinCriteria);
try {
setState(7104);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ON:
enterOuterAlt(_localctx, 1);
{
setState(7100);
match(ON);
setState(7101);
booleanExpression(0);
}
break;
case USING:
enterOuterAlt(_localctx, 2);
{
setState(7102);
match(USING);
setState(7103);
identifierList();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifierList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifierList(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierListContext identifierList() throws RecognitionException {
IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState());
enterRule(_localctx, 570, RULE_identifierList);
try {
enterOuterAlt(_localctx, 1);
{
setState(7106);
match(LEFT_PAREN);
setState(7107);
identifierSeq();
setState(7108);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierSeqContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext errorCapturingIdentifier;
public List<ErrorCapturingIdentifierContext> ident = new ArrayList<ErrorCapturingIdentifierContext>();
public List<ErrorCapturingIdentifierContext> errorCapturingIdentifier() {
return getRuleContexts(ErrorCapturingIdentifierContext.class);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier(int i) {
return getRuleContext(ErrorCapturingIdentifierContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public IdentifierSeqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierSeq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifierSeq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifierSeq(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifierSeq(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierSeqContext identifierSeq() throws RecognitionException {
IdentifierSeqContext _localctx = new IdentifierSeqContext(_ctx, getState());
enterRule(_localctx, 572, RULE_identifierSeq);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7110);
((IdentifierSeqContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((IdentifierSeqContext)_localctx).ident.add(((IdentifierSeqContext)_localctx).errorCapturingIdentifier);
setState(7115);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,984,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7111);
match(COMMA);
setState(7112);
((IdentifierSeqContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((IdentifierSeqContext)_localctx).ident.add(((IdentifierSeqContext)_localctx).errorCapturingIdentifier);
}
}
}
setState(7117);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,984,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OptScanParamsContext extends ParserRuleContext {
public IdentifierContext funcName;
public PropertyItemListContext mapParams;
public IdentifierSeqContext listParams;
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public OptScanParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optScanParams; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterOptScanParams(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitOptScanParams(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitOptScanParams(this);
else return visitor.visitChildren(this);
}
}
public final OptScanParamsContext optScanParams() throws RecognitionException {
OptScanParamsContext _localctx = new OptScanParamsContext(_ctx, getState());
enterRule(_localctx, 574, RULE_optScanParams);
try {
enterOuterAlt(_localctx, 1);
{
setState(7118);
match(ATSIGN);
setState(7119);
((OptScanParamsContext)_localctx).funcName = identifier();
setState(7120);
match(LEFT_PAREN);
setState(7123);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,985,_ctx) ) {
case 1:
{
setState(7121);
((OptScanParamsContext)_localctx).mapParams = propertyItemList();
}
break;
case 2:
{
setState(7122);
((OptScanParamsContext)_localctx).listParams = identifierSeq();
}
break;
}
setState(7125);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationPrimaryContext extends ParserRuleContext {
public RelationPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationPrimary; }
public RelationPrimaryContext() { }
public void copyFrom(RelationPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableValuedFunctionContext extends RelationPrimaryContext {
public IdentifierContext tvfName;
public PropertyItemListContext properties;
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TableValuedFunctionContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTableValuedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTableValuedFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTableValuedFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RelationListContext extends RelationPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public RelationsContext relations() {
return getRuleContext(RelationsContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public RelationListContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRelationList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRelationList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRelationList(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AliasedQueryContext extends RelationPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public List<LateralViewContext> lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public AliasedQueryContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAliasedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAliasedQuery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAliasedQuery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableNameContext extends RelationPrimaryContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public OptScanParamsContext optScanParams() {
return getRuleContext(OptScanParamsContext.class,0);
}
public MaterializedViewNameContext materializedViewName() {
return getRuleContext(MaterializedViewNameContext.class,0);
}
public TableSnapshotContext tableSnapshot() {
return getRuleContext(TableSnapshotContext.class,0);
}
public SpecifiedPartitionContext specifiedPartition() {
return getRuleContext(SpecifiedPartitionContext.class,0);
}
public TabletListContext tabletList() {
return getRuleContext(TabletListContext.class,0);
}
public SampleContext sample() {
return getRuleContext(SampleContext.class,0);
}
public RelationHintContext relationHint() {
return getRuleContext(RelationHintContext.class,0);
}
public List<LateralViewContext> lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public TableNameContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTableName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTableName(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTableName(this);
else return visitor.visitChildren(this);
}
}
public final RelationPrimaryContext relationPrimary() throws RecognitionException {
RelationPrimaryContext _localctx = new RelationPrimaryContext(_ctx, getState());
enterRule(_localctx, 576, RULE_relationPrimary);
int _la;
try {
int _alt;
setState(7178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,996,_ctx) ) {
case 1:
_localctx = new TableNameContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(7127);
multipartIdentifier();
setState(7129);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,986,_ctx) ) {
case 1:
{
setState(7128);
optScanParams();
}
break;
}
setState(7132);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,987,_ctx) ) {
case 1:
{
setState(7131);
materializedViewName();
}
break;
}
setState(7135);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,988,_ctx) ) {
case 1:
{
setState(7134);
tableSnapshot();
}
break;
}
setState(7138);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,989,_ctx) ) {
case 1:
{
setState(7137);
specifiedPartition();
}
break;
}
setState(7141);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,990,_ctx) ) {
case 1:
{
setState(7140);
tabletList();
}
break;
}
setState(7143);
tableAlias();
setState(7145);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,991,_ctx) ) {
case 1:
{
setState(7144);
sample();
}
break;
}
setState(7148);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,992,_ctx) ) {
case 1:
{
setState(7147);
relationHint();
}
break;
}
setState(7153);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,993,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7150);
lateralView();
}
}
}
setState(7155);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,993,_ctx);
}
}
break;
case 2:
_localctx = new AliasedQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(7156);
match(LEFT_PAREN);
setState(7157);
query();
setState(7158);
match(RIGHT_PAREN);
setState(7159);
tableAlias();
setState(7163);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,994,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7160);
lateralView();
}
}
}
setState(7165);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,994,_ctx);
}
}
break;
case 3:
_localctx = new TableValuedFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(7166);
((TableValuedFunctionContext)_localctx).tvfName = identifier();
setState(7167);
match(LEFT_PAREN);
setState(7169);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3918131675812331519L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731842229283L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489932296231L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701645201671361L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -2730456240740152091L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305560947974124779L) != 0) || ((((_la - 714)) & ~0x3f) == 0 && ((1L << (_la - 714)) & 1761L) != 0)) {
{
setState(7168);
((TableValuedFunctionContext)_localctx).properties = propertyItemList();
}
}
setState(7171);
match(RIGHT_PAREN);
setState(7172);
tableAlias();
}
break;
case 4:
_localctx = new RelationListContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(7174);
match(LEFT_PAREN);
setState(7175);
relations();
setState(7176);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MaterializedViewNameContext extends ParserRuleContext {
public IdentifierContext indexName;
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MaterializedViewNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_materializedViewName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMaterializedViewName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMaterializedViewName(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMaterializedViewName(this);
else return visitor.visitChildren(this);
}
}
public final MaterializedViewNameContext materializedViewName() throws RecognitionException {
MaterializedViewNameContext _localctx = new MaterializedViewNameContext(_ctx, getState());
enterRule(_localctx, 578, RULE_materializedViewName);
try {
enterOuterAlt(_localctx, 1);
{
setState(7180);
match(INDEX);
setState(7181);
((MaterializedViewNameContext)_localctx).indexName = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyClauseContext extends ParserRuleContext {
public PropertyItemListContext fileProperties;
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public PropertyClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPropertyClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPropertyClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPropertyClause(this);
else return visitor.visitChildren(this);
}
}
public final PropertyClauseContext propertyClause() throws RecognitionException {
PropertyClauseContext _localctx = new PropertyClauseContext(_ctx, getState());
enterRule(_localctx, 580, RULE_propertyClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(7183);
match(PROPERTIES);
setState(7184);
match(LEFT_PAREN);
setState(7185);
((PropertyClauseContext)_localctx).fileProperties = propertyItemList();
setState(7186);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyItemListContext extends ParserRuleContext {
public PropertyItemContext propertyItem;
public List<PropertyItemContext> properties = new ArrayList<PropertyItemContext>();
public List<PropertyItemContext> propertyItem() {
return getRuleContexts(PropertyItemContext.class);
}
public PropertyItemContext propertyItem(int i) {
return getRuleContext(PropertyItemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PropertyItemListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyItemList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPropertyItemList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPropertyItemList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPropertyItemList(this);
else return visitor.visitChildren(this);
}
}
public final PropertyItemListContext propertyItemList() throws RecognitionException {
PropertyItemListContext _localctx = new PropertyItemListContext(_ctx, getState());
enterRule(_localctx, 582, RULE_propertyItemList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7188);
((PropertyItemListContext)_localctx).propertyItem = propertyItem();
((PropertyItemListContext)_localctx).properties.add(((PropertyItemListContext)_localctx).propertyItem);
setState(7193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,997,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7189);
match(COMMA);
setState(7190);
((PropertyItemListContext)_localctx).propertyItem = propertyItem();
((PropertyItemListContext)_localctx).properties.add(((PropertyItemListContext)_localctx).propertyItem);
}
}
}
setState(7195);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,997,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyItemContext extends ParserRuleContext {
public PropertyKeyContext key;
public PropertyValueContext value;
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public PropertyKeyContext propertyKey() {
return getRuleContext(PropertyKeyContext.class,0);
}
public PropertyValueContext propertyValue() {
return getRuleContext(PropertyValueContext.class,0);
}
public PropertyItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPropertyItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPropertyItem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPropertyItem(this);
else return visitor.visitChildren(this);
}
}
public final PropertyItemContext propertyItem() throws RecognitionException {
PropertyItemContext _localctx = new PropertyItemContext(_ctx, getState());
enterRule(_localctx, 584, RULE_propertyItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(7196);
((PropertyItemContext)_localctx).key = propertyKey();
setState(7197);
match(EQ);
setState(7198);
((PropertyItemContext)_localctx).value = propertyValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyKeyContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public PropertyKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPropertyKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPropertyKey(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPropertyKey(this);
else return visitor.visitChildren(this);
}
}
public final PropertyKeyContext propertyKey() throws RecognitionException {
PropertyKeyContext _localctx = new PropertyKeyContext(_ctx, getState());
enterRule(_localctx, 586, RULE_propertyKey);
try {
setState(7202);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,998,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7200);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7201);
constant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyValueContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public PropertyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPropertyValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final PropertyValueContext propertyValue() throws RecognitionException {
PropertyValueContext _localctx = new PropertyValueContext(_ctx, getState());
enterRule(_localctx, 588, RULE_propertyValue);
try {
setState(7206);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,999,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7204);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7205);
constant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableAliasContext extends ParserRuleContext {
public StrictIdentifierContext strictIdentifier() {
return getRuleContext(StrictIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TableAliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableAlias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTableAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTableAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTableAlias(this);
else return visitor.visitChildren(this);
}
}
public final TableAliasContext tableAlias() throws RecognitionException {
TableAliasContext _localctx = new TableAliasContext(_ctx, getState());
enterRule(_localctx, 590, RULE_tableAlias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7215);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1002,_ctx) ) {
case 1:
{
setState(7209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(7208);
match(AS);
}
}
setState(7211);
strictIdentifier();
setState(7213);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1001,_ctx) ) {
case 1:
{
setState(7212);
identifierList();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultipartIdentifierContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext errorCapturingIdentifier;
public List<ErrorCapturingIdentifierContext> parts = new ArrayList<ErrorCapturingIdentifierContext>();
public List<ErrorCapturingIdentifierContext> errorCapturingIdentifier() {
return getRuleContexts(ErrorCapturingIdentifierContext.class);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier(int i) {
return getRuleContext(ErrorCapturingIdentifierContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(PLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(PLParser.DOT, i);
}
public MultipartIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMultipartIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMultipartIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final MultipartIdentifierContext multipartIdentifier() throws RecognitionException {
MultipartIdentifierContext _localctx = new MultipartIdentifierContext(_ctx, getState());
enterRule(_localctx, 592, RULE_multipartIdentifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7217);
((MultipartIdentifierContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).errorCapturingIdentifier);
setState(7222);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1003,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7218);
match(DOT);
setState(7219);
((MultipartIdentifierContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).errorCapturingIdentifier);
}
}
}
setState(7224);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1003,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleColumnDefsContext extends ParserRuleContext {
public SimpleColumnDefContext simpleColumnDef;
public List<SimpleColumnDefContext> cols = new ArrayList<SimpleColumnDefContext>();
public List<SimpleColumnDefContext> simpleColumnDef() {
return getRuleContexts(SimpleColumnDefContext.class);
}
public SimpleColumnDefContext simpleColumnDef(int i) {
return getRuleContext(SimpleColumnDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public SimpleColumnDefsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleColumnDefs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSimpleColumnDefs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSimpleColumnDefs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSimpleColumnDefs(this);
else return visitor.visitChildren(this);
}
}
public final SimpleColumnDefsContext simpleColumnDefs() throws RecognitionException {
SimpleColumnDefsContext _localctx = new SimpleColumnDefsContext(_ctx, getState());
enterRule(_localctx, 594, RULE_simpleColumnDefs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7225);
((SimpleColumnDefsContext)_localctx).simpleColumnDef = simpleColumnDef();
((SimpleColumnDefsContext)_localctx).cols.add(((SimpleColumnDefsContext)_localctx).simpleColumnDef);
setState(7230);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7226);
match(COMMA);
setState(7227);
((SimpleColumnDefsContext)_localctx).simpleColumnDef = simpleColumnDef();
((SimpleColumnDefsContext)_localctx).cols.add(((SimpleColumnDefsContext)_localctx).simpleColumnDef);
}
}
setState(7232);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleColumnDefContext extends ParserRuleContext {
public IdentifierContext colName;
public Token comment;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public SimpleColumnDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleColumnDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSimpleColumnDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSimpleColumnDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSimpleColumnDef(this);
else return visitor.visitChildren(this);
}
}
public final SimpleColumnDefContext simpleColumnDef() throws RecognitionException {
SimpleColumnDefContext _localctx = new SimpleColumnDefContext(_ctx, getState());
enterRule(_localctx, 596, RULE_simpleColumnDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7233);
((SimpleColumnDefContext)_localctx).colName = identifier();
setState(7236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(7234);
match(COMMENT);
setState(7235);
((SimpleColumnDefContext)_localctx).comment = match(STRING_LITERAL);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnDefsContext extends ParserRuleContext {
public ColumnDefContext columnDef;
public List<ColumnDefContext> cols = new ArrayList<ColumnDefContext>();
public List<ColumnDefContext> columnDef() {
return getRuleContexts(ColumnDefContext.class);
}
public ColumnDefContext columnDef(int i) {
return getRuleContext(ColumnDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ColumnDefsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnDefs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColumnDefs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColumnDefs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColumnDefs(this);
else return visitor.visitChildren(this);
}
}
public final ColumnDefsContext columnDefs() throws RecognitionException {
ColumnDefsContext _localctx = new ColumnDefsContext(_ctx, getState());
enterRule(_localctx, 598, RULE_columnDefs);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7238);
((ColumnDefsContext)_localctx).columnDef = columnDef();
((ColumnDefsContext)_localctx).cols.add(((ColumnDefsContext)_localctx).columnDef);
setState(7243);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1006,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7239);
match(COMMA);
setState(7240);
((ColumnDefsContext)_localctx).columnDef = columnDef();
((ColumnDefsContext)_localctx).cols.add(((ColumnDefsContext)_localctx).columnDef);
}
}
}
setState(7245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1006,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnDefContext extends ParserRuleContext {
public IdentifierContext colName;
public DataTypeContext type;
public AggTypeDefContext aggType;
public ExpressionContext generatedExpr;
public Token nullable;
public NumberContext autoIncInitValue;
public Token nullValue;
public Token stringValue;
public Token defaultTimestamp;
public NumberContext defaultValuePrecision;
public NumberContext onUpdateValuePrecision;
public Token comment;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public List<TerminalNode> LEFT_PAREN() { return getTokens(PLParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(PLParser.LEFT_PAREN, i);
}
public List<TerminalNode> RIGHT_PAREN() { return getTokens(PLParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(PLParser.RIGHT_PAREN, i);
}
public TerminalNode AUTO_INCREMENT() { return getToken(PLParser.AUTO_INCREMENT, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public TerminalNode ON() { return getToken(PLParser.ON, 0); }
public TerminalNode UPDATE() { return getToken(PLParser.UPDATE, 0); }
public List<TerminalNode> CURRENT_TIMESTAMP() { return getTokens(PLParser.CURRENT_TIMESTAMP); }
public TerminalNode CURRENT_TIMESTAMP(int i) {
return getToken(PLParser.CURRENT_TIMESTAMP, i);
}
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public AggTypeDefContext aggTypeDef() {
return getRuleContext(AggTypeDefContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NULL() { return getTokens(PLParser.NULL); }
public TerminalNode NULL(int i) {
return getToken(PLParser.NULL, i);
}
public List<TerminalNode> STRING_LITERAL() { return getTokens(PLParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(PLParser.STRING_LITERAL, i);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode DECIMAL_VALUE() { return getToken(PLParser.DECIMAL_VALUE, 0); }
public TerminalNode PI() { return getToken(PLParser.PI, 0); }
public TerminalNode E() { return getToken(PLParser.E, 0); }
public TerminalNode BITMAP_EMPTY() { return getToken(PLParser.BITMAP_EMPTY, 0); }
public TerminalNode CURRENT_DATE() { return getToken(PLParser.CURRENT_DATE, 0); }
public TerminalNode GENERATED() { return getToken(PLParser.GENERATED, 0); }
public TerminalNode ALWAYS() { return getToken(PLParser.ALWAYS, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public List<NumberContext> number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public ColumnDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColumnDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColumnDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColumnDef(this);
else return visitor.visitChildren(this);
}
}
public final ColumnDefContext columnDef() throws RecognitionException {
ColumnDefContext _localctx = new ColumnDefContext(_ctx, getState());
enterRule(_localctx, 600, RULE_columnDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7246);
((ColumnDefContext)_localctx).colName = identifier();
setState(7247);
((ColumnDefContext)_localctx).type = dataType();
setState(7249);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1007,_ctx) ) {
case 1:
{
setState(7248);
match(KEY);
}
break;
}
setState(7252);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1008,_ctx) ) {
case 1:
{
setState(7251);
((ColumnDefContext)_localctx).aggType = aggTypeDef();
}
break;
}
setState(7263);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1010,_ctx) ) {
case 1:
{
setState(7256);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GENERATED) {
{
setState(7254);
match(GENERATED);
setState(7255);
match(ALWAYS);
}
}
setState(7258);
match(AS);
setState(7259);
match(LEFT_PAREN);
setState(7260);
((ColumnDefContext)_localctx).generatedExpr = expression();
setState(7261);
match(RIGHT_PAREN);
}
break;
}
setState(7269);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1012,_ctx) ) {
case 1:
{
setState(7266);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7265);
match(NOT);
}
}
setState(7268);
((ColumnDefContext)_localctx).nullable = match(NULL);
}
break;
}
setState(7278);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1014,_ctx) ) {
case 1:
{
setState(7271);
match(AUTO_INCREMENT);
setState(7276);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1013,_ctx) ) {
case 1:
{
setState(7272);
match(LEFT_PAREN);
setState(7273);
((ColumnDefContext)_localctx).autoIncInitValue = number();
setState(7274);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
setState(7304);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1019,_ctx) ) {
case 1:
{
setState(7280);
match(DEFAULT);
setState(7302);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1018,_ctx) ) {
case 1:
{
setState(7281);
((ColumnDefContext)_localctx).nullValue = match(NULL);
}
break;
case 2:
{
setState(7283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(7282);
match(SUBTRACT);
}
}
setState(7285);
match(INTEGER_VALUE);
}
break;
case 3:
{
setState(7287);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(7286);
match(SUBTRACT);
}
}
setState(7289);
match(DECIMAL_VALUE);
}
break;
case 4:
{
setState(7290);
match(PI);
}
break;
case 5:
{
setState(7291);
match(E);
}
break;
case 6:
{
setState(7292);
match(BITMAP_EMPTY);
}
break;
case 7:
{
setState(7293);
((ColumnDefContext)_localctx).stringValue = match(STRING_LITERAL);
}
break;
case 8:
{
setState(7294);
match(CURRENT_DATE);
}
break;
case 9:
{
setState(7295);
((ColumnDefContext)_localctx).defaultTimestamp = match(CURRENT_TIMESTAMP);
setState(7300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1017,_ctx) ) {
case 1:
{
setState(7296);
match(LEFT_PAREN);
setState(7297);
((ColumnDefContext)_localctx).defaultValuePrecision = number();
setState(7298);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
}
break;
}
setState(7315);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1021,_ctx) ) {
case 1:
{
setState(7306);
match(ON);
setState(7307);
match(UPDATE);
setState(7308);
match(CURRENT_TIMESTAMP);
setState(7313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1020,_ctx) ) {
case 1:
{
setState(7309);
match(LEFT_PAREN);
setState(7310);
((ColumnDefContext)_localctx).onUpdateValuePrecision = number();
setState(7311);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
setState(7319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1022,_ctx) ) {
case 1:
{
setState(7317);
match(COMMENT);
setState(7318);
((ColumnDefContext)_localctx).comment = match(STRING_LITERAL);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IndexDefsContext extends ParserRuleContext {
public IndexDefContext indexDef;
public List<IndexDefContext> indexes = new ArrayList<IndexDefContext>();
public List<IndexDefContext> indexDef() {
return getRuleContexts(IndexDefContext.class);
}
public IndexDefContext indexDef(int i) {
return getRuleContext(IndexDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public IndexDefsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexDefs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIndexDefs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIndexDefs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIndexDefs(this);
else return visitor.visitChildren(this);
}
}
public final IndexDefsContext indexDefs() throws RecognitionException {
IndexDefsContext _localctx = new IndexDefsContext(_ctx, getState());
enterRule(_localctx, 602, RULE_indexDefs);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7321);
((IndexDefsContext)_localctx).indexDef = indexDef();
((IndexDefsContext)_localctx).indexes.add(((IndexDefsContext)_localctx).indexDef);
setState(7326);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1023,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7322);
match(COMMA);
setState(7323);
((IndexDefsContext)_localctx).indexDef = indexDef();
((IndexDefsContext)_localctx).indexes.add(((IndexDefsContext)_localctx).indexDef);
}
}
}
setState(7328);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1023,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IndexDefContext extends ParserRuleContext {
public IdentifierContext indexName;
public IdentifierListContext cols;
public Token indexType;
public PropertyItemListContext properties;
public Token comment;
public TerminalNode INDEX() { return getToken(PLParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode BITMAP() { return getToken(PLParser.BITMAP, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode NGRAM_BF() { return getToken(PLParser.NGRAM_BF, 0); }
public IndexDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIndexDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIndexDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIndexDef(this);
else return visitor.visitChildren(this);
}
}
public final IndexDefContext indexDef() throws RecognitionException {
IndexDefContext _localctx = new IndexDefContext(_ctx, getState());
enterRule(_localctx, 604, RULE_indexDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7329);
match(INDEX);
setState(7333);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(7330);
match(IF);
setState(7331);
match(NOT);
setState(7332);
match(EXISTS);
}
}
setState(7335);
((IndexDefContext)_localctx).indexName = identifier();
setState(7336);
((IndexDefContext)_localctx).cols = identifierList();
setState(7339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1025,_ctx) ) {
case 1:
{
setState(7337);
match(USING);
setState(7338);
((IndexDefContext)_localctx).indexType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BITMAP || _la==INVERTED || _la==NGRAM_BF) ) {
((IndexDefContext)_localctx).indexType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(7346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1026,_ctx) ) {
case 1:
{
setState(7341);
match(PROPERTIES);
setState(7342);
match(LEFT_PAREN);
setState(7343);
((IndexDefContext)_localctx).properties = propertyItemList();
setState(7344);
match(RIGHT_PAREN);
}
break;
}
setState(7350);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1027,_ctx) ) {
case 1:
{
setState(7348);
match(COMMENT);
setState(7349);
((IndexDefContext)_localctx).comment = match(STRING_LITERAL);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionsDefContext extends ParserRuleContext {
public PartitionDefContext partitionDef;
public List<PartitionDefContext> partitions = new ArrayList<PartitionDefContext>();
public List<PartitionDefContext> partitionDef() {
return getRuleContexts(PartitionDefContext.class);
}
public PartitionDefContext partitionDef(int i) {
return getRuleContext(PartitionDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PartitionsDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionsDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionsDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionsDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionsDef(this);
else return visitor.visitChildren(this);
}
}
public final PartitionsDefContext partitionsDef() throws RecognitionException {
PartitionsDefContext _localctx = new PartitionsDefContext(_ctx, getState());
enterRule(_localctx, 606, RULE_partitionsDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7352);
((PartitionsDefContext)_localctx).partitionDef = partitionDef();
((PartitionsDefContext)_localctx).partitions.add(((PartitionsDefContext)_localctx).partitionDef);
setState(7357);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7353);
match(COMMA);
setState(7354);
((PartitionsDefContext)_localctx).partitionDef = partitionDef();
((PartitionsDefContext)_localctx).partitions.add(((PartitionsDefContext)_localctx).partitionDef);
}
}
setState(7359);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionDefContext extends ParserRuleContext {
public PropertyItemListContext partitionProperties;
public LessThanPartitionDefContext lessThanPartitionDef() {
return getRuleContext(LessThanPartitionDefContext.class,0);
}
public FixedPartitionDefContext fixedPartitionDef() {
return getRuleContext(FixedPartitionDefContext.class,0);
}
public StepPartitionDefContext stepPartitionDef() {
return getRuleContext(StepPartitionDefContext.class,0);
}
public InPartitionDefContext inPartitionDef() {
return getRuleContext(InPartitionDefContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PropertyItemListContext propertyItemList() {
return getRuleContext(PropertyItemListContext.class,0);
}
public PartitionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionDef(this);
else return visitor.visitChildren(this);
}
}
public final PartitionDefContext partitionDef() throws RecognitionException {
PartitionDefContext _localctx = new PartitionDefContext(_ctx, getState());
enterRule(_localctx, 608, RULE_partitionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7364);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1029,_ctx) ) {
case 1:
{
setState(7360);
lessThanPartitionDef();
}
break;
case 2:
{
setState(7361);
fixedPartitionDef();
}
break;
case 3:
{
setState(7362);
stepPartitionDef();
}
break;
case 4:
{
setState(7363);
inPartitionDef();
}
break;
}
setState(7370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(7366);
match(LEFT_PAREN);
setState(7367);
((PartitionDefContext)_localctx).partitionProperties = propertyItemList();
setState(7368);
match(RIGHT_PAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LessThanPartitionDefContext extends ParserRuleContext {
public IdentifierContext partitionName;
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode VALUES() { return getToken(PLParser.VALUES, 0); }
public TerminalNode LESS() { return getToken(PLParser.LESS, 0); }
public TerminalNode THAN() { return getToken(PLParser.THAN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode MAXVALUE() { return getToken(PLParser.MAXVALUE, 0); }
public PartitionValueListContext partitionValueList() {
return getRuleContext(PartitionValueListContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public LessThanPartitionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lessThanPartitionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLessThanPartitionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLessThanPartitionDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLessThanPartitionDef(this);
else return visitor.visitChildren(this);
}
}
public final LessThanPartitionDefContext lessThanPartitionDef() throws RecognitionException {
LessThanPartitionDefContext _localctx = new LessThanPartitionDefContext(_ctx, getState());
enterRule(_localctx, 610, RULE_lessThanPartitionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7372);
match(PARTITION);
setState(7376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(7373);
match(IF);
setState(7374);
match(NOT);
setState(7375);
match(EXISTS);
}
}
setState(7378);
((LessThanPartitionDefContext)_localctx).partitionName = identifier();
setState(7379);
match(VALUES);
setState(7380);
match(LESS);
setState(7381);
match(THAN);
setState(7384);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MAXVALUE:
{
setState(7382);
match(MAXVALUE);
}
break;
case LEFT_PAREN:
{
setState(7383);
partitionValueList();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FixedPartitionDefContext extends ParserRuleContext {
public IdentifierContext partitionName;
public PartitionValueListContext lower;
public PartitionValueListContext upper;
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public TerminalNode VALUES() { return getToken(PLParser.VALUES, 0); }
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<PartitionValueListContext> partitionValueList() {
return getRuleContexts(PartitionValueListContext.class);
}
public PartitionValueListContext partitionValueList(int i) {
return getRuleContext(PartitionValueListContext.class,i);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public FixedPartitionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fixedPartitionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFixedPartitionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFixedPartitionDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFixedPartitionDef(this);
else return visitor.visitChildren(this);
}
}
public final FixedPartitionDefContext fixedPartitionDef() throws RecognitionException {
FixedPartitionDefContext _localctx = new FixedPartitionDefContext(_ctx, getState());
enterRule(_localctx, 612, RULE_fixedPartitionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7386);
match(PARTITION);
setState(7390);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(7387);
match(IF);
setState(7388);
match(NOT);
setState(7389);
match(EXISTS);
}
}
setState(7392);
((FixedPartitionDefContext)_localctx).partitionName = identifier();
setState(7393);
match(VALUES);
setState(7394);
match(LEFT_BRACKET);
setState(7395);
((FixedPartitionDefContext)_localctx).lower = partitionValueList();
setState(7396);
match(COMMA);
setState(7397);
((FixedPartitionDefContext)_localctx).upper = partitionValueList();
setState(7398);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StepPartitionDefContext extends ParserRuleContext {
public PartitionValueListContext from;
public PartitionValueListContext to;
public Token unitsAmount;
public UnitIdentifierContext unit;
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode TO() { return getToken(PLParser.TO, 0); }
public TerminalNode INTERVAL() { return getToken(PLParser.INTERVAL, 0); }
public List<PartitionValueListContext> partitionValueList() {
return getRuleContexts(PartitionValueListContext.class);
}
public PartitionValueListContext partitionValueList(int i) {
return getRuleContext(PartitionValueListContext.class,i);
}
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public UnitIdentifierContext unitIdentifier() {
return getRuleContext(UnitIdentifierContext.class,0);
}
public StepPartitionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stepPartitionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStepPartitionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStepPartitionDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStepPartitionDef(this);
else return visitor.visitChildren(this);
}
}
public final StepPartitionDefContext stepPartitionDef() throws RecognitionException {
StepPartitionDefContext _localctx = new StepPartitionDefContext(_ctx, getState());
enterRule(_localctx, 614, RULE_stepPartitionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7400);
match(FROM);
setState(7401);
((StepPartitionDefContext)_localctx).from = partitionValueList();
setState(7402);
match(TO);
setState(7403);
((StepPartitionDefContext)_localctx).to = partitionValueList();
setState(7404);
match(INTERVAL);
setState(7405);
((StepPartitionDefContext)_localctx).unitsAmount = match(INTEGER_VALUE);
setState(7407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAY || _la==HOUR || _la==MINUTE || _la==MONTH || _la==SECOND || _la==WEEK || _la==YEAR) {
{
setState(7406);
((StepPartitionDefContext)_localctx).unit = unitIdentifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InPartitionDefContext extends ParserRuleContext {
public IdentifierContext partitionName;
public PartitionValueListContext partitionValueList;
public List<PartitionValueListContext> partitionValueLists = new ArrayList<PartitionValueListContext>();
public PartitionValueListContext constants;
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode VALUES() { return getToken(PLParser.VALUES, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public List<PartitionValueListContext> partitionValueList() {
return getRuleContexts(PartitionValueListContext.class);
}
public PartitionValueListContext partitionValueList(int i) {
return getRuleContext(PartitionValueListContext.class,i);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public InPartitionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inPartitionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInPartitionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInPartitionDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInPartitionDef(this);
else return visitor.visitChildren(this);
}
}
public final InPartitionDefContext inPartitionDef() throws RecognitionException {
InPartitionDefContext _localctx = new InPartitionDefContext(_ctx, getState());
enterRule(_localctx, 616, RULE_inPartitionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7409);
match(PARTITION);
setState(7413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(7410);
match(IF);
setState(7411);
match(NOT);
setState(7412);
match(EXISTS);
}
}
setState(7415);
((InPartitionDefContext)_localctx).partitionName = identifier();
setState(7434);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1039,_ctx) ) {
case 1:
{
setState(7418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==VALUES) {
{
setState(7416);
match(VALUES);
setState(7417);
match(IN);
}
}
setState(7432);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1038,_ctx) ) {
case 1:
{
{
setState(7420);
match(LEFT_PAREN);
setState(7421);
((InPartitionDefContext)_localctx).partitionValueList = partitionValueList();
((InPartitionDefContext)_localctx).partitionValueLists.add(((InPartitionDefContext)_localctx).partitionValueList);
setState(7426);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7422);
match(COMMA);
setState(7423);
((InPartitionDefContext)_localctx).partitionValueList = partitionValueList();
((InPartitionDefContext)_localctx).partitionValueLists.add(((InPartitionDefContext)_localctx).partitionValueList);
}
}
setState(7428);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7429);
match(RIGHT_PAREN);
}
}
break;
case 2:
{
setState(7431);
((InPartitionDefContext)_localctx).constants = partitionValueList();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionValueListContext extends ParserRuleContext {
public PartitionValueDefContext partitionValueDef;
public List<PartitionValueDefContext> values = new ArrayList<PartitionValueDefContext>();
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<PartitionValueDefContext> partitionValueDef() {
return getRuleContexts(PartitionValueDefContext.class);
}
public PartitionValueDefContext partitionValueDef(int i) {
return getRuleContext(PartitionValueDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PartitionValueListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionValueList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionValueList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionValueList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionValueList(this);
else return visitor.visitChildren(this);
}
}
public final PartitionValueListContext partitionValueList() throws RecognitionException {
PartitionValueListContext _localctx = new PartitionValueListContext(_ctx, getState());
enterRule(_localctx, 618, RULE_partitionValueList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7436);
match(LEFT_PAREN);
setState(7437);
((PartitionValueListContext)_localctx).partitionValueDef = partitionValueDef();
((PartitionValueListContext)_localctx).values.add(((PartitionValueListContext)_localctx).partitionValueDef);
setState(7442);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7438);
match(COMMA);
setState(7439);
((PartitionValueListContext)_localctx).partitionValueDef = partitionValueDef();
((PartitionValueListContext)_localctx).values.add(((PartitionValueListContext)_localctx).partitionValueDef);
}
}
setState(7444);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7445);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionValueDefContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode MAXVALUE() { return getToken(PLParser.MAXVALUE, 0); }
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public PartitionValueDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionValueDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPartitionValueDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPartitionValueDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPartitionValueDef(this);
else return visitor.visitChildren(this);
}
}
public final PartitionValueDefContext partitionValueDef() throws RecognitionException {
PartitionValueDefContext _localctx = new PartitionValueDefContext(_ctx, getState());
enterRule(_localctx, 620, RULE_partitionValueDef);
int _la;
try {
setState(7454);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUBTRACT:
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(7448);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(7447);
match(SUBTRACT);
}
}
setState(7450);
match(INTEGER_VALUE);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(7451);
match(STRING_LITERAL);
}
break;
case MAXVALUE:
enterOuterAlt(_localctx, 3);
{
setState(7452);
match(MAXVALUE);
}
break;
case NULL:
enterOuterAlt(_localctx, 4);
{
setState(7453);
match(NULL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RollupDefsContext extends ParserRuleContext {
public RollupDefContext rollupDef;
public List<RollupDefContext> rollups = new ArrayList<RollupDefContext>();
public List<RollupDefContext> rollupDef() {
return getRuleContexts(RollupDefContext.class);
}
public RollupDefContext rollupDef(int i) {
return getRuleContext(RollupDefContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public RollupDefsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollupDefs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRollupDefs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRollupDefs(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRollupDefs(this);
else return visitor.visitChildren(this);
}
}
public final RollupDefsContext rollupDefs() throws RecognitionException {
RollupDefsContext _localctx = new RollupDefsContext(_ctx, getState());
enterRule(_localctx, 622, RULE_rollupDefs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7456);
((RollupDefsContext)_localctx).rollupDef = rollupDef();
((RollupDefsContext)_localctx).rollups.add(((RollupDefsContext)_localctx).rollupDef);
setState(7461);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7457);
match(COMMA);
setState(7458);
((RollupDefsContext)_localctx).rollupDef = rollupDef();
((RollupDefsContext)_localctx).rollups.add(((RollupDefsContext)_localctx).rollupDef);
}
}
setState(7463);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RollupDefContext extends ParserRuleContext {
public IdentifierContext rollupName;
public IdentifierListContext rollupCols;
public IdentifierListContext dupKeys;
public PropertyClauseContext properties;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<IdentifierListContext> identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public TerminalNode DUPLICATE() { return getToken(PLParser.DUPLICATE, 0); }
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public RollupDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollupDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRollupDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRollupDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRollupDef(this);
else return visitor.visitChildren(this);
}
}
public final RollupDefContext rollupDef() throws RecognitionException {
RollupDefContext _localctx = new RollupDefContext(_ctx, getState());
enterRule(_localctx, 624, RULE_rollupDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7464);
((RollupDefContext)_localctx).rollupName = identifier();
setState(7465);
((RollupDefContext)_localctx).rollupCols = identifierList();
setState(7469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DUPLICATE) {
{
setState(7466);
match(DUPLICATE);
setState(7467);
match(KEY);
setState(7468);
((RollupDefContext)_localctx).dupKeys = identifierList();
}
}
setState(7472);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROPERTIES) {
{
setState(7471);
((RollupDefContext)_localctx).properties = propertyClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AggTypeDefContext extends ParserRuleContext {
public TerminalNode MAX() { return getToken(PLParser.MAX, 0); }
public TerminalNode MIN() { return getToken(PLParser.MIN, 0); }
public TerminalNode SUM() { return getToken(PLParser.SUM, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode REPLACE_IF_NOT_NULL() { return getToken(PLParser.REPLACE_IF_NOT_NULL, 0); }
public TerminalNode HLL_UNION() { return getToken(PLParser.HLL_UNION, 0); }
public TerminalNode BITMAP_UNION() { return getToken(PLParser.BITMAP_UNION, 0); }
public TerminalNode QUANTILE_UNION() { return getToken(PLParser.QUANTILE_UNION, 0); }
public TerminalNode GENERIC() { return getToken(PLParser.GENERIC, 0); }
public AggTypeDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggTypeDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAggTypeDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAggTypeDef(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAggTypeDef(this);
else return visitor.visitChildren(this);
}
}
public final AggTypeDefContext aggTypeDef() throws RecognitionException {
AggTypeDefContext _localctx = new AggTypeDefContext(_ctx, getState());
enterRule(_localctx, 626, RULE_aggTypeDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7474);
_la = _input.LA(1);
if ( !(_la==BITMAP_UNION || _la==GENERIC || _la==HLL_UNION || _la==MAX || _la==MIN || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & 786433L) != 0) || _la==SUM) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TabletListContext extends ParserRuleContext {
public Token INTEGER_VALUE;
public List<Token> tabletIdList = new ArrayList<Token>();
public TerminalNode TABLET() { return getToken(PLParser.TABLET, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TabletListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tabletList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTabletList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTabletList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTabletList(this);
else return visitor.visitChildren(this);
}
}
public final TabletListContext tabletList() throws RecognitionException {
TabletListContext _localctx = new TabletListContext(_ctx, getState());
enterRule(_localctx, 628, RULE_tabletList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7476);
match(TABLET);
setState(7477);
match(LEFT_PAREN);
setState(7478);
((TabletListContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((TabletListContext)_localctx).tabletIdList.add(((TabletListContext)_localctx).INTEGER_VALUE);
setState(7483);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7479);
match(COMMA);
setState(7480);
((TabletListContext)_localctx).INTEGER_VALUE = match(INTEGER_VALUE);
((TabletListContext)_localctx).tabletIdList.add(((TabletListContext)_localctx).INTEGER_VALUE);
}
}
setState(7485);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7486);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InlineTableContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(PLParser.VALUES, 0); }
public List<RowConstructorContext> rowConstructor() {
return getRuleContexts(RowConstructorContext.class);
}
public RowConstructorContext rowConstructor(int i) {
return getRuleContext(RowConstructorContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public InlineTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inlineTable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInlineTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInlineTable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInlineTable(this);
else return visitor.visitChildren(this);
}
}
public final InlineTableContext inlineTable() throws RecognitionException {
InlineTableContext _localctx = new InlineTableContext(_ctx, getState());
enterRule(_localctx, 630, RULE_inlineTable);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7488);
match(VALUES);
setState(7489);
rowConstructor();
setState(7494);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1047,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7490);
match(COMMA);
setState(7491);
rowConstructor();
}
}
}
setState(7496);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1047,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NamedExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public NamedExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNamedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNamedExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNamedExpression(this);
else return visitor.visitChildren(this);
}
}
public final NamedExpressionContext namedExpression() throws RecognitionException {
NamedExpressionContext _localctx = new NamedExpressionContext(_ctx, getState());
enterRule(_localctx, 632, RULE_namedExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7497);
expression();
setState(7502);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1049,_ctx) ) {
case 1:
{
setState(7499);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(7498);
match(AS);
}
}
{
setState(7501);
identifierOrText();
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NamedExpressionSeqContext extends ParserRuleContext {
public List<NamedExpressionContext> namedExpression() {
return getRuleContexts(NamedExpressionContext.class);
}
public NamedExpressionContext namedExpression(int i) {
return getRuleContext(NamedExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public NamedExpressionSeqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedExpressionSeq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNamedExpressionSeq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNamedExpressionSeq(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNamedExpressionSeq(this);
else return visitor.visitChildren(this);
}
}
public final NamedExpressionSeqContext namedExpressionSeq() throws RecognitionException {
NamedExpressionSeqContext _localctx = new NamedExpressionSeqContext(_ctx, getState());
enterRule(_localctx, 634, RULE_namedExpressionSeq);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7504);
namedExpression();
setState(7509);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1050,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7505);
match(COMMA);
setState(7506);
namedExpression();
}
}
}
setState(7511);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1050,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public LambdaExpressionContext lambdaExpression() {
return getRuleContext(LambdaExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 636, RULE_expression);
try {
setState(7514);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1051,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7512);
booleanExpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7513);
lambdaExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LambdaExpressionContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext errorCapturingIdentifier;
public List<ErrorCapturingIdentifierContext> args = new ArrayList<ErrorCapturingIdentifierContext>();
public BooleanExpressionContext body;
public TerminalNode ARROW() { return getToken(PLParser.ARROW, 0); }
public List<ErrorCapturingIdentifierContext> errorCapturingIdentifier() {
return getRuleContexts(ErrorCapturingIdentifierContext.class);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier(int i) {
return getRuleContext(ErrorCapturingIdentifierContext.class,i);
}
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public LambdaExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLambdaExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLambdaExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLambdaExpression(this);
else return visitor.visitChildren(this);
}
}
public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
enterRule(_localctx, 638, RULE_lambdaExpression);
int _la;
try {
setState(7532);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(7516);
((LambdaExpressionContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((LambdaExpressionContext)_localctx).args.add(((LambdaExpressionContext)_localctx).errorCapturingIdentifier);
setState(7517);
match(ARROW);
setState(7518);
((LambdaExpressionContext)_localctx).body = booleanExpression(0);
}
break;
case LEFT_PAREN:
enterOuterAlt(_localctx, 2);
{
setState(7520);
match(LEFT_PAREN);
setState(7521);
((LambdaExpressionContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((LambdaExpressionContext)_localctx).args.add(((LambdaExpressionContext)_localctx).errorCapturingIdentifier);
setState(7524);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(7522);
match(COMMA);
setState(7523);
((LambdaExpressionContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((LambdaExpressionContext)_localctx).args.add(((LambdaExpressionContext)_localctx).errorCapturingIdentifier);
}
}
setState(7526);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(7528);
match(RIGHT_PAREN);
setState(7529);
match(ARROW);
setState(7530);
((LambdaExpressionContext)_localctx).body = booleanExpression(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanExpressionContext extends ParserRuleContext {
public BooleanExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanExpression; }
public BooleanExpressionContext() { }
public void copyFrom(BooleanExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExistContext extends BooleanExpressionContext {
public TerminalNode EXISTS() { return getToken(PLParser.EXISTS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ExistContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExist(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExist(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalNotContext extends BooleanExpressionContext {
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode LOGICALNOT() { return getToken(PLParser.LOGICALNOT, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public LogicalNotContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLogicalNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLogicalNot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLogicalNot(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PredicatedContext extends BooleanExpressionContext {
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public PredicatedContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPredicated(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPredicated(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPredicated(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IsnullContext extends BooleanExpressionContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode ISNULL() { return getToken(PLParser.ISNULL, 0); }
public TerminalNode IS_NULL_PRED() { return getToken(PLParser.IS_NULL_PRED, 0); }
public IsnullContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIsnull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIsnull(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIsnull(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class Is_not_null_predContext extends BooleanExpressionContext {
public TerminalNode IS_NOT_NULL_PRED() { return getToken(PLParser.IS_NOT_NULL_PRED, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public Is_not_null_predContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIs_not_null_pred(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIs_not_null_pred(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIs_not_null_pred(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalBinaryContext extends BooleanExpressionContext {
public BooleanExpressionContext left;
public Token operator;
public BooleanExpressionContext right;
public List<BooleanExpressionContext> booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public TerminalNode LOGICALAND() { return getToken(PLParser.LOGICALAND, 0); }
public TerminalNode XOR() { return getToken(PLParser.XOR, 0); }
public TerminalNode OR() { return getToken(PLParser.OR, 0); }
public LogicalBinaryContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLogicalBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLogicalBinary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLogicalBinary(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DoublePipesContext extends BooleanExpressionContext {
public BooleanExpressionContext left;
public Token operator;
public BooleanExpressionContext right;
public List<BooleanExpressionContext> booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public TerminalNode DOUBLEPIPES() { return getToken(PLParser.DOUBLEPIPES, 0); }
public DoublePipesContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDoublePipes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDoublePipes(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDoublePipes(this);
else return visitor.visitChildren(this);
}
}
public final BooleanExpressionContext booleanExpression() throws RecognitionException {
return booleanExpression(0);
}
private BooleanExpressionContext booleanExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BooleanExpressionContext _localctx = new BooleanExpressionContext(_ctx, _parentState);
BooleanExpressionContext _prevctx = _localctx;
int _startState = 640;
enterRecursionRule(_localctx, 640, RULE_booleanExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7556);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1055,_ctx) ) {
case 1:
{
_localctx = new LogicalNotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7535);
_la = _input.LA(1);
if ( !(_la==NOT || _la==LOGICALNOT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7536);
booleanExpression(9);
}
break;
case 2:
{
_localctx = new ExistContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7537);
match(EXISTS);
setState(7538);
match(LEFT_PAREN);
setState(7539);
query();
setState(7540);
match(RIGHT_PAREN);
}
break;
case 3:
{
_localctx = new IsnullContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7542);
_la = _input.LA(1);
if ( !(_la==IS_NULL_PRED || _la==ISNULL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7543);
match(LEFT_PAREN);
setState(7544);
valueExpression(0);
setState(7545);
match(RIGHT_PAREN);
}
break;
case 4:
{
_localctx = new Is_not_null_predContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7547);
match(IS_NOT_NULL_PRED);
setState(7548);
match(LEFT_PAREN);
setState(7549);
valueExpression(0);
setState(7550);
match(RIGHT_PAREN);
}
break;
case 5:
{
_localctx = new PredicatedContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7552);
valueExpression(0);
setState(7554);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1054,_ctx) ) {
case 1:
{
setState(7553);
predicate();
}
break;
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(7572);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1057,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(7570);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1056,_ctx) ) {
case 1:
{
_localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
((LogicalBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(7558);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(7559);
((LogicalBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==AND || _la==LOGICALAND) ) {
((LogicalBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7560);
((LogicalBinaryContext)_localctx).right = booleanExpression(5);
}
break;
case 2:
{
_localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
((LogicalBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(7561);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(7562);
((LogicalBinaryContext)_localctx).operator = match(XOR);
setState(7563);
((LogicalBinaryContext)_localctx).right = booleanExpression(4);
}
break;
case 3:
{
_localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
((LogicalBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(7564);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(7565);
((LogicalBinaryContext)_localctx).operator = match(OR);
setState(7566);
((LogicalBinaryContext)_localctx).right = booleanExpression(3);
}
break;
case 4:
{
_localctx = new DoublePipesContext(new BooleanExpressionContext(_parentctx, _parentState));
((DoublePipesContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(7567);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(7568);
((DoublePipesContext)_localctx).operator = match(DOUBLEPIPES);
setState(7569);
((DoublePipesContext)_localctx).right = booleanExpression(2);
}
break;
}
}
}
setState(7574);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1057,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RowConstructorContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<RowConstructorItemContext> rowConstructorItem() {
return getRuleContexts(RowConstructorItemContext.class);
}
public RowConstructorItemContext rowConstructorItem(int i) {
return getRuleContext(RowConstructorItemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public RowConstructorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowConstructor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRowConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRowConstructor(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRowConstructor(this);
else return visitor.visitChildren(this);
}
}
public final RowConstructorContext rowConstructor() throws RecognitionException {
RowConstructorContext _localctx = new RowConstructorContext(_ctx, getState());
enterRule(_localctx, 642, RULE_rowConstructor);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7575);
match(LEFT_PAREN);
setState(7584);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1787005457973895167L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(7576);
rowConstructorItem();
setState(7581);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7577);
match(COMMA);
setState(7578);
rowConstructorItem();
}
}
setState(7583);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(7586);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RowConstructorItemContext extends ParserRuleContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public NamedExpressionContext namedExpression() {
return getRuleContext(NamedExpressionContext.class,0);
}
public RowConstructorItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowConstructorItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRowConstructorItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRowConstructorItem(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRowConstructorItem(this);
else return visitor.visitChildren(this);
}
}
public final RowConstructorItemContext rowConstructorItem() throws RecognitionException {
RowConstructorItemContext _localctx = new RowConstructorItemContext(_ctx, getState());
enterRule(_localctx, 644, RULE_rowConstructorItem);
try {
setState(7591);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1060,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7588);
constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7589);
match(DEFAULT);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(7590);
namedExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PredicateContext extends ParserRuleContext {
public Token kind;
public ValueExpressionContext lower;
public ValueExpressionContext upper;
public ValueExpressionContext pattern;
public ValueExpressionContext escape;
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public TerminalNode BETWEEN() { return getToken(PLParser.BETWEEN, 0); }
public List<ValueExpressionContext> valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public TerminalNode REGEXP() { return getToken(PLParser.REGEXP, 0); }
public TerminalNode RLIKE() { return getToken(PLParser.RLIKE, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode ESCAPE() { return getToken(PLParser.ESCAPE, 0); }
public TerminalNode MATCH() { return getToken(PLParser.MATCH, 0); }
public TerminalNode MATCH_ANY() { return getToken(PLParser.MATCH_ANY, 0); }
public TerminalNode MATCH_ALL() { return getToken(PLParser.MATCH_ALL, 0); }
public TerminalNode MATCH_PHRASE() { return getToken(PLParser.MATCH_PHRASE, 0); }
public TerminalNode MATCH_PHRASE_PREFIX() { return getToken(PLParser.MATCH_PHRASE_PREFIX, 0); }
public TerminalNode MATCH_REGEXP() { return getToken(PLParser.MATCH_REGEXP, 0); }
public TerminalNode MATCH_PHRASE_EDGE() { return getToken(PLParser.MATCH_PHRASE_EDGE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode IN() { return getToken(PLParser.IN, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode IS() { return getToken(PLParser.IS, 0); }
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public TerminalNode TRUE() { return getToken(PLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(PLParser.FALSE, 0); }
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPredicate(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPredicate(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState());
enterRule(_localctx, 646, RULE_predicate);
int _la;
try {
setState(7653);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1071,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7594);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7593);
match(NOT);
}
}
setState(7596);
((PredicateContext)_localctx).kind = match(BETWEEN);
setState(7597);
((PredicateContext)_localctx).lower = valueExpression(0);
setState(7598);
match(AND);
setState(7599);
((PredicateContext)_localctx).upper = valueExpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7602);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7601);
match(NOT);
}
}
setState(7604);
((PredicateContext)_localctx).kind = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==REGEXP || _la==RLIKE) ) {
((PredicateContext)_localctx).kind = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7605);
((PredicateContext)_localctx).pattern = valueExpression(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(7607);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7606);
match(NOT);
}
}
setState(7609);
((PredicateContext)_localctx).kind = match(LIKE);
setState(7610);
((PredicateContext)_localctx).pattern = valueExpression(0);
setState(7613);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1064,_ctx) ) {
case 1:
{
setState(7611);
match(ESCAPE);
setState(7612);
((PredicateContext)_localctx).escape = valueExpression(0);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(7616);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7615);
match(NOT);
}
}
setState(7618);
((PredicateContext)_localctx).kind = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 455)) & ~0x3f) == 0 && ((1L << (_la - 455)) & 127L) != 0)) ) {
((PredicateContext)_localctx).kind = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7619);
((PredicateContext)_localctx).pattern = valueExpression(0);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(7621);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7620);
match(NOT);
}
}
setState(7623);
((PredicateContext)_localctx).kind = match(IN);
setState(7624);
match(LEFT_PAREN);
setState(7625);
query();
setState(7626);
match(RIGHT_PAREN);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(7629);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7628);
match(NOT);
}
}
setState(7631);
((PredicateContext)_localctx).kind = match(IN);
setState(7632);
match(LEFT_PAREN);
setState(7633);
expression();
setState(7638);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7634);
match(COMMA);
setState(7635);
expression();
}
}
setState(7640);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7641);
match(RIGHT_PAREN);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(7643);
match(IS);
setState(7645);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7644);
match(NOT);
}
}
setState(7647);
((PredicateContext)_localctx).kind = match(NULL);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(7648);
match(IS);
setState(7650);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(7649);
match(NOT);
}
}
setState(7652);
((PredicateContext)_localctx).kind = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
((PredicateContext)_localctx).kind = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionContext extends ParserRuleContext {
public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueExpression; }
public ValueExpressionContext() { }
public void copyFrom(ValueExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionDefaultContext extends ValueExpressionContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionDefaultContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterValueExpressionDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitValueExpressionDefault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitValueExpressionDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends ValueExpressionContext {
public ValueExpressionContext left;
public ValueExpressionContext right;
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public List<ValueExpressionContext> valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public ComparisonContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitComparison(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticBinaryContext extends ValueExpressionContext {
public ValueExpressionContext left;
public Token operator;
public ValueExpressionContext right;
public List<ValueExpressionContext> valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(PLParser.SLASH, 0); }
public TerminalNode MOD() { return getToken(PLParser.MOD, 0); }
public TerminalNode DIV() { return getToken(PLParser.DIV, 0); }
public TerminalNode PLUS() { return getToken(PLParser.PLUS, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public TerminalNode HAT() { return getToken(PLParser.HAT, 0); }
public TerminalNode PIPE() { return getToken(PLParser.PIPE, 0); }
public TerminalNode AMPERSAND() { return getToken(PLParser.AMPERSAND, 0); }
public ArithmeticBinaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterArithmeticBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitArithmeticBinary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitArithmeticBinary(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticUnaryContext extends ValueExpressionContext {
public Token operator;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public TerminalNode PLUS() { return getToken(PLParser.PLUS, 0); }
public TerminalNode TILDE() { return getToken(PLParser.TILDE, 0); }
public ArithmeticUnaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterArithmeticUnary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitArithmeticUnary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitArithmeticUnary(this);
else return visitor.visitChildren(this);
}
}
public final ValueExpressionContext valueExpression() throws RecognitionException {
return valueExpression(0);
}
private ValueExpressionContext valueExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, _parentState);
ValueExpressionContext _prevctx = _localctx;
int _startState = 648;
enterRecursionRule(_localctx, 648, RULE_valueExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7659);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1072,_ctx) ) {
case 1:
{
_localctx = new ValueExpressionDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7656);
primaryExpression(0);
}
break;
case 2:
{
_localctx = new ArithmeticUnaryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7657);
((ArithmeticUnaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 695)) & ~0x3f) == 0 && ((1L << (_la - 695)) & 35L) != 0)) ) {
((ArithmeticUnaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7658);
valueExpression(4);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(7673);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1074,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(7671);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1073,_ctx) ) {
case 1:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(7661);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(7662);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DIV || ((((_la - 697)) & ~0x3f) == 0 && ((1L << (_la - 697)) & 7L) != 0)) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7663);
((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
}
break;
case 2:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(7664);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(7665);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 695)) & ~0x3f) == 0 && ((1L << (_la - 695)) & 2627L) != 0)) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7666);
((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
}
break;
case 3:
{
_localctx = new ComparisonContext(new ValueExpressionContext(_parentctx, _parentState));
((ComparisonContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(7667);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(7668);
comparisonOperator();
setState(7669);
((ComparisonContext)_localctx).right = valueExpression(2);
}
break;
}
}
}
setState(7675);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1074,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
public PrimaryExpressionContext() { }
public void copyFrom(PrimaryExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DereferenceContext extends PrimaryExpressionContext {
public PrimaryExpressionContext base;
public IdentifierContext fieldName;
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DereferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDereference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDereference(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDereference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentDateContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(PLParser.CURRENT_DATE, 0); }
public CurrentDateContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCurrentDate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCurrentDate(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCurrentDate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CastContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public CastDataTypeContext castDataType() {
return getRuleContext(CastDataTypeContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode CAST() { return getToken(PLParser.CAST, 0); }
public CastContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCast(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCast(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedExpressionContext extends PrimaryExpressionContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ParenthesizedExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterParenthesizedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitParenthesizedExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitParenthesizedExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UserVariableContext extends PrimaryExpressionContext {
public TerminalNode ATSIGN() { return getToken(PLParser.ATSIGN, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public UserVariableContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUserVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUserVariable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUserVariable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ElementAtContext extends PrimaryExpressionContext {
public PrimaryExpressionContext value;
public ValueExpressionContext index;
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ElementAtContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterElementAt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitElementAt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitElementAt(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LocalTimestampContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode LOCALTIMESTAMP() { return getToken(PLParser.LOCALTIMESTAMP, 0); }
public LocalTimestampContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLocalTimestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLocalTimestamp(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLocalTimestamp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CharFunctionContext extends PrimaryExpressionContext {
public ExpressionContext expression;
public List<ExpressionContext> arguments = new ArrayList<ExpressionContext>();
public IdentifierOrTextContext charSet;
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public CharFunctionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCharFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCharFunction(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCharFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalLiteralContext extends PrimaryExpressionContext {
public IntervalContext interval() {
return getRuleContext(IntervalContext.class,0);
}
public IntervalLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIntervalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIntervalLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIntervalLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleCaseContext extends PrimaryExpressionContext {
public ExpressionContext value;
public ExpressionContext elseExpression;
public TerminalNode CASE() { return getToken(PLParser.CASE, 0); }
public TerminalNode END() { return getToken(PLParser.END, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<WhenClauseContext> whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public SimpleCaseContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSimpleCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSimpleCase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSimpleCase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnReferenceContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode BINARY() { return getToken(PLParser.BINARY, 0); }
public ColumnReferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterColumnReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitColumnReference(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitColumnReference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StarContext extends PrimaryExpressionContext {
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public StarContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStar(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStar(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SessionUserContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode SESSION_USER() { return getToken(PLParser.SESSION_USER, 0); }
public SessionUserContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSessionUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSessionUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSessionUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConvertTypeContext extends PrimaryExpressionContext {
public ExpressionContext argument;
public TerminalNode CONVERT() { return getToken(PLParser.CONVERT, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public CastDataTypeContext castDataType() {
return getRuleContext(CastDataTypeContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConvertTypeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterConvertType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitConvertType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitConvertType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConvertCharSetContext extends PrimaryExpressionContext {
public ExpressionContext argument;
public IdentifierOrTextContext charSet;
public TerminalNode CONVERT() { return getToken(PLParser.CONVERT, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode USING() { return getToken(PLParser.USING, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierOrTextContext identifierOrText() {
return getRuleContext(IdentifierOrTextContext.class,0);
}
public ConvertCharSetContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterConvertCharSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitConvertCharSet(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitConvertCharSet(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubqueryExpressionContext extends PrimaryExpressionContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SubqueryExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSubqueryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSubqueryExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSubqueryExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EncryptKeyContext extends PrimaryExpressionContext {
public IdentifierContext dbName;
public IdentifierContext keyName;
public TerminalNode KEY() { return getToken(PLParser.KEY, 0); }
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public EncryptKeyContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterEncryptKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitEncryptKey(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitEncryptKey(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentTimeContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_TIME() { return getToken(PLParser.CURRENT_TIME, 0); }
public CurrentTimeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCurrentTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCurrentTime(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCurrentTime(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LocalTimeContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode LOCALTIME() { return getToken(PLParser.LOCALTIME, 0); }
public LocalTimeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterLocalTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitLocalTime(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitLocalTime(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SystemVariableContext extends PrimaryExpressionContext {
public Token kind;
public TerminalNode DOUBLEATSIGN() { return getToken(PLParser.DOUBLEATSIGN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public SystemVariableContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSystemVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSystemVariable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSystemVariable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CollateContext extends PrimaryExpressionContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public TerminalNode COLLATE() { return getToken(PLParser.COLLATE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode DEFAULT() { return getToken(PLParser.DEFAULT, 0); }
public CollateContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCollate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCollate(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCollate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentUserContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_USER() { return getToken(PLParser.CURRENT_USER, 0); }
public CurrentUserContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCurrentUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCurrentUser(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCurrentUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConstantDefaultContext extends PrimaryExpressionContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public ConstantDefaultContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterConstantDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitConstantDefault(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitConstantDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExtractContext extends PrimaryExpressionContext {
public IdentifierContext field;
public ValueExpressionContext source;
public TerminalNode EXTRACT() { return getToken(PLParser.EXTRACT, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode FROM() { return getToken(PLParser.FROM, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public ExtractContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterExtract(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitExtract(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitExtract(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentTimestampContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_TIMESTAMP() { return getToken(PLParser.CURRENT_TIMESTAMP, 0); }
public CurrentTimestampContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCurrentTimestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCurrentTimestamp(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCurrentTimestamp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionCallContext extends PrimaryExpressionContext {
public FunctionCallExpressionContext functionCallExpression() {
return getRuleContext(FunctionCallExpressionContext.class,0);
}
public FunctionCallContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionCall(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionCall(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArraySliceContext extends PrimaryExpressionContext {
public PrimaryExpressionContext value;
public ValueExpressionContext begin;
public ValueExpressionContext end;
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public List<ValueExpressionContext> valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public ArraySliceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterArraySlice(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitArraySlice(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitArraySlice(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SearchedCaseContext extends PrimaryExpressionContext {
public ExpressionContext elseExpression;
public TerminalNode CASE() { return getToken(PLParser.CASE, 0); }
public TerminalNode END() { return getToken(PLParser.END, 0); }
public List<WhenClauseContext> whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public TerminalNode ELSE() { return getToken(PLParser.ELSE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SearchedCaseContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSearchedCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSearchedCase(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSearchedCase(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
return primaryExpression(0);
}
private PrimaryExpressionContext primaryExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, _parentState);
PrimaryExpressionContext _prevctx = _localctx;
int _startState = 650;
enterRecursionRule(_localctx, 650, RULE_primaryExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7791);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1085,_ctx) ) {
case 1:
{
_localctx = new CurrentDateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7677);
((CurrentDateContext)_localctx).name = match(CURRENT_DATE);
}
break;
case 2:
{
_localctx = new CurrentTimeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7678);
((CurrentTimeContext)_localctx).name = match(CURRENT_TIME);
}
break;
case 3:
{
_localctx = new CurrentTimestampContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7679);
((CurrentTimestampContext)_localctx).name = match(CURRENT_TIMESTAMP);
}
break;
case 4:
{
_localctx = new LocalTimeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7680);
((LocalTimeContext)_localctx).name = match(LOCALTIME);
}
break;
case 5:
{
_localctx = new LocalTimestampContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7681);
((LocalTimestampContext)_localctx).name = match(LOCALTIMESTAMP);
}
break;
case 6:
{
_localctx = new CurrentUserContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7682);
((CurrentUserContext)_localctx).name = match(CURRENT_USER);
}
break;
case 7:
{
_localctx = new SessionUserContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7683);
((SessionUserContext)_localctx).name = match(SESSION_USER);
}
break;
case 8:
{
_localctx = new SearchedCaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7684);
match(CASE);
setState(7686);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(7685);
whenClause();
}
}
setState(7688);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(7692);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(7690);
match(ELSE);
setState(7691);
((SearchedCaseContext)_localctx).elseExpression = expression();
}
}
setState(7694);
match(END);
}
break;
case 9:
{
_localctx = new SimpleCaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7696);
match(CASE);
setState(7697);
((SimpleCaseContext)_localctx).value = expression();
setState(7699);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(7698);
whenClause();
}
}
setState(7701);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(7705);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(7703);
match(ELSE);
setState(7704);
((SimpleCaseContext)_localctx).elseExpression = expression();
}
}
setState(7707);
match(END);
}
break;
case 10:
{
_localctx = new CastContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7709);
((CastContext)_localctx).name = match(CAST);
setState(7710);
match(LEFT_PAREN);
setState(7711);
expression();
setState(7712);
match(AS);
setState(7713);
castDataType();
setState(7714);
match(RIGHT_PAREN);
}
break;
case 11:
{
_localctx = new ConstantDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7716);
constant();
}
break;
case 12:
{
_localctx = new IntervalLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7717);
interval();
}
break;
case 13:
{
_localctx = new StarContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7718);
match(ASTERISK);
}
break;
case 14:
{
_localctx = new StarContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7719);
qualifiedName();
setState(7720);
match(DOT);
setState(7721);
match(ASTERISK);
}
break;
case 15:
{
_localctx = new CharFunctionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7723);
match(CHAR);
setState(7724);
match(LEFT_PAREN);
setState(7725);
((CharFunctionContext)_localctx).expression = expression();
((CharFunctionContext)_localctx).arguments.add(((CharFunctionContext)_localctx).expression);
setState(7730);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7726);
match(COMMA);
setState(7727);
((CharFunctionContext)_localctx).expression = expression();
((CharFunctionContext)_localctx).arguments.add(((CharFunctionContext)_localctx).expression);
}
}
setState(7732);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7735);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(7733);
match(USING);
setState(7734);
((CharFunctionContext)_localctx).charSet = identifierOrText();
}
}
setState(7737);
match(RIGHT_PAREN);
}
break;
case 16:
{
_localctx = new ConvertCharSetContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7739);
match(CONVERT);
setState(7740);
match(LEFT_PAREN);
setState(7741);
((ConvertCharSetContext)_localctx).argument = expression();
setState(7742);
match(USING);
setState(7743);
((ConvertCharSetContext)_localctx).charSet = identifierOrText();
setState(7744);
match(RIGHT_PAREN);
}
break;
case 17:
{
_localctx = new ConvertTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7746);
match(CONVERT);
setState(7747);
match(LEFT_PAREN);
setState(7748);
((ConvertTypeContext)_localctx).argument = expression();
setState(7749);
match(COMMA);
setState(7750);
castDataType();
setState(7751);
match(RIGHT_PAREN);
}
break;
case 18:
{
_localctx = new FunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7753);
functionCallExpression();
}
break;
case 19:
{
_localctx = new SubqueryExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7754);
match(LEFT_PAREN);
setState(7755);
query();
setState(7756);
match(RIGHT_PAREN);
}
break;
case 20:
{
_localctx = new UserVariableContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7758);
match(ATSIGN);
setState(7759);
identifierOrText();
}
break;
case 21:
{
_localctx = new SystemVariableContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7760);
match(DOUBLEATSIGN);
setState(7763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1081,_ctx) ) {
case 1:
{
setState(7761);
((SystemVariableContext)_localctx).kind = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==GLOBAL || _la==SESSION) ) {
((SystemVariableContext)_localctx).kind = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7762);
match(DOT);
}
break;
}
setState(7765);
identifier();
}
break;
case 22:
{
_localctx = new ColumnReferenceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7767);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BINARY) {
{
setState(7766);
match(BINARY);
}
}
setState(7769);
identifier();
}
break;
case 23:
{
_localctx = new ParenthesizedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7770);
match(LEFT_PAREN);
setState(7771);
expression();
setState(7772);
match(RIGHT_PAREN);
}
break;
case 24:
{
_localctx = new EncryptKeyContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7774);
match(KEY);
setState(7778);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1083,_ctx) ) {
case 1:
{
setState(7775);
((EncryptKeyContext)_localctx).dbName = identifier();
setState(7776);
match(DOT);
}
break;
}
setState(7780);
((EncryptKeyContext)_localctx).keyName = identifier();
}
break;
case 25:
{
_localctx = new ExtractContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(7781);
match(EXTRACT);
setState(7782);
match(LEFT_PAREN);
setState(7783);
((ExtractContext)_localctx).field = identifier();
setState(7784);
match(FROM);
setState(7786);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1084,_ctx) ) {
case 1:
{
setState(7785);
_la = _input.LA(1);
if ( !(_la==DATE || _la==TIMESTAMP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(7788);
((ExtractContext)_localctx).source = valueExpression(0);
setState(7789);
match(RIGHT_PAREN);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(7819);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1089,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(7817);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1088,_ctx) ) {
case 1:
{
_localctx = new ElementAtContext(new PrimaryExpressionContext(_parentctx, _parentState));
((ElementAtContext)_localctx).value = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(7793);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(7794);
match(LEFT_BRACKET);
setState(7795);
((ElementAtContext)_localctx).index = valueExpression(0);
setState(7796);
match(RIGHT_BRACKET);
}
break;
case 2:
{
_localctx = new ArraySliceContext(new PrimaryExpressionContext(_parentctx, _parentState));
((ArraySliceContext)_localctx).value = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(7798);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(7799);
match(LEFT_BRACKET);
setState(7800);
((ArraySliceContext)_localctx).begin = valueExpression(0);
setState(7801);
match(COLON);
setState(7803);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361251L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987865787850751L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489798078503L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701645201671361L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2300353660904977643L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(7802);
((ArraySliceContext)_localctx).end = valueExpression(0);
}
}
setState(7805);
match(RIGHT_BRACKET);
}
break;
case 3:
{
_localctx = new DereferenceContext(new PrimaryExpressionContext(_parentctx, _parentState));
((DereferenceContext)_localctx).base = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(7807);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(7808);
match(DOT);
setState(7809);
((DereferenceContext)_localctx).fieldName = identifier();
}
break;
case 4:
{
_localctx = new CollateContext(new PrimaryExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(7810);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(7811);
match(COLLATE);
setState(7815);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(7812);
identifier();
}
break;
case STRING_LITERAL:
{
setState(7813);
match(STRING_LITERAL);
}
break;
case DEFAULT:
{
setState(7814);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
}
setState(7821);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1089,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CastDataTypeContext extends ParserRuleContext {
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public TerminalNode SIGNED() { return getToken(PLParser.SIGNED, 0); }
public TerminalNode UNSIGNED() { return getToken(PLParser.UNSIGNED, 0); }
public TerminalNode INT() { return getToken(PLParser.INT, 0); }
public TerminalNode INTEGER() { return getToken(PLParser.INTEGER, 0); }
public CastDataTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castDataType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCastDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCastDataType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCastDataType(this);
else return visitor.visitChildren(this);
}
}
public final CastDataTypeContext castDataType() throws RecognitionException {
CastDataTypeContext _localctx = new CastDataTypeContext(_ctx, getState());
enterRule(_localctx, 652, RULE_castDataType);
int _la;
try {
setState(7827);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AGG_STATE:
case ALL:
case ARRAY:
case BIGINT:
case BITMAP:
case BOOLEAN:
case CHAR:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DOUBLE:
case FLOAT:
case HLL:
case INT:
case INTEGER:
case IPV4:
case IPV6:
case JSON:
case JSONB:
case LARGEINT:
case MAP:
case QUANTILE_STATE:
case SMALLINT:
case STRING:
case STRUCT:
case TEXT:
case TIME:
case TINYINT:
case VARCHAR:
case VARIANT:
enterOuterAlt(_localctx, 1);
{
setState(7822);
dataType();
}
break;
case SIGNED:
case UNSIGNED:
enterOuterAlt(_localctx, 2);
{
setState(7823);
_la = _input.LA(1);
if ( !(_la==SIGNED || _la==UNSIGNED) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7825);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INT || _la==INTEGER) {
{
setState(7824);
_la = _input.LA(1);
if ( !(_la==INT || _la==INTEGER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionCallExpressionContext extends ParserRuleContext {
public ExpressionContext expression;
public List<ExpressionContext> arguments = new ArrayList<ExpressionContext>();
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode OVER() { return getToken(PLParser.OVER, 0); }
public WindowSpecContext windowSpec() {
return getRuleContext(WindowSpecContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public TerminalNode ORDER() { return getToken(PLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(PLParser.BY, 0); }
public List<SortItemContext> sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(PLParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public FunctionCallExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionCallExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionCallExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionCallExpression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionCallExpression(this);
else return visitor.visitChildren(this);
}
}
public final FunctionCallExpressionContext functionCallExpression() throws RecognitionException {
FunctionCallExpressionContext _localctx = new FunctionCallExpressionContext(_ctx, getState());
enterRule(_localctx, 654, RULE_functionCallExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7829);
functionIdentifier();
setState(7830);
match(LEFT_PAREN);
setState(7854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -2764928696228773887L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8574704156772361255L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1795995065042591743L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761489795981351L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334002343961416705L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & -701643054187713L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -892275966651403139L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -424613231526458139L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2264324863886013675L) != 0) || ((((_la - 712)) & ~0x3f) == 0 && ((1L << (_la - 712)) & 7047L) != 0)) {
{
setState(7832);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(7831);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(7834);
((FunctionCallExpressionContext)_localctx).expression = expression();
((FunctionCallExpressionContext)_localctx).arguments.add(((FunctionCallExpressionContext)_localctx).expression);
setState(7839);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7835);
match(COMMA);
setState(7836);
((FunctionCallExpressionContext)_localctx).expression = expression();
((FunctionCallExpressionContext)_localctx).arguments.add(((FunctionCallExpressionContext)_localctx).expression);
}
}
setState(7841);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7852);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(7842);
match(ORDER);
setState(7843);
match(BY);
setState(7844);
sortItem();
setState(7849);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7845);
match(COMMA);
setState(7846);
sortItem();
}
}
setState(7851);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
}
setState(7856);
match(RIGHT_PAREN);
setState(7859);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1097,_ctx) ) {
case 1:
{
setState(7857);
match(OVER);
setState(7858);
windowSpec();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionIdentifierContext extends ParserRuleContext {
public IdentifierContext dbName;
public FunctionNameIdentifierContext functionNameIdentifier() {
return getRuleContext(FunctionNameIdentifierContext.class,0);
}
public TerminalNode DOT() { return getToken(PLParser.DOT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FunctionIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final FunctionIdentifierContext functionIdentifier() throws RecognitionException {
FunctionIdentifierContext _localctx = new FunctionIdentifierContext(_ctx, getState());
enterRule(_localctx, 656, RULE_functionIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(7864);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1098,_ctx) ) {
case 1:
{
setState(7861);
((FunctionIdentifierContext)_localctx).dbName = identifier();
setState(7862);
match(DOT);
}
break;
}
setState(7866);
functionNameIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionNameIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(PLParser.ADD, 0); }
public TerminalNode CONNECTION_ID() { return getToken(PLParser.CONNECTION_ID, 0); }
public TerminalNode CURRENT_CATALOG() { return getToken(PLParser.CURRENT_CATALOG, 0); }
public TerminalNode CURRENT_USER() { return getToken(PLParser.CURRENT_USER, 0); }
public TerminalNode DATABASE() { return getToken(PLParser.DATABASE, 0); }
public TerminalNode IF() { return getToken(PLParser.IF, 0); }
public TerminalNode LEFT() { return getToken(PLParser.LEFT, 0); }
public TerminalNode LIKE() { return getToken(PLParser.LIKE, 0); }
public TerminalNode PASSWORD() { return getToken(PLParser.PASSWORD, 0); }
public TerminalNode REGEXP() { return getToken(PLParser.REGEXP, 0); }
public TerminalNode RIGHT() { return getToken(PLParser.RIGHT, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public TerminalNode SESSION_USER() { return getToken(PLParser.SESSION_USER, 0); }
public TerminalNode TRIM() { return getToken(PLParser.TRIM, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public FunctionNameIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionNameIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFunctionNameIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFunctionNameIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFunctionNameIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final FunctionNameIdentifierContext functionNameIdentifier() throws RecognitionException {
FunctionNameIdentifierContext _localctx = new FunctionNameIdentifierContext(_ctx, getState());
enterRule(_localctx, 658, RULE_functionNameIdentifier);
try {
setState(7884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1099,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7868);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7869);
match(ADD);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(7870);
match(CONNECTION_ID);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(7871);
match(CURRENT_CATALOG);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(7872);
match(CURRENT_USER);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(7873);
match(DATABASE);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(7874);
match(IF);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(7875);
match(LEFT);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(7876);
match(LIKE);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(7877);
match(PASSWORD);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(7878);
match(REGEXP);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(7879);
match(RIGHT);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(7880);
match(SCHEMA);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(7881);
match(SESSION_USER);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(7882);
match(TRIM);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(7883);
match(USER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WindowSpecContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public PartitionClauseContext partitionClause() {
return getRuleContext(PartitionClauseContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public WindowFrameContext windowFrame() {
return getRuleContext(WindowFrameContext.class,0);
}
public WindowSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWindowSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWindowSpec(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWindowSpec(this);
else return visitor.visitChildren(this);
}
}
public final WindowSpecContext windowSpec() throws RecognitionException {
WindowSpecContext _localctx = new WindowSpecContext(_ctx, getState());
enterRule(_localctx, 660, RULE_windowSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7886);
match(LEFT_PAREN);
setState(7888);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(7887);
partitionClause();
}
}
setState(7891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(7890);
sortClause();
}
}
setState(7894);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RANGE || _la==ROWS) {
{
setState(7893);
windowFrame();
}
}
setState(7896);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WindowFrameContext extends ParserRuleContext {
public FrameBoundaryContext start;
public FrameBoundaryContext end;
public FrameUnitsContext frameUnits() {
return getRuleContext(FrameUnitsContext.class,0);
}
public List<FrameBoundaryContext> frameBoundary() {
return getRuleContexts(FrameBoundaryContext.class);
}
public FrameBoundaryContext frameBoundary(int i) {
return getRuleContext(FrameBoundaryContext.class,i);
}
public TerminalNode BETWEEN() { return getToken(PLParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(PLParser.AND, 0); }
public WindowFrameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowFrame; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWindowFrame(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWindowFrame(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWindowFrame(this);
else return visitor.visitChildren(this);
}
}
public final WindowFrameContext windowFrame() throws RecognitionException {
WindowFrameContext _localctx = new WindowFrameContext(_ctx, getState());
enterRule(_localctx, 662, RULE_windowFrame);
try {
setState(7907);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7898);
frameUnits();
setState(7899);
((WindowFrameContext)_localctx).start = frameBoundary();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7901);
frameUnits();
setState(7902);
match(BETWEEN);
setState(7903);
((WindowFrameContext)_localctx).start = frameBoundary();
setState(7904);
match(AND);
setState(7905);
((WindowFrameContext)_localctx).end = frameBoundary();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FrameUnitsContext extends ParserRuleContext {
public TerminalNode ROWS() { return getToken(PLParser.ROWS, 0); }
public TerminalNode RANGE() { return getToken(PLParser.RANGE, 0); }
public FrameUnitsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameUnits; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFrameUnits(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFrameUnits(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFrameUnits(this);
else return visitor.visitChildren(this);
}
}
public final FrameUnitsContext frameUnits() throws RecognitionException {
FrameUnitsContext _localctx = new FrameUnitsContext(_ctx, getState());
enterRule(_localctx, 664, RULE_frameUnits);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7909);
_la = _input.LA(1);
if ( !(_la==RANGE || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FrameBoundaryContext extends ParserRuleContext {
public Token boundType;
public TerminalNode UNBOUNDED() { return getToken(PLParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(PLParser.PRECEDING, 0); }
public TerminalNode FOLLOWING() { return getToken(PLParser.FOLLOWING, 0); }
public TerminalNode ROW() { return getToken(PLParser.ROW, 0); }
public TerminalNode CURRENT() { return getToken(PLParser.CURRENT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public FrameBoundaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameBoundary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterFrameBoundary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitFrameBoundary(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitFrameBoundary(this);
else return visitor.visitChildren(this);
}
}
public final FrameBoundaryContext frameBoundary() throws RecognitionException {
FrameBoundaryContext _localctx = new FrameBoundaryContext(_ctx, getState());
enterRule(_localctx, 666, RULE_frameBoundary);
int _la;
try {
setState(7918);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNBOUNDED:
enterOuterAlt(_localctx, 1);
{
setState(7911);
match(UNBOUNDED);
setState(7912);
((FrameBoundaryContext)_localctx).boundType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FOLLOWING || _la==PRECEDING) ) {
((FrameBoundaryContext)_localctx).boundType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case CURRENT:
enterOuterAlt(_localctx, 2);
{
setState(7913);
((FrameBoundaryContext)_localctx).boundType = match(CURRENT);
setState(7914);
match(ROW);
}
break;
case DAYS:
case SQL:
case LEFT_PAREN:
case LEFT_BRACKET:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case ADD:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BINARY:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATABASE:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXISTS:
case EXPIRED:
case EXTERNAL:
case EXTRACT:
case FAILED_LOGIN_ATTEMPTS:
case FALSE:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IF:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INTERVAL:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case KEY:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LEFT:
case LESS:
case LEVEL:
case LIKE:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NOT:
case NULL:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLACEHOLDER:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REGEXP:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RIGHT:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRIM:
case TRUE:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case PLUS:
case SUBTRACT:
case ASTERISK:
case TILDE:
case LOGICALNOT:
case HINT_START:
case HINT_END:
case COMMENT_START:
case ATSIGN:
case DOUBLEATSIGN:
case STRING_LITERAL:
case INTEGER_VALUE:
case EXPONENT_VALUE:
case DECIMAL_VALUE:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 3);
{
setState(7915);
expression();
setState(7916);
((FrameBoundaryContext)_localctx).boundType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FOLLOWING || _la==PRECEDING) ) {
((FrameBoundaryContext)_localctx).boundType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedNameContext extends ParserRuleContext {
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(PLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(PLParser.DOT, i);
}
public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQualifiedName(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQualifiedName(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 668, RULE_qualifiedName);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(7920);
identifier();
setState(7925);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1105,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(7921);
match(DOT);
setState(7922);
identifier();
}
}
}
setState(7927);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1105,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SpecifiedPartitionContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(PLParser.PARTITION, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public TerminalNode PARTITIONS() { return getToken(PLParser.PARTITIONS, 0); }
public SpecifiedPartitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specifiedPartition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSpecifiedPartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSpecifiedPartition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSpecifiedPartition(this);
else return visitor.visitChildren(this);
}
}
public final SpecifiedPartitionContext specifiedPartition() throws RecognitionException {
SpecifiedPartitionContext _localctx = new SpecifiedPartitionContext(_ctx, getState());
enterRule(_localctx, 670, RULE_specifiedPartition);
int _la;
try {
setState(7941);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(7929);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(7928);
match(TEMPORARY);
}
}
setState(7931);
match(PARTITION);
setState(7934);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
setState(7932);
identifier();
}
break;
case LEFT_PAREN:
{
setState(7933);
identifierList();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(7937);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(7936);
match(TEMPORARY);
}
}
setState(7939);
match(PARTITIONS);
setState(7940);
identifierList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstantContext extends ParserRuleContext {
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
public ConstantContext() { }
public void copyFrom(ConstantContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StructLiteralContext extends ConstantContext {
public ConstantContext constant;
public List<ConstantContext> items = new ArrayList<ConstantContext>();
public TerminalNode LEFT_BRACE() { return getToken(PLParser.LEFT_BRACE, 0); }
public TerminalNode RIGHT_BRACE() { return getToken(PLParser.RIGHT_BRACE, 0); }
public List<ConstantContext> constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public StructLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStructLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStructLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStructLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullLiteralContext extends ConstantContext {
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public NullLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNullLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNullLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends ConstantContext {
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode BINARY() { return getToken(PLParser.BINARY, 0); }
public StringLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitStringLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeConstructorContext extends ConstantContext {
public Token type;
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode DATEV1() { return getToken(PLParser.DATEV1, 0); }
public TerminalNode DATEV2() { return getToken(PLParser.DATEV2, 0); }
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public TypeConstructorContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTypeConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTypeConstructor(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTypeConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayLiteralContext extends ConstantContext {
public ConstantContext constant;
public List<ConstantContext> items = new ArrayList<ConstantContext>();
public TerminalNode LEFT_BRACKET() { return getToken(PLParser.LEFT_BRACKET, 0); }
public TerminalNode RIGHT_BRACKET() { return getToken(PLParser.RIGHT_BRACKET, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public List<ConstantContext> constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public ArrayLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterArrayLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitArrayLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitArrayLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PlaceholderContext extends ConstantContext {
public TerminalNode PLACEHOLDER() { return getToken(PLParser.PLACEHOLDER, 0); }
public PlaceholderContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPlaceholder(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPlaceholder(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MapLiteralContext extends ConstantContext {
public ConstantContext constant;
public List<ConstantContext> items = new ArrayList<ConstantContext>();
public TerminalNode LEFT_BRACE() { return getToken(PLParser.LEFT_BRACE, 0); }
public TerminalNode RIGHT_BRACE() { return getToken(PLParser.RIGHT_BRACE, 0); }
public List<TerminalNode> COLON() { return getTokens(PLParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(PLParser.COLON, i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public List<ConstantContext> constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public MapLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterMapLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitMapLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitMapLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NumericLiteralContext extends ConstantContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNumericLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends ConstantContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBooleanLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 672, RULE_constant);
int _la;
try {
setState(7994);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1116,_ctx) ) {
case 1:
_localctx = new NullLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(7943);
match(NULL);
}
break;
case 2:
_localctx = new TypeConstructorContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(7944);
((TypeConstructorContext)_localctx).type = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 295)) & ~0x3f) == 0 && ((1L << (_la - 295)) & 41L) != 0) || _la==TIMESTAMP) ) {
((TypeConstructorContext)_localctx).type = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(7945);
match(STRING_LITERAL);
}
break;
case 3:
_localctx = new NumericLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(7946);
number();
}
break;
case 4:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(7947);
booleanValue();
}
break;
case 5:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(7949);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BINARY) {
{
setState(7948);
match(BINARY);
}
}
setState(7951);
match(STRING_LITERAL);
}
break;
case 6:
_localctx = new ArrayLiteralContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(7952);
match(LEFT_BRACKET);
setState(7954);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & 137438953477L) != 0) || ((((_la - 295)) & ~0x3f) == 0 && ((1L << (_la - 295)) & 1152921504606847017L) != 0) || _la==NULL || _la==PLACEHOLDER || ((((_la - 636)) & ~0x3f) == 0 && ((1L << (_la - 636)) & 1152921504606848001L) != 0) || ((((_la - 714)) & ~0x3f) == 0 && ((1L << (_la - 714)) & 225L) != 0)) {
{
setState(7953);
((ArrayLiteralContext)_localctx).constant = constant();
((ArrayLiteralContext)_localctx).items.add(((ArrayLiteralContext)_localctx).constant);
}
}
setState(7960);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7956);
match(COMMA);
setState(7957);
((ArrayLiteralContext)_localctx).constant = constant();
((ArrayLiteralContext)_localctx).items.add(((ArrayLiteralContext)_localctx).constant);
}
}
setState(7962);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7963);
match(RIGHT_BRACKET);
}
break;
case 7:
_localctx = new MapLiteralContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(7964);
match(LEFT_BRACE);
setState(7969);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & 137438953477L) != 0) || ((((_la - 295)) & ~0x3f) == 0 && ((1L << (_la - 295)) & 1152921504606847017L) != 0) || _la==NULL || _la==PLACEHOLDER || ((((_la - 636)) & ~0x3f) == 0 && ((1L << (_la - 636)) & 1152921504606848001L) != 0) || ((((_la - 714)) & ~0x3f) == 0 && ((1L << (_la - 714)) & 225L) != 0)) {
{
setState(7965);
((MapLiteralContext)_localctx).constant = constant();
((MapLiteralContext)_localctx).items.add(((MapLiteralContext)_localctx).constant);
setState(7966);
match(COLON);
setState(7967);
((MapLiteralContext)_localctx).constant = constant();
((MapLiteralContext)_localctx).items.add(((MapLiteralContext)_localctx).constant);
}
}
setState(7978);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7971);
match(COMMA);
setState(7972);
((MapLiteralContext)_localctx).constant = constant();
((MapLiteralContext)_localctx).items.add(((MapLiteralContext)_localctx).constant);
setState(7973);
match(COLON);
setState(7974);
((MapLiteralContext)_localctx).constant = constant();
((MapLiteralContext)_localctx).items.add(((MapLiteralContext)_localctx).constant);
}
}
setState(7980);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7981);
match(RIGHT_BRACE);
}
break;
case 8:
_localctx = new StructLiteralContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(7982);
match(LEFT_BRACE);
setState(7983);
((StructLiteralContext)_localctx).constant = constant();
((StructLiteralContext)_localctx).items.add(((StructLiteralContext)_localctx).constant);
setState(7988);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(7984);
match(COMMA);
setState(7985);
((StructLiteralContext)_localctx).constant = constant();
((StructLiteralContext)_localctx).items.add(((StructLiteralContext)_localctx).constant);
}
}
setState(7990);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(7991);
match(RIGHT_BRACE);
}
break;
case 9:
_localctx = new PlaceholderContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(7993);
match(PLACEHOLDER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonOperatorContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(PLParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(PLParser.NEQ, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public TerminalNode LTE() { return getToken(PLParser.LTE, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public TerminalNode GTE() { return getToken(PLParser.GTE, 0); }
public TerminalNode NSEQ() { return getToken(PLParser.NSEQ, 0); }
public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterComparisonOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitComparisonOperator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 674, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7996);
_la = _input.LA(1);
if ( !(((((_la - 688)) & ~0x3f) == 0 && ((1L << (_la - 688)) & 127L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanValueContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(PLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(PLParser.FALSE, 0); }
public BooleanValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitBooleanValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 676, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7998);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhenClauseContext extends ParserRuleContext {
public ExpressionContext condition;
public ExpressionContext result;
public TerminalNode WHEN() { return getToken(PLParser.WHEN, 0); }
public TerminalNode THEN() { return getToken(PLParser.THEN, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public WhenClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterWhenClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitWhenClause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitWhenClause(this);
else return visitor.visitChildren(this);
}
}
public final WhenClauseContext whenClause() throws RecognitionException {
WhenClauseContext _localctx = new WhenClauseContext(_ctx, getState());
enterRule(_localctx, 678, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(8000);
match(WHEN);
setState(8001);
((WhenClauseContext)_localctx).condition = expression();
setState(8002);
match(THEN);
setState(8003);
((WhenClauseContext)_localctx).result = expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalContext extends ParserRuleContext {
public ExpressionContext value;
public UnitIdentifierContext unit;
public TerminalNode INTERVAL() { return getToken(PLParser.INTERVAL, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnitIdentifierContext unitIdentifier() {
return getRuleContext(UnitIdentifierContext.class,0);
}
public IntervalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterInterval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitInterval(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitInterval(this);
else return visitor.visitChildren(this);
}
}
public final IntervalContext interval() throws RecognitionException {
IntervalContext _localctx = new IntervalContext(_ctx, getState());
enterRule(_localctx, 680, RULE_interval);
try {
enterOuterAlt(_localctx, 1);
{
setState(8005);
match(INTERVAL);
setState(8006);
((IntervalContext)_localctx).value = expression();
setState(8007);
((IntervalContext)_localctx).unit = unitIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnitIdentifierContext extends ParserRuleContext {
public TerminalNode YEAR() { return getToken(PLParser.YEAR, 0); }
public TerminalNode MONTH() { return getToken(PLParser.MONTH, 0); }
public TerminalNode WEEK() { return getToken(PLParser.WEEK, 0); }
public TerminalNode DAY() { return getToken(PLParser.DAY, 0); }
public TerminalNode HOUR() { return getToken(PLParser.HOUR, 0); }
public TerminalNode MINUTE() { return getToken(PLParser.MINUTE, 0); }
public TerminalNode SECOND() { return getToken(PLParser.SECOND, 0); }
public UnitIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unitIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnitIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnitIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final UnitIdentifierContext unitIdentifier() throws RecognitionException {
UnitIdentifierContext _localctx = new UnitIdentifierContext(_ctx, getState());
enterRule(_localctx, 682, RULE_unitIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8009);
_la = _input.LA(1);
if ( !(_la==DAY || _la==HOUR || _la==MINUTE || _la==MONTH || _la==SECOND || _la==WEEK || _la==YEAR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DataTypeWithNullableContext extends ParserRuleContext {
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public TerminalNode NULL() { return getToken(PLParser.NULL, 0); }
public TerminalNode NOT() { return getToken(PLParser.NOT, 0); }
public DataTypeWithNullableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataTypeWithNullable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDataTypeWithNullable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDataTypeWithNullable(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDataTypeWithNullable(this);
else return visitor.visitChildren(this);
}
}
public final DataTypeWithNullableContext dataTypeWithNullable() throws RecognitionException {
DataTypeWithNullableContext _localctx = new DataTypeWithNullableContext(_ctx, getState());
enterRule(_localctx, 684, RULE_dataTypeWithNullable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8011);
dataType();
setState(8016);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT || _la==NULL) {
{
setState(8013);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(8012);
match(NOT);
}
}
setState(8015);
match(NULL);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DataTypeContext extends ParserRuleContext {
public DataTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataType; }
public DataTypeContext() { }
public void copyFrom(DataTypeContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VariantPredefinedFieldsContext extends DataTypeContext {
public VariantTypeDefinitionsContext complex;
public VariantTypeDefinitionsContext variantTypeDefinitions() {
return getRuleContext(VariantTypeDefinitionsContext.class,0);
}
public VariantPredefinedFieldsContext(DataTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantPredefinedFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantPredefinedFields(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantPredefinedFields(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComplexDataTypeContext extends DataTypeContext {
public Token complex;
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public List<DataTypeContext> dataType() {
return getRuleContexts(DataTypeContext.class);
}
public DataTypeContext dataType(int i) {
return getRuleContext(DataTypeContext.class,i);
}
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public TerminalNode ARRAY() { return getToken(PLParser.ARRAY, 0); }
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public TerminalNode MAP() { return getToken(PLParser.MAP, 0); }
public ComplexColTypeListContext complexColTypeList() {
return getRuleContext(ComplexColTypeListContext.class,0);
}
public TerminalNode STRUCT() { return getToken(PLParser.STRUCT, 0); }
public ComplexDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterComplexDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitComplexDataType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitComplexDataType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AggStateDataTypeContext extends DataTypeContext {
public DataTypeWithNullableContext dataTypeWithNullable;
public List<DataTypeWithNullableContext> dataTypes = new ArrayList<DataTypeWithNullableContext>();
public TerminalNode AGG_STATE() { return getToken(PLParser.AGG_STATE, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public FunctionNameIdentifierContext functionNameIdentifier() {
return getRuleContext(FunctionNameIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public List<DataTypeWithNullableContext> dataTypeWithNullable() {
return getRuleContexts(DataTypeWithNullableContext.class);
}
public DataTypeWithNullableContext dataTypeWithNullable(int i) {
return getRuleContext(DataTypeWithNullableContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public AggStateDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterAggStateDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitAggStateDataType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitAggStateDataType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PrimitiveDataTypeContext extends DataTypeContext {
public PrimitiveColTypeContext primitiveColType() {
return getRuleContext(PrimitiveColTypeContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public List<TerminalNode> INTEGER_VALUE() { return getTokens(PLParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(PLParser.INTEGER_VALUE, i);
}
public TerminalNode ASTERISK() { return getToken(PLParser.ASTERISK, 0); }
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public PrimitiveDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPrimitiveDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPrimitiveDataType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPrimitiveDataType(this);
else return visitor.visitChildren(this);
}
}
public final DataTypeContext dataType() throws RecognitionException {
DataTypeContext _localctx = new DataTypeContext(_ctx, getState());
enterRule(_localctx, 686, RULE_dataType);
int _la;
try {
setState(8064);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1122,_ctx) ) {
case 1:
_localctx = new ComplexDataTypeContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8018);
((ComplexDataTypeContext)_localctx).complex = match(ARRAY);
setState(8019);
match(LT);
setState(8020);
dataType();
setState(8021);
match(GT);
}
break;
case 2:
_localctx = new ComplexDataTypeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(8023);
((ComplexDataTypeContext)_localctx).complex = match(MAP);
setState(8024);
match(LT);
setState(8025);
dataType();
setState(8026);
match(COMMA);
setState(8027);
dataType();
setState(8028);
match(GT);
}
break;
case 3:
_localctx = new ComplexDataTypeContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(8030);
((ComplexDataTypeContext)_localctx).complex = match(STRUCT);
setState(8031);
match(LT);
setState(8032);
complexColTypeList();
setState(8033);
match(GT);
}
break;
case 4:
_localctx = new VariantPredefinedFieldsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(8035);
((VariantPredefinedFieldsContext)_localctx).complex = variantTypeDefinitions();
}
break;
case 5:
_localctx = new AggStateDataTypeContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(8036);
match(AGG_STATE);
setState(8037);
match(LT);
setState(8038);
functionNameIdentifier();
setState(8039);
match(LEFT_PAREN);
setState(8040);
((AggStateDataTypeContext)_localctx).dataTypeWithNullable = dataTypeWithNullable();
((AggStateDataTypeContext)_localctx).dataTypes.add(((AggStateDataTypeContext)_localctx).dataTypeWithNullable);
setState(8045);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(8041);
match(COMMA);
setState(8042);
((AggStateDataTypeContext)_localctx).dataTypeWithNullable = dataTypeWithNullable();
((AggStateDataTypeContext)_localctx).dataTypes.add(((AggStateDataTypeContext)_localctx).dataTypeWithNullable);
}
}
setState(8047);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(8048);
match(RIGHT_PAREN);
setState(8049);
match(GT);
}
break;
case 6:
_localctx = new PrimitiveDataTypeContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(8051);
primitiveColType();
setState(8062);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1121,_ctx) ) {
case 1:
{
setState(8052);
match(LEFT_PAREN);
setState(8053);
_la = _input.LA(1);
if ( !(_la==ASTERISK || _la==INTEGER_VALUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(8058);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(8054);
match(COMMA);
setState(8055);
match(INTEGER_VALUE);
}
}
setState(8060);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(8061);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimitiveColTypeContext extends ParserRuleContext {
public Token type;
public TerminalNode TINYINT() { return getToken(PLParser.TINYINT, 0); }
public TerminalNode SMALLINT() { return getToken(PLParser.SMALLINT, 0); }
public TerminalNode INT() { return getToken(PLParser.INT, 0); }
public TerminalNode INTEGER() { return getToken(PLParser.INTEGER, 0); }
public TerminalNode BIGINT() { return getToken(PLParser.BIGINT, 0); }
public TerminalNode LARGEINT() { return getToken(PLParser.LARGEINT, 0); }
public TerminalNode BOOLEAN() { return getToken(PLParser.BOOLEAN, 0); }
public TerminalNode FLOAT() { return getToken(PLParser.FLOAT, 0); }
public TerminalNode DOUBLE() { return getToken(PLParser.DOUBLE, 0); }
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode DATETIME() { return getToken(PLParser.DATETIME, 0); }
public TerminalNode TIME() { return getToken(PLParser.TIME, 0); }
public TerminalNode DATEV2() { return getToken(PLParser.DATEV2, 0); }
public TerminalNode DATETIMEV2() { return getToken(PLParser.DATETIMEV2, 0); }
public TerminalNode DATEV1() { return getToken(PLParser.DATEV1, 0); }
public TerminalNode DATETIMEV1() { return getToken(PLParser.DATETIMEV1, 0); }
public TerminalNode BITMAP() { return getToken(PLParser.BITMAP, 0); }
public TerminalNode QUANTILE_STATE() { return getToken(PLParser.QUANTILE_STATE, 0); }
public TerminalNode HLL() { return getToken(PLParser.HLL, 0); }
public TerminalNode AGG_STATE() { return getToken(PLParser.AGG_STATE, 0); }
public TerminalNode STRING() { return getToken(PLParser.STRING, 0); }
public TerminalNode JSON() { return getToken(PLParser.JSON, 0); }
public TerminalNode JSONB() { return getToken(PLParser.JSONB, 0); }
public TerminalNode TEXT() { return getToken(PLParser.TEXT, 0); }
public TerminalNode VARCHAR() { return getToken(PLParser.VARCHAR, 0); }
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode DECIMAL() { return getToken(PLParser.DECIMAL, 0); }
public TerminalNode DECIMALV2() { return getToken(PLParser.DECIMALV2, 0); }
public TerminalNode DECIMALV3() { return getToken(PLParser.DECIMALV3, 0); }
public TerminalNode IPV4() { return getToken(PLParser.IPV4, 0); }
public TerminalNode IPV6() { return getToken(PLParser.IPV6, 0); }
public TerminalNode ALL() { return getToken(PLParser.ALL, 0); }
public PrimitiveColTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveColType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterPrimitiveColType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitPrimitiveColType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitPrimitiveColType(this);
else return visitor.visitChildren(this);
}
}
public final PrimitiveColTypeContext primitiveColType() throws RecognitionException {
PrimitiveColTypeContext _localctx = new PrimitiveColTypeContext(_ctx, getState());
enterRule(_localctx, 688, RULE_primitiveColType);
int _la;
try {
setState(8097);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TINYINT:
enterOuterAlt(_localctx, 1);
{
setState(8066);
((PrimitiveColTypeContext)_localctx).type = match(TINYINT);
}
break;
case SMALLINT:
enterOuterAlt(_localctx, 2);
{
setState(8067);
((PrimitiveColTypeContext)_localctx).type = match(SMALLINT);
}
break;
case INT:
case INTEGER:
enterOuterAlt(_localctx, 3);
{
setState(8068);
((PrimitiveColTypeContext)_localctx).type = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INT || _la==INTEGER) ) {
((PrimitiveColTypeContext)_localctx).type = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case BIGINT:
enterOuterAlt(_localctx, 4);
{
setState(8069);
((PrimitiveColTypeContext)_localctx).type = match(BIGINT);
}
break;
case LARGEINT:
enterOuterAlt(_localctx, 5);
{
setState(8070);
((PrimitiveColTypeContext)_localctx).type = match(LARGEINT);
}
break;
case BOOLEAN:
enterOuterAlt(_localctx, 6);
{
setState(8071);
((PrimitiveColTypeContext)_localctx).type = match(BOOLEAN);
}
break;
case FLOAT:
enterOuterAlt(_localctx, 7);
{
setState(8072);
((PrimitiveColTypeContext)_localctx).type = match(FLOAT);
}
break;
case DOUBLE:
enterOuterAlt(_localctx, 8);
{
setState(8073);
((PrimitiveColTypeContext)_localctx).type = match(DOUBLE);
}
break;
case DATE:
enterOuterAlt(_localctx, 9);
{
setState(8074);
((PrimitiveColTypeContext)_localctx).type = match(DATE);
}
break;
case DATETIME:
enterOuterAlt(_localctx, 10);
{
setState(8075);
((PrimitiveColTypeContext)_localctx).type = match(DATETIME);
}
break;
case TIME:
enterOuterAlt(_localctx, 11);
{
setState(8076);
((PrimitiveColTypeContext)_localctx).type = match(TIME);
}
break;
case DATEV2:
enterOuterAlt(_localctx, 12);
{
setState(8077);
((PrimitiveColTypeContext)_localctx).type = match(DATEV2);
}
break;
case DATETIMEV2:
enterOuterAlt(_localctx, 13);
{
setState(8078);
((PrimitiveColTypeContext)_localctx).type = match(DATETIMEV2);
}
break;
case DATEV1:
enterOuterAlt(_localctx, 14);
{
setState(8079);
((PrimitiveColTypeContext)_localctx).type = match(DATEV1);
}
break;
case DATETIMEV1:
enterOuterAlt(_localctx, 15);
{
setState(8080);
((PrimitiveColTypeContext)_localctx).type = match(DATETIMEV1);
}
break;
case BITMAP:
enterOuterAlt(_localctx, 16);
{
setState(8081);
((PrimitiveColTypeContext)_localctx).type = match(BITMAP);
}
break;
case QUANTILE_STATE:
enterOuterAlt(_localctx, 17);
{
setState(8082);
((PrimitiveColTypeContext)_localctx).type = match(QUANTILE_STATE);
}
break;
case HLL:
enterOuterAlt(_localctx, 18);
{
setState(8083);
((PrimitiveColTypeContext)_localctx).type = match(HLL);
}
break;
case AGG_STATE:
enterOuterAlt(_localctx, 19);
{
setState(8084);
((PrimitiveColTypeContext)_localctx).type = match(AGG_STATE);
}
break;
case STRING:
enterOuterAlt(_localctx, 20);
{
setState(8085);
((PrimitiveColTypeContext)_localctx).type = match(STRING);
}
break;
case JSON:
enterOuterAlt(_localctx, 21);
{
setState(8086);
((PrimitiveColTypeContext)_localctx).type = match(JSON);
}
break;
case JSONB:
enterOuterAlt(_localctx, 22);
{
setState(8087);
((PrimitiveColTypeContext)_localctx).type = match(JSONB);
}
break;
case TEXT:
enterOuterAlt(_localctx, 23);
{
setState(8088);
((PrimitiveColTypeContext)_localctx).type = match(TEXT);
}
break;
case VARCHAR:
enterOuterAlt(_localctx, 24);
{
setState(8089);
((PrimitiveColTypeContext)_localctx).type = match(VARCHAR);
}
break;
case CHAR:
enterOuterAlt(_localctx, 25);
{
setState(8090);
((PrimitiveColTypeContext)_localctx).type = match(CHAR);
}
break;
case DECIMAL:
enterOuterAlt(_localctx, 26);
{
setState(8091);
((PrimitiveColTypeContext)_localctx).type = match(DECIMAL);
}
break;
case DECIMALV2:
enterOuterAlt(_localctx, 27);
{
setState(8092);
((PrimitiveColTypeContext)_localctx).type = match(DECIMALV2);
}
break;
case DECIMALV3:
enterOuterAlt(_localctx, 28);
{
setState(8093);
((PrimitiveColTypeContext)_localctx).type = match(DECIMALV3);
}
break;
case IPV4:
enterOuterAlt(_localctx, 29);
{
setState(8094);
((PrimitiveColTypeContext)_localctx).type = match(IPV4);
}
break;
case IPV6:
enterOuterAlt(_localctx, 30);
{
setState(8095);
((PrimitiveColTypeContext)_localctx).type = match(IPV6);
}
break;
case ALL:
enterOuterAlt(_localctx, 31);
{
setState(8096);
((PrimitiveColTypeContext)_localctx).type = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComplexColTypeListContext extends ParserRuleContext {
public List<ComplexColTypeContext> complexColType() {
return getRuleContexts(ComplexColTypeContext.class);
}
public ComplexColTypeContext complexColType(int i) {
return getRuleContext(ComplexColTypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public ComplexColTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_complexColTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterComplexColTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitComplexColTypeList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitComplexColTypeList(this);
else return visitor.visitChildren(this);
}
}
public final ComplexColTypeListContext complexColTypeList() throws RecognitionException {
ComplexColTypeListContext _localctx = new ComplexColTypeListContext(_ctx, getState());
enterRule(_localctx, 690, RULE_complexColTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8099);
complexColType();
setState(8104);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(8100);
match(COMMA);
setState(8101);
complexColType();
}
}
setState(8106);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComplexColTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public ComplexColTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_complexColType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterComplexColType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitComplexColType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitComplexColType(this);
else return visitor.visitChildren(this);
}
}
public final ComplexColTypeContext complexColType() throws RecognitionException {
ComplexColTypeContext _localctx = new ComplexColTypeContext(_ctx, getState());
enterRule(_localctx, 692, RULE_complexColType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8107);
identifier();
setState(8108);
match(COLON);
setState(8109);
dataType();
setState(8111);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(8110);
commentSpec();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariantTypeDefinitionsContext extends ParserRuleContext {
public VariantTypeDefinitionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantTypeDefinitions; }
public VariantTypeDefinitionsContext() { }
public void copyFrom(VariantTypeDefinitionsContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VariantWithOnlyFieldsContext extends VariantTypeDefinitionsContext {
public TerminalNode VARIANT() { return getToken(PLParser.VARIANT, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public VariantSubColTypeListContext variantSubColTypeList() {
return getRuleContext(VariantSubColTypeListContext.class,0);
}
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public VariantWithOnlyFieldsContext(VariantTypeDefinitionsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantWithOnlyFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantWithOnlyFields(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantWithOnlyFields(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VariantWithOnlyPropsContext extends VariantTypeDefinitionsContext {
public PropertyClauseContext properties;
public TerminalNode VARIANT() { return getToken(PLParser.VARIANT, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public VariantWithOnlyPropsContext(VariantTypeDefinitionsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantWithOnlyProps(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantWithOnlyProps(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantWithOnlyProps(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VariantContext extends VariantTypeDefinitionsContext {
public TerminalNode VARIANT() { return getToken(PLParser.VARIANT, 0); }
public VariantContext(VariantTypeDefinitionsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariant(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariant(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VariantWithFieldsAndPropsContext extends VariantTypeDefinitionsContext {
public PropertyClauseContext properties;
public TerminalNode VARIANT() { return getToken(PLParser.VARIANT, 0); }
public TerminalNode LT() { return getToken(PLParser.LT, 0); }
public VariantSubColTypeListContext variantSubColTypeList() {
return getRuleContext(VariantSubColTypeListContext.class,0);
}
public TerminalNode COMMA() { return getToken(PLParser.COMMA, 0); }
public TerminalNode GT() { return getToken(PLParser.GT, 0); }
public PropertyClauseContext propertyClause() {
return getRuleContext(PropertyClauseContext.class,0);
}
public VariantWithFieldsAndPropsContext(VariantTypeDefinitionsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantWithFieldsAndProps(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantWithFieldsAndProps(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantWithFieldsAndProps(this);
else return visitor.visitChildren(this);
}
}
public final VariantTypeDefinitionsContext variantTypeDefinitions() throws RecognitionException {
VariantTypeDefinitionsContext _localctx = new VariantTypeDefinitionsContext(_ctx, getState());
enterRule(_localctx, 694, RULE_variantTypeDefinitions);
try {
setState(8131);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1126,_ctx) ) {
case 1:
_localctx = new VariantWithFieldsAndPropsContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8113);
match(VARIANT);
setState(8114);
match(LT);
setState(8115);
variantSubColTypeList();
setState(8116);
match(COMMA);
setState(8117);
((VariantWithFieldsAndPropsContext)_localctx).properties = propertyClause();
setState(8118);
match(GT);
}
break;
case 2:
_localctx = new VariantWithOnlyFieldsContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(8120);
match(VARIANT);
setState(8121);
match(LT);
setState(8122);
variantSubColTypeList();
setState(8123);
match(GT);
}
break;
case 3:
_localctx = new VariantWithOnlyPropsContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(8125);
match(VARIANT);
setState(8126);
match(LT);
setState(8127);
((VariantWithOnlyPropsContext)_localctx).properties = propertyClause();
setState(8128);
match(GT);
}
break;
case 4:
_localctx = new VariantContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(8130);
match(VARIANT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariantSubColTypeListContext extends ParserRuleContext {
public List<VariantSubColTypeContext> variantSubColType() {
return getRuleContexts(VariantSubColTypeContext.class);
}
public VariantSubColTypeContext variantSubColType(int i) {
return getRuleContext(VariantSubColTypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(PLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(PLParser.COMMA, i);
}
public VariantSubColTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantSubColTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantSubColTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantSubColTypeList(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantSubColTypeList(this);
else return visitor.visitChildren(this);
}
}
public final VariantSubColTypeListContext variantSubColTypeList() throws RecognitionException {
VariantSubColTypeListContext _localctx = new VariantSubColTypeListContext(_ctx, getState());
enterRule(_localctx, 696, RULE_variantSubColTypeList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(8133);
variantSubColType();
setState(8138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1127,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(8134);
match(COMMA);
setState(8135);
variantSubColType();
}
}
}
setState(8140);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1127,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariantSubColTypeContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode COLON() { return getToken(PLParser.COLON, 0); }
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public VariantSubColMatchTypeContext variantSubColMatchType() {
return getRuleContext(VariantSubColMatchTypeContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public VariantSubColTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantSubColType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantSubColType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantSubColType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantSubColType(this);
else return visitor.visitChildren(this);
}
}
public final VariantSubColTypeContext variantSubColType() throws RecognitionException {
VariantSubColTypeContext _localctx = new VariantSubColTypeContext(_ctx, getState());
enterRule(_localctx, 698, RULE_variantSubColType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8142);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MATCH_NAME || _la==MATCH_NAME_GLOB) {
{
setState(8141);
variantSubColMatchType();
}
}
setState(8144);
match(STRING_LITERAL);
setState(8145);
match(COLON);
setState(8146);
dataType();
setState(8148);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(8147);
commentSpec();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariantSubColMatchTypeContext extends ParserRuleContext {
public TerminalNode MATCH_NAME() { return getToken(PLParser.MATCH_NAME, 0); }
public TerminalNode MATCH_NAME_GLOB() { return getToken(PLParser.MATCH_NAME_GLOB, 0); }
public VariantSubColMatchTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantSubColMatchType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterVariantSubColMatchType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitVariantSubColMatchType(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitVariantSubColMatchType(this);
else return visitor.visitChildren(this);
}
}
public final VariantSubColMatchTypeContext variantSubColMatchType() throws RecognitionException {
VariantSubColMatchTypeContext _localctx = new VariantSubColMatchTypeContext(_ctx, getState());
enterRule(_localctx, 700, RULE_variantSubColMatchType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8150);
_la = _input.LA(1);
if ( !(_la==MATCH_NAME || _la==MATCH_NAME_GLOB) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommentSpecContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public CommentSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterCommentSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitCommentSpec(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitCommentSpec(this);
else return visitor.visitChildren(this);
}
}
public final CommentSpecContext commentSpec() throws RecognitionException {
CommentSpecContext _localctx = new CommentSpecContext(_ctx, getState());
enterRule(_localctx, 702, RULE_commentSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(8152);
match(COMMENT);
setState(8153);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SampleContext extends ParserRuleContext {
public Token seed;
public TerminalNode TABLESAMPLE() { return getToken(PLParser.TABLESAMPLE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(PLParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(PLParser.RIGHT_PAREN, 0); }
public SampleMethodContext sampleMethod() {
return getRuleContext(SampleMethodContext.class,0);
}
public TerminalNode REPEATABLE() { return getToken(PLParser.REPEATABLE, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public SampleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sample; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSample(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSample(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSample(this);
else return visitor.visitChildren(this);
}
}
public final SampleContext sample() throws RecognitionException {
SampleContext _localctx = new SampleContext(_ctx, getState());
enterRule(_localctx, 704, RULE_sample);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8155);
match(TABLESAMPLE);
setState(8156);
match(LEFT_PAREN);
setState(8158);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTEGER_VALUE) {
{
setState(8157);
sampleMethod();
}
}
setState(8160);
match(RIGHT_PAREN);
setState(8163);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1131,_ctx) ) {
case 1:
{
setState(8161);
match(REPEATABLE);
setState(8162);
((SampleContext)_localctx).seed = match(INTEGER_VALUE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SampleMethodContext extends ParserRuleContext {
public SampleMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampleMethod; }
public SampleMethodContext() { }
public void copyFrom(SampleMethodContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SampleByRowsContext extends SampleMethodContext {
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode ROWS() { return getToken(PLParser.ROWS, 0); }
public SampleByRowsContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSampleByRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSampleByRows(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSampleByRows(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SampleByPercentileContext extends SampleMethodContext {
public Token percentage;
public TerminalNode PERCENT() { return getToken(PLParser.PERCENT, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public SampleByPercentileContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterSampleByPercentile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitSampleByPercentile(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitSampleByPercentile(this);
else return visitor.visitChildren(this);
}
}
public final SampleMethodContext sampleMethod() throws RecognitionException {
SampleMethodContext _localctx = new SampleMethodContext(_ctx, getState());
enterRule(_localctx, 706, RULE_sampleMethod);
try {
setState(8169);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1132,_ctx) ) {
case 1:
_localctx = new SampleByPercentileContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8165);
((SampleByPercentileContext)_localctx).percentage = match(INTEGER_VALUE);
setState(8166);
match(PERCENT);
}
break;
case 2:
_localctx = new SampleByRowsContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(8167);
match(INTEGER_VALUE);
setState(8168);
match(ROWS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableSnapshotContext extends ParserRuleContext {
public Token version;
public Token time;
public TerminalNode FOR() { return getToken(PLParser.FOR, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public TerminalNode AS() { return getToken(PLParser.AS, 0); }
public TerminalNode OF() { return getToken(PLParser.OF, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(PLParser.STRING_LITERAL, 0); }
public TerminalNode TIME() { return getToken(PLParser.TIME, 0); }
public TableSnapshotContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableSnapshot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterTableSnapshot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitTableSnapshot(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitTableSnapshot(this);
else return visitor.visitChildren(this);
}
}
public final TableSnapshotContext tableSnapshot() throws RecognitionException {
TableSnapshotContext _localctx = new TableSnapshotContext(_ctx, getState());
enterRule(_localctx, 708, RULE_tableSnapshot);
int _la;
try {
setState(8181);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1133,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(8171);
match(FOR);
setState(8172);
match(VERSION);
setState(8173);
match(AS);
setState(8174);
match(OF);
setState(8175);
((TableSnapshotContext)_localctx).version = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==STRING_LITERAL || _la==INTEGER_VALUE) ) {
((TableSnapshotContext)_localctx).version = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(8176);
match(FOR);
setState(8177);
match(TIME);
setState(8178);
match(AS);
setState(8179);
match(OF);
setState(8180);
((TableSnapshotContext)_localctx).time = match(STRING_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ErrorCapturingIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ErrorCapturingIdentifierExtraContext errorCapturingIdentifierExtra() {
return getRuleContext(ErrorCapturingIdentifierExtraContext.class,0);
}
public ErrorCapturingIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_errorCapturingIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterErrorCapturingIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitErrorCapturingIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitErrorCapturingIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ErrorCapturingIdentifierContext errorCapturingIdentifier() throws RecognitionException {
ErrorCapturingIdentifierContext _localctx = new ErrorCapturingIdentifierContext(_ctx, getState());
enterRule(_localctx, 710, RULE_errorCapturingIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(8183);
identifier();
setState(8184);
errorCapturingIdentifierExtra();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ErrorCapturingIdentifierExtraContext extends ParserRuleContext {
public ErrorCapturingIdentifierExtraContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_errorCapturingIdentifierExtra; }
public ErrorCapturingIdentifierExtraContext() { }
public void copyFrom(ErrorCapturingIdentifierExtraContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ErrorIdentContext extends ErrorCapturingIdentifierExtraContext {
public List<TerminalNode> SUBTRACT() { return getTokens(PLParser.SUBTRACT); }
public TerminalNode SUBTRACT(int i) {
return getToken(PLParser.SUBTRACT, i);
}
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public ErrorIdentContext(ErrorCapturingIdentifierExtraContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterErrorIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitErrorIdent(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitErrorIdent(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RealIdentContext extends ErrorCapturingIdentifierExtraContext {
public RealIdentContext(ErrorCapturingIdentifierExtraContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterRealIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitRealIdent(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitRealIdent(this);
else return visitor.visitChildren(this);
}
}
public final ErrorCapturingIdentifierExtraContext errorCapturingIdentifierExtra() throws RecognitionException {
ErrorCapturingIdentifierExtraContext _localctx = new ErrorCapturingIdentifierExtraContext(_ctx, getState());
enterRule(_localctx, 712, RULE_errorCapturingIdentifierExtra);
try {
int _alt;
setState(8193);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1135,_ctx) ) {
case 1:
_localctx = new ErrorIdentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8188);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(8186);
match(SUBTRACT);
setState(8187);
identifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(8190);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1134,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case 2:
_localctx = new RealIdentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public StrictIdentifierContext strictIdentifier() {
return getRuleContext(StrictIdentifierContext.class,0);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 714, RULE_identifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(8195);
strictIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StrictIdentifierContext extends ParserRuleContext {
public StrictIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strictIdentifier; }
public StrictIdentifierContext() { }
public void copyFrom(StrictIdentifierContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QuotedIdentifierAlternativeContext extends StrictIdentifierContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public QuotedIdentifierAlternativeContext(StrictIdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQuotedIdentifierAlternative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQuotedIdentifierAlternative(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQuotedIdentifierAlternative(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnquotedIdentifierContext extends StrictIdentifierContext {
public TerminalNode IDENTIFIER() { return getToken(PLParser.IDENTIFIER, 0); }
public NonReservedContext nonReserved() {
return getRuleContext(NonReservedContext.class,0);
}
public UnquotedIdentifierContext(StrictIdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterUnquotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitUnquotedIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitUnquotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final StrictIdentifierContext strictIdentifier() throws RecognitionException {
StrictIdentifierContext _localctx = new StrictIdentifierContext(_ctx, getState());
enterRule(_localctx, 716, RULE_strictIdentifier);
try {
setState(8200);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8197);
match(IDENTIFIER);
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new QuotedIdentifierAlternativeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(8198);
quotedIdentifier();
}
break;
case DAYS:
case SQL:
case LEFT_BRACE:
case RIGHT_BRACE:
case ACTIONS:
case AFTER:
case AGG_STATE:
case AGGREGATE:
case ALIAS:
case ANALYZED:
case ARRAY:
case AT:
case AUTHORS:
case AUTO_INCREMENT:
case ALWAYS:
case BACKENDS:
case BACKUP:
case BEGIN:
case BELONG:
case BIN:
case BITAND:
case BITMAP:
case BITMAP_EMPTY:
case BITMAP_UNION:
case BITOR:
case BITXOR:
case BLOB:
case BOOLEAN:
case BRANCH:
case BRIEF:
case BROKER:
case BUCKETS:
case BUILD:
case BUILTIN:
case BULK:
case CACHE:
case CACHED:
case CALL:
case CATALOG:
case CATALOGS:
case CHAIN:
case CHAR:
case CHARSET:
case CHECK:
case CLUSTER:
case CLUSTERS:
case COLLATION:
case COLLECT:
case COLOCATE:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case COMPACT:
case COMPLETE:
case COMPRESS_TYPE:
case COMPUTE:
case CONDITIONS:
case CONFIG:
case CONNECTION:
case CONNECTION_ID:
case CONSISTENT:
case CONSTRAINTS:
case CONVERT:
case CONVERT_LSC:
case COPY:
case COUNT:
case CREATION:
case CRON:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DATETIME:
case DATETIMEV2:
case DATEV2:
case DATETIMEV1:
case DATEV1:
case DAY:
case DECIMAL:
case DECIMALV2:
case DECIMALV3:
case DEFERRED:
case DEMAND:
case DIAGNOSE:
case DIAGNOSIS:
case DISTINCTPC:
case DISTINCTPCSA:
case DO:
case DORIS_INTERNAL_TABLE_ID:
case DUAL:
case DYNAMIC:
case E:
case ENABLE:
case ENCRYPTKEY:
case ENCRYPTKEYS:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERRORS:
case ESCAPE:
case EVENTS:
case EVERY:
case EXCLUDE:
case EXPIRED:
case EXTERNAL:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FEATURE:
case FIELDS:
case FILE:
case FILTER:
case FIRST:
case FORMAT:
case FREE:
case FRONTENDS:
case FUNCTION:
case GENERATED:
case GENERIC:
case GLOBAL:
case GRAPH:
case GROUPING:
case GROUPS:
case HASH:
case HDFS:
case HELP:
case HISTOGRAM:
case HLL_UNION:
case HOSTNAME:
case HOTSPOT:
case HOUR:
case HOURS:
case HUB:
case IDENTIFIED:
case IGNORE:
case IMMEDIATE:
case INCREMENTAL:
case INDEXES:
case INVERTED:
case IPV4:
case IPV6:
case IS_NOT_NULL_PRED:
case IS_NULL_PRED:
case ISNULL:
case ISOLATION:
case JOB:
case JOBS:
case JSON:
case JSONB:
case LABEL:
case LAST:
case LDAP:
case LDAP_ADMIN_PASSWORD:
case LESS:
case LEVEL:
case LINES:
case LINK:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOCATION:
case LOCK:
case LOGICAL:
case MANUAL:
case MAP:
case MATCH_ALL:
case MATCH_ANY:
case MATCH_PHRASE:
case MATCH_PHRASE_EDGE:
case MATCH_PHRASE_PREFIX:
case MATCH_REGEXP:
case MATERIALIZED:
case MAX:
case MEMO:
case MERGE:
case MIGRATE:
case MIGRATIONS:
case MIN:
case MINUTE:
case MINUTES:
case MODIFY:
case MONTH:
case MTMV:
case NAME:
case NAMES:
case NEGATIVE:
case NEVER:
case NEXT:
case NGRAM_BF:
case NO:
case NON_NULLABLE:
case NULLS:
case OF:
case OFFSET:
case ONLY:
case OPEN:
case OPTIMIZED:
case PARAMETER:
case PARSED:
case PARTITIONS:
case PASSWORD:
case PASSWORD_EXPIRE:
case PASSWORD_HISTORY:
case PASSWORD_LOCK_TIME:
case PASSWORD_REUSE:
case PATH:
case PAUSE:
case PERCENT:
case PERIOD:
case PERMISSIVE:
case PHYSICAL:
case PI:
case PLAN:
case PRIVILEGES:
case PROCESS:
case PLUGIN:
case PLUGINS:
case POLICY:
case PROC:
case PROCESSLIST:
case PROFILE:
case PROPERTIES:
case PROPERTY:
case QUANTILE_STATE:
case QUANTILE_UNION:
case QUERY:
case QUOTA:
case RANDOM:
case RECENT:
case RECOVER:
case RECYCLE:
case REFRESH:
case REPEATABLE:
case REPLACE:
case REPLACE_IF_NOT_NULL:
case REPLAYER:
case REPOSITORIES:
case REPOSITORY:
case RESOURCE:
case RESOURCES:
case RESTORE:
case RESTRICTIVE:
case RESUME:
case RETAIN:
case RETENTION:
case RETURNS:
case REWRITTEN:
case RLIKE:
case ROLLBACK:
case ROLLUP:
case ROUTINE:
case S3:
case SAMPLE:
case SCHEDULE:
case SCHEDULER:
case SCHEMA:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SESSION_USER:
case SET_SESSION_VARIABLE:
case SHAPE:
case SKEW:
case SNAPSHOT:
case SNAPSHOTS:
case SONAME:
case SPLIT:
case STAGE:
case STAGES:
case START:
case STARTS:
case STATS:
case STATUS:
case STOP:
case STORAGE:
case STREAM:
case STREAMING:
case STRING:
case STRUCT:
case SUM:
case TABLES:
case TAG:
case TASK:
case TASKS:
case TEMPORARY:
case TEXT:
case THAN:
case TIME:
case TIMESTAMP:
case TRANSACTION:
case TREE:
case TRIGGERS:
case TRUNCATE:
case TYPE:
case TYPES:
case UNCOMMITTED:
case UNLOCK:
case UNSET:
case UP:
case USER:
case VALUE:
case VARCHAR:
case VARIABLE:
case VARIABLES:
case VARIANT:
case VAULT:
case VAULTS:
case VERBOSE:
case VERSION:
case VIEW:
case VIEWS:
case WARM:
case WARNINGS:
case WEEK:
case WORK:
case YEAR:
case HINT_START:
case HINT_END:
case COMMENT_START:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(8199);
nonReserved();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuotedIdentifierContext extends ParserRuleContext {
public TerminalNode BACKQUOTED_IDENTIFIER() { return getToken(PLParser.BACKQUOTED_IDENTIFIER, 0); }
public QuotedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitQuotedIdentifier(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final QuotedIdentifierContext quotedIdentifier() throws RecognitionException {
QuotedIdentifierContext _localctx = new QuotedIdentifierContext(_ctx, getState());
enterRule(_localctx, 718, RULE_quotedIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(8202);
match(BACKQUOTED_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NumberContext extends ParserRuleContext {
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
public NumberContext() { }
public void copyFrom(NumberContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DecimalLiteralContext extends NumberContext {
public TerminalNode EXPONENT_VALUE() { return getToken(PLParser.EXPONENT_VALUE, 0); }
public TerminalNode DECIMAL_VALUE() { return getToken(PLParser.DECIMAL_VALUE, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public DecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitDecimalLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerLiteralContext extends NumberContext {
public TerminalNode INTEGER_VALUE() { return getToken(PLParser.INTEGER_VALUE, 0); }
public TerminalNode SUBTRACT() { return getToken(PLParser.SUBTRACT, 0); }
public IntegerLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitIntegerLiteral(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 720, RULE_number);
int _la;
try {
setState(8212);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1139,_ctx) ) {
case 1:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(8205);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(8204);
match(SUBTRACT);
}
}
setState(8207);
match(INTEGER_VALUE);
}
break;
case 2:
_localctx = new DecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(8209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBTRACT) {
{
setState(8208);
match(SUBTRACT);
}
}
setState(8211);
_la = _input.LA(1);
if ( !(_la==EXPONENT_VALUE || _la==DECIMAL_VALUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NonReservedContext extends ParserRuleContext {
public TerminalNode ACTIONS() { return getToken(PLParser.ACTIONS, 0); }
public TerminalNode AFTER() { return getToken(PLParser.AFTER, 0); }
public TerminalNode AGG_STATE() { return getToken(PLParser.AGG_STATE, 0); }
public TerminalNode AGGREGATE() { return getToken(PLParser.AGGREGATE, 0); }
public TerminalNode ALIAS() { return getToken(PLParser.ALIAS, 0); }
public TerminalNode ALWAYS() { return getToken(PLParser.ALWAYS, 0); }
public TerminalNode ANALYZED() { return getToken(PLParser.ANALYZED, 0); }
public TerminalNode ARRAY() { return getToken(PLParser.ARRAY, 0); }
public TerminalNode AT() { return getToken(PLParser.AT, 0); }
public TerminalNode AUTHORS() { return getToken(PLParser.AUTHORS, 0); }
public TerminalNode AUTO_INCREMENT() { return getToken(PLParser.AUTO_INCREMENT, 0); }
public TerminalNode BACKENDS() { return getToken(PLParser.BACKENDS, 0); }
public TerminalNode BACKUP() { return getToken(PLParser.BACKUP, 0); }
public TerminalNode BEGIN() { return getToken(PLParser.BEGIN, 0); }
public TerminalNode BELONG() { return getToken(PLParser.BELONG, 0); }
public TerminalNode BIN() { return getToken(PLParser.BIN, 0); }
public TerminalNode BITAND() { return getToken(PLParser.BITAND, 0); }
public TerminalNode BITMAP() { return getToken(PLParser.BITMAP, 0); }
public TerminalNode BITMAP_EMPTY() { return getToken(PLParser.BITMAP_EMPTY, 0); }
public TerminalNode BITMAP_UNION() { return getToken(PLParser.BITMAP_UNION, 0); }
public TerminalNode BITOR() { return getToken(PLParser.BITOR, 0); }
public TerminalNode BITXOR() { return getToken(PLParser.BITXOR, 0); }
public TerminalNode BLOB() { return getToken(PLParser.BLOB, 0); }
public TerminalNode BOOLEAN() { return getToken(PLParser.BOOLEAN, 0); }
public TerminalNode BRANCH() { return getToken(PLParser.BRANCH, 0); }
public TerminalNode BRIEF() { return getToken(PLParser.BRIEF, 0); }
public TerminalNode BROKER() { return getToken(PLParser.BROKER, 0); }
public TerminalNode BUCKETS() { return getToken(PLParser.BUCKETS, 0); }
public TerminalNode BUILD() { return getToken(PLParser.BUILD, 0); }
public TerminalNode BUILTIN() { return getToken(PLParser.BUILTIN, 0); }
public TerminalNode BULK() { return getToken(PLParser.BULK, 0); }
public TerminalNode CACHE() { return getToken(PLParser.CACHE, 0); }
public TerminalNode CACHED() { return getToken(PLParser.CACHED, 0); }
public TerminalNode CALL() { return getToken(PLParser.CALL, 0); }
public TerminalNode CATALOG() { return getToken(PLParser.CATALOG, 0); }
public TerminalNode CATALOGS() { return getToken(PLParser.CATALOGS, 0); }
public TerminalNode CHAIN() { return getToken(PLParser.CHAIN, 0); }
public TerminalNode CHAR() { return getToken(PLParser.CHAR, 0); }
public TerminalNode CHARSET() { return getToken(PLParser.CHARSET, 0); }
public TerminalNode CHECK() { return getToken(PLParser.CHECK, 0); }
public TerminalNode CLUSTER() { return getToken(PLParser.CLUSTER, 0); }
public TerminalNode CLUSTERS() { return getToken(PLParser.CLUSTERS, 0); }
public TerminalNode COLLATION() { return getToken(PLParser.COLLATION, 0); }
public TerminalNode COLLECT() { return getToken(PLParser.COLLECT, 0); }
public TerminalNode COLOCATE() { return getToken(PLParser.COLOCATE, 0); }
public TerminalNode COLUMNS() { return getToken(PLParser.COLUMNS, 0); }
public TerminalNode COMMENT() { return getToken(PLParser.COMMENT, 0); }
public TerminalNode COMMENT_START() { return getToken(PLParser.COMMENT_START, 0); }
public TerminalNode COMMIT() { return getToken(PLParser.COMMIT, 0); }
public TerminalNode COMMITTED() { return getToken(PLParser.COMMITTED, 0); }
public TerminalNode COMPACT() { return getToken(PLParser.COMPACT, 0); }
public TerminalNode COMPLETE() { return getToken(PLParser.COMPLETE, 0); }
public TerminalNode COMPRESS_TYPE() { return getToken(PLParser.COMPRESS_TYPE, 0); }
public TerminalNode COMPUTE() { return getToken(PLParser.COMPUTE, 0); }
public TerminalNode CONDITIONS() { return getToken(PLParser.CONDITIONS, 0); }
public TerminalNode CONFIG() { return getToken(PLParser.CONFIG, 0); }
public TerminalNode CONNECTION() { return getToken(PLParser.CONNECTION, 0); }
public TerminalNode CONNECTION_ID() { return getToken(PLParser.CONNECTION_ID, 0); }
public TerminalNode CONSISTENT() { return getToken(PLParser.CONSISTENT, 0); }
public TerminalNode CONSTRAINTS() { return getToken(PLParser.CONSTRAINTS, 0); }
public TerminalNode CONVERT() { return getToken(PLParser.CONVERT, 0); }
public TerminalNode CONVERT_LSC() { return getToken(PLParser.CONVERT_LSC, 0); }
public TerminalNode COPY() { return getToken(PLParser.COPY, 0); }
public TerminalNode COUNT() { return getToken(PLParser.COUNT, 0); }
public TerminalNode CREATION() { return getToken(PLParser.CREATION, 0); }
public TerminalNode CRON() { return getToken(PLParser.CRON, 0); }
public TerminalNode CURRENT_CATALOG() { return getToken(PLParser.CURRENT_CATALOG, 0); }
public TerminalNode CURRENT_DATE() { return getToken(PLParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(PLParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(PLParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_USER() { return getToken(PLParser.CURRENT_USER, 0); }
public TerminalNode DATA() { return getToken(PLParser.DATA, 0); }
public TerminalNode DATE() { return getToken(PLParser.DATE, 0); }
public TerminalNode DATETIME() { return getToken(PLParser.DATETIME, 0); }
public TerminalNode DATETIMEV1() { return getToken(PLParser.DATETIMEV1, 0); }
public TerminalNode DATETIMEV2() { return getToken(PLParser.DATETIMEV2, 0); }
public TerminalNode DATEV1() { return getToken(PLParser.DATEV1, 0); }
public TerminalNode DATEV2() { return getToken(PLParser.DATEV2, 0); }
public TerminalNode DAY() { return getToken(PLParser.DAY, 0); }
public TerminalNode DAYS() { return getToken(PLParser.DAYS, 0); }
public TerminalNode DECIMAL() { return getToken(PLParser.DECIMAL, 0); }
public TerminalNode DECIMALV2() { return getToken(PLParser.DECIMALV2, 0); }
public TerminalNode DECIMALV3() { return getToken(PLParser.DECIMALV3, 0); }
public TerminalNode DEFERRED() { return getToken(PLParser.DEFERRED, 0); }
public TerminalNode DEMAND() { return getToken(PLParser.DEMAND, 0); }
public TerminalNode DIAGNOSE() { return getToken(PLParser.DIAGNOSE, 0); }
public TerminalNode DIAGNOSIS() { return getToken(PLParser.DIAGNOSIS, 0); }
public TerminalNode DISTINCTPC() { return getToken(PLParser.DISTINCTPC, 0); }
public TerminalNode DISTINCTPCSA() { return getToken(PLParser.DISTINCTPCSA, 0); }
public TerminalNode DO() { return getToken(PLParser.DO, 0); }
public TerminalNode DORIS_INTERNAL_TABLE_ID() { return getToken(PLParser.DORIS_INTERNAL_TABLE_ID, 0); }
public TerminalNode DUAL() { return getToken(PLParser.DUAL, 0); }
public TerminalNode DYNAMIC() { return getToken(PLParser.DYNAMIC, 0); }
public TerminalNode E() { return getToken(PLParser.E, 0); }
public TerminalNode ENABLE() { return getToken(PLParser.ENABLE, 0); }
public TerminalNode ENCRYPTKEY() { return getToken(PLParser.ENCRYPTKEY, 0); }
public TerminalNode ENCRYPTKEYS() { return getToken(PLParser.ENCRYPTKEYS, 0); }
public TerminalNode END() { return getToken(PLParser.END, 0); }
public TerminalNode ENDS() { return getToken(PLParser.ENDS, 0); }
public TerminalNode ENGINE() { return getToken(PLParser.ENGINE, 0); }
public TerminalNode ENGINES() { return getToken(PLParser.ENGINES, 0); }
public TerminalNode ERRORS() { return getToken(PLParser.ERRORS, 0); }
public TerminalNode ESCAPE() { return getToken(PLParser.ESCAPE, 0); }
public TerminalNode EVENTS() { return getToken(PLParser.EVENTS, 0); }
public TerminalNode EVERY() { return getToken(PLParser.EVERY, 0); }
public TerminalNode EXCLUDE() { return getToken(PLParser.EXCLUDE, 0); }
public TerminalNode EXPIRED() { return getToken(PLParser.EXPIRED, 0); }
public TerminalNode EXTERNAL() { return getToken(PLParser.EXTERNAL, 0); }
public TerminalNode FAILED_LOGIN_ATTEMPTS() { return getToken(PLParser.FAILED_LOGIN_ATTEMPTS, 0); }
public TerminalNode FAST() { return getToken(PLParser.FAST, 0); }
public TerminalNode FEATURE() { return getToken(PLParser.FEATURE, 0); }
public TerminalNode FIELDS() { return getToken(PLParser.FIELDS, 0); }
public TerminalNode FILE() { return getToken(PLParser.FILE, 0); }
public TerminalNode FILTER() { return getToken(PLParser.FILTER, 0); }
public TerminalNode FIRST() { return getToken(PLParser.FIRST, 0); }
public TerminalNode FORMAT() { return getToken(PLParser.FORMAT, 0); }
public TerminalNode FREE() { return getToken(PLParser.FREE, 0); }
public TerminalNode FRONTENDS() { return getToken(PLParser.FRONTENDS, 0); }
public TerminalNode FUNCTION() { return getToken(PLParser.FUNCTION, 0); }
public TerminalNode GENERATED() { return getToken(PLParser.GENERATED, 0); }
public TerminalNode GENERIC() { return getToken(PLParser.GENERIC, 0); }
public TerminalNode GLOBAL() { return getToken(PLParser.GLOBAL, 0); }
public TerminalNode GRAPH() { return getToken(PLParser.GRAPH, 0); }
public TerminalNode GROUPING() { return getToken(PLParser.GROUPING, 0); }
public TerminalNode GROUPS() { return getToken(PLParser.GROUPS, 0); }
public TerminalNode HASH() { return getToken(PLParser.HASH, 0); }
public TerminalNode HDFS() { return getToken(PLParser.HDFS, 0); }
public TerminalNode HELP() { return getToken(PLParser.HELP, 0); }
public TerminalNode HINT_END() { return getToken(PLParser.HINT_END, 0); }
public TerminalNode HINT_START() { return getToken(PLParser.HINT_START, 0); }
public TerminalNode HISTOGRAM() { return getToken(PLParser.HISTOGRAM, 0); }
public TerminalNode HLL_UNION() { return getToken(PLParser.HLL_UNION, 0); }
public TerminalNode HOSTNAME() { return getToken(PLParser.HOSTNAME, 0); }
public TerminalNode HOTSPOT() { return getToken(PLParser.HOTSPOT, 0); }
public TerminalNode HOUR() { return getToken(PLParser.HOUR, 0); }
public TerminalNode HOURS() { return getToken(PLParser.HOURS, 0); }
public TerminalNode HUB() { return getToken(PLParser.HUB, 0); }
public TerminalNode IDENTIFIED() { return getToken(PLParser.IDENTIFIED, 0); }
public TerminalNode IGNORE() { return getToken(PLParser.IGNORE, 0); }
public TerminalNode IMMEDIATE() { return getToken(PLParser.IMMEDIATE, 0); }
public TerminalNode INCREMENTAL() { return getToken(PLParser.INCREMENTAL, 0); }
public TerminalNode INDEXES() { return getToken(PLParser.INDEXES, 0); }
public TerminalNode INVERTED() { return getToken(PLParser.INVERTED, 0); }
public TerminalNode IPV4() { return getToken(PLParser.IPV4, 0); }
public TerminalNode IPV6() { return getToken(PLParser.IPV6, 0); }
public TerminalNode IS_NOT_NULL_PRED() { return getToken(PLParser.IS_NOT_NULL_PRED, 0); }
public TerminalNode IS_NULL_PRED() { return getToken(PLParser.IS_NULL_PRED, 0); }
public TerminalNode ISNULL() { return getToken(PLParser.ISNULL, 0); }
public TerminalNode ISOLATION() { return getToken(PLParser.ISOLATION, 0); }
public TerminalNode JOB() { return getToken(PLParser.JOB, 0); }
public TerminalNode JOBS() { return getToken(PLParser.JOBS, 0); }
public TerminalNode JSON() { return getToken(PLParser.JSON, 0); }
public TerminalNode JSONB() { return getToken(PLParser.JSONB, 0); }
public TerminalNode LABEL() { return getToken(PLParser.LABEL, 0); }
public TerminalNode LAST() { return getToken(PLParser.LAST, 0); }
public TerminalNode LDAP() { return getToken(PLParser.LDAP, 0); }
public TerminalNode LDAP_ADMIN_PASSWORD() { return getToken(PLParser.LDAP_ADMIN_PASSWORD, 0); }
public TerminalNode LEFT_BRACE() { return getToken(PLParser.LEFT_BRACE, 0); }
public TerminalNode LESS() { return getToken(PLParser.LESS, 0); }
public TerminalNode LEVEL() { return getToken(PLParser.LEVEL, 0); }
public TerminalNode LINES() { return getToken(PLParser.LINES, 0); }
public TerminalNode LINK() { return getToken(PLParser.LINK, 0); }
public TerminalNode LOCAL() { return getToken(PLParser.LOCAL, 0); }
public TerminalNode LOCALTIME() { return getToken(PLParser.LOCALTIME, 0); }
public TerminalNode LOCALTIMESTAMP() { return getToken(PLParser.LOCALTIMESTAMP, 0); }
public TerminalNode LOCATION() { return getToken(PLParser.LOCATION, 0); }
public TerminalNode LOCK() { return getToken(PLParser.LOCK, 0); }
public TerminalNode LOGICAL() { return getToken(PLParser.LOGICAL, 0); }
public TerminalNode MANUAL() { return getToken(PLParser.MANUAL, 0); }
public TerminalNode MAP() { return getToken(PLParser.MAP, 0); }
public TerminalNode MATCH_ALL() { return getToken(PLParser.MATCH_ALL, 0); }
public TerminalNode MATCH_ANY() { return getToken(PLParser.MATCH_ANY, 0); }
public TerminalNode MATCH_PHRASE() { return getToken(PLParser.MATCH_PHRASE, 0); }
public TerminalNode MATCH_PHRASE_EDGE() { return getToken(PLParser.MATCH_PHRASE_EDGE, 0); }
public TerminalNode MATCH_PHRASE_PREFIX() { return getToken(PLParser.MATCH_PHRASE_PREFIX, 0); }
public TerminalNode MATCH_REGEXP() { return getToken(PLParser.MATCH_REGEXP, 0); }
public TerminalNode MATERIALIZED() { return getToken(PLParser.MATERIALIZED, 0); }
public TerminalNode MAX() { return getToken(PLParser.MAX, 0); }
public TerminalNode MEMO() { return getToken(PLParser.MEMO, 0); }
public TerminalNode MERGE() { return getToken(PLParser.MERGE, 0); }
public TerminalNode MIGRATE() { return getToken(PLParser.MIGRATE, 0); }
public TerminalNode MIGRATIONS() { return getToken(PLParser.MIGRATIONS, 0); }
public TerminalNode MIN() { return getToken(PLParser.MIN, 0); }
public TerminalNode MINUTE() { return getToken(PLParser.MINUTE, 0); }
public TerminalNode MINUTES() { return getToken(PLParser.MINUTES, 0); }
public TerminalNode MODIFY() { return getToken(PLParser.MODIFY, 0); }
public TerminalNode MONTH() { return getToken(PLParser.MONTH, 0); }
public TerminalNode MTMV() { return getToken(PLParser.MTMV, 0); }
public TerminalNode NAME() { return getToken(PLParser.NAME, 0); }
public TerminalNode NAMES() { return getToken(PLParser.NAMES, 0); }
public TerminalNode NEGATIVE() { return getToken(PLParser.NEGATIVE, 0); }
public TerminalNode NEVER() { return getToken(PLParser.NEVER, 0); }
public TerminalNode NEXT() { return getToken(PLParser.NEXT, 0); }
public TerminalNode NGRAM_BF() { return getToken(PLParser.NGRAM_BF, 0); }
public TerminalNode NO() { return getToken(PLParser.NO, 0); }
public TerminalNode NON_NULLABLE() { return getToken(PLParser.NON_NULLABLE, 0); }
public TerminalNode NULLS() { return getToken(PLParser.NULLS, 0); }
public TerminalNode OF() { return getToken(PLParser.OF, 0); }
public TerminalNode OFFSET() { return getToken(PLParser.OFFSET, 0); }
public TerminalNode ONLY() { return getToken(PLParser.ONLY, 0); }
public TerminalNode OPEN() { return getToken(PLParser.OPEN, 0); }
public TerminalNode OPTIMIZED() { return getToken(PLParser.OPTIMIZED, 0); }
public TerminalNode PARAMETER() { return getToken(PLParser.PARAMETER, 0); }
public TerminalNode PARSED() { return getToken(PLParser.PARSED, 0); }
public TerminalNode PASSWORD() { return getToken(PLParser.PASSWORD, 0); }
public TerminalNode PASSWORD_EXPIRE() { return getToken(PLParser.PASSWORD_EXPIRE, 0); }
public TerminalNode PASSWORD_HISTORY() { return getToken(PLParser.PASSWORD_HISTORY, 0); }
public TerminalNode PASSWORD_LOCK_TIME() { return getToken(PLParser.PASSWORD_LOCK_TIME, 0); }
public TerminalNode PASSWORD_REUSE() { return getToken(PLParser.PASSWORD_REUSE, 0); }
public TerminalNode PARTITIONS() { return getToken(PLParser.PARTITIONS, 0); }
public TerminalNode PATH() { return getToken(PLParser.PATH, 0); }
public TerminalNode PAUSE() { return getToken(PLParser.PAUSE, 0); }
public TerminalNode PERCENT() { return getToken(PLParser.PERCENT, 0); }
public TerminalNode PERIOD() { return getToken(PLParser.PERIOD, 0); }
public TerminalNode PERMISSIVE() { return getToken(PLParser.PERMISSIVE, 0); }
public TerminalNode PHYSICAL() { return getToken(PLParser.PHYSICAL, 0); }
public TerminalNode PI() { return getToken(PLParser.PI, 0); }
public TerminalNode PLAN() { return getToken(PLParser.PLAN, 0); }
public TerminalNode PLUGIN() { return getToken(PLParser.PLUGIN, 0); }
public TerminalNode PLUGINS() { return getToken(PLParser.PLUGINS, 0); }
public TerminalNode POLICY() { return getToken(PLParser.POLICY, 0); }
public TerminalNode PRIVILEGES() { return getToken(PLParser.PRIVILEGES, 0); }
public TerminalNode PROC() { return getToken(PLParser.PROC, 0); }
public TerminalNode PROCESS() { return getToken(PLParser.PROCESS, 0); }
public TerminalNode PROCESSLIST() { return getToken(PLParser.PROCESSLIST, 0); }
public TerminalNode PROFILE() { return getToken(PLParser.PROFILE, 0); }
public TerminalNode PROPERTIES() { return getToken(PLParser.PROPERTIES, 0); }
public TerminalNode PROPERTY() { return getToken(PLParser.PROPERTY, 0); }
public TerminalNode QUANTILE_STATE() { return getToken(PLParser.QUANTILE_STATE, 0); }
public TerminalNode QUANTILE_UNION() { return getToken(PLParser.QUANTILE_UNION, 0); }
public TerminalNode QUERY() { return getToken(PLParser.QUERY, 0); }
public TerminalNode QUOTA() { return getToken(PLParser.QUOTA, 0); }
public TerminalNode RANDOM() { return getToken(PLParser.RANDOM, 0); }
public TerminalNode RECENT() { return getToken(PLParser.RECENT, 0); }
public TerminalNode RECOVER() { return getToken(PLParser.RECOVER, 0); }
public TerminalNode RECYCLE() { return getToken(PLParser.RECYCLE, 0); }
public TerminalNode REFRESH() { return getToken(PLParser.REFRESH, 0); }
public TerminalNode REPEATABLE() { return getToken(PLParser.REPEATABLE, 0); }
public TerminalNode REPLACE() { return getToken(PLParser.REPLACE, 0); }
public TerminalNode REPLACE_IF_NOT_NULL() { return getToken(PLParser.REPLACE_IF_NOT_NULL, 0); }
public TerminalNode REPLAYER() { return getToken(PLParser.REPLAYER, 0); }
public TerminalNode REPOSITORIES() { return getToken(PLParser.REPOSITORIES, 0); }
public TerminalNode REPOSITORY() { return getToken(PLParser.REPOSITORY, 0); }
public TerminalNode RESOURCE() { return getToken(PLParser.RESOURCE, 0); }
public TerminalNode RESOURCES() { return getToken(PLParser.RESOURCES, 0); }
public TerminalNode RESTORE() { return getToken(PLParser.RESTORE, 0); }
public TerminalNode RESTRICTIVE() { return getToken(PLParser.RESTRICTIVE, 0); }
public TerminalNode RESUME() { return getToken(PLParser.RESUME, 0); }
public TerminalNode RETAIN() { return getToken(PLParser.RETAIN, 0); }
public TerminalNode RETENTION() { return getToken(PLParser.RETENTION, 0); }
public TerminalNode RETURNS() { return getToken(PLParser.RETURNS, 0); }
public TerminalNode REWRITTEN() { return getToken(PLParser.REWRITTEN, 0); }
public TerminalNode RIGHT_BRACE() { return getToken(PLParser.RIGHT_BRACE, 0); }
public TerminalNode RLIKE() { return getToken(PLParser.RLIKE, 0); }
public TerminalNode ROLLBACK() { return getToken(PLParser.ROLLBACK, 0); }
public TerminalNode ROLLUP() { return getToken(PLParser.ROLLUP, 0); }
public TerminalNode ROUTINE() { return getToken(PLParser.ROUTINE, 0); }
public TerminalNode S3() { return getToken(PLParser.S3, 0); }
public TerminalNode SAMPLE() { return getToken(PLParser.SAMPLE, 0); }
public TerminalNode SCHEDULE() { return getToken(PLParser.SCHEDULE, 0); }
public TerminalNode SCHEDULER() { return getToken(PLParser.SCHEDULER, 0); }
public TerminalNode SCHEMA() { return getToken(PLParser.SCHEMA, 0); }
public TerminalNode SECOND() { return getToken(PLParser.SECOND, 0); }
public TerminalNode SERIALIZABLE() { return getToken(PLParser.SERIALIZABLE, 0); }
public TerminalNode SET_SESSION_VARIABLE() { return getToken(PLParser.SET_SESSION_VARIABLE, 0); }
public TerminalNode SESSION() { return getToken(PLParser.SESSION, 0); }
public TerminalNode SESSION_USER() { return getToken(PLParser.SESSION_USER, 0); }
public TerminalNode SHAPE() { return getToken(PLParser.SHAPE, 0); }
public TerminalNode SKEW() { return getToken(PLParser.SKEW, 0); }
public TerminalNode SNAPSHOT() { return getToken(PLParser.SNAPSHOT, 0); }
public TerminalNode SNAPSHOTS() { return getToken(PLParser.SNAPSHOTS, 0); }
public TerminalNode SONAME() { return getToken(PLParser.SONAME, 0); }
public TerminalNode SPLIT() { return getToken(PLParser.SPLIT, 0); }
public TerminalNode SQL() { return getToken(PLParser.SQL, 0); }
public TerminalNode STAGE() { return getToken(PLParser.STAGE, 0); }
public TerminalNode STAGES() { return getToken(PLParser.STAGES, 0); }
public TerminalNode START() { return getToken(PLParser.START, 0); }
public TerminalNode STARTS() { return getToken(PLParser.STARTS, 0); }
public TerminalNode STATS() { return getToken(PLParser.STATS, 0); }
public TerminalNode STATUS() { return getToken(PLParser.STATUS, 0); }
public TerminalNode STOP() { return getToken(PLParser.STOP, 0); }
public TerminalNode STORAGE() { return getToken(PLParser.STORAGE, 0); }
public TerminalNode STREAM() { return getToken(PLParser.STREAM, 0); }
public TerminalNode STREAMING() { return getToken(PLParser.STREAMING, 0); }
public TerminalNode STRING() { return getToken(PLParser.STRING, 0); }
public TerminalNode STRUCT() { return getToken(PLParser.STRUCT, 0); }
public TerminalNode SUM() { return getToken(PLParser.SUM, 0); }
public TerminalNode TABLES() { return getToken(PLParser.TABLES, 0); }
public TerminalNode TAG() { return getToken(PLParser.TAG, 0); }
public TerminalNode TASK() { return getToken(PLParser.TASK, 0); }
public TerminalNode TASKS() { return getToken(PLParser.TASKS, 0); }
public TerminalNode TEMPORARY() { return getToken(PLParser.TEMPORARY, 0); }
public TerminalNode TEXT() { return getToken(PLParser.TEXT, 0); }
public TerminalNode THAN() { return getToken(PLParser.THAN, 0); }
public TerminalNode TIME() { return getToken(PLParser.TIME, 0); }
public TerminalNode TIMESTAMP() { return getToken(PLParser.TIMESTAMP, 0); }
public TerminalNode TRANSACTION() { return getToken(PLParser.TRANSACTION, 0); }
public TerminalNode TREE() { return getToken(PLParser.TREE, 0); }
public TerminalNode TRIGGERS() { return getToken(PLParser.TRIGGERS, 0); }
public TerminalNode TRUNCATE() { return getToken(PLParser.TRUNCATE, 0); }
public TerminalNode TYPE() { return getToken(PLParser.TYPE, 0); }
public TerminalNode TYPES() { return getToken(PLParser.TYPES, 0); }
public TerminalNode UNCOMMITTED() { return getToken(PLParser.UNCOMMITTED, 0); }
public TerminalNode UNLOCK() { return getToken(PLParser.UNLOCK, 0); }
public TerminalNode UNSET() { return getToken(PLParser.UNSET, 0); }
public TerminalNode UP() { return getToken(PLParser.UP, 0); }
public TerminalNode USER() { return getToken(PLParser.USER, 0); }
public TerminalNode VALUE() { return getToken(PLParser.VALUE, 0); }
public TerminalNode VARCHAR() { return getToken(PLParser.VARCHAR, 0); }
public TerminalNode VARIABLE() { return getToken(PLParser.VARIABLE, 0); }
public TerminalNode VARIABLES() { return getToken(PLParser.VARIABLES, 0); }
public TerminalNode VARIANT() { return getToken(PLParser.VARIANT, 0); }
public TerminalNode VAULT() { return getToken(PLParser.VAULT, 0); }
public TerminalNode VAULTS() { return getToken(PLParser.VAULTS, 0); }
public TerminalNode VERBOSE() { return getToken(PLParser.VERBOSE, 0); }
public TerminalNode VERSION() { return getToken(PLParser.VERSION, 0); }
public TerminalNode VIEW() { return getToken(PLParser.VIEW, 0); }
public TerminalNode VIEWS() { return getToken(PLParser.VIEWS, 0); }
public TerminalNode WARM() { return getToken(PLParser.WARM, 0); }
public TerminalNode WARNINGS() { return getToken(PLParser.WARNINGS, 0); }
public TerminalNode WEEK() { return getToken(PLParser.WEEK, 0); }
public TerminalNode WORK() { return getToken(PLParser.WORK, 0); }
public TerminalNode YEAR() { return getToken(PLParser.YEAR, 0); }
public NonReservedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonReserved; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).enterNonReserved(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PLParserListener ) ((PLParserListener)listener).exitNonReserved(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof PLParserVisitor ) return ((PLParserVisitor<? extends T>)visitor).visitNonReserved(this);
else return visitor.visitChildren(this);
}
}
public final NonReservedContext nonReserved() throws RecognitionException {
NonReservedContext _localctx = new NonReservedContext(_ctx, getState());
enterRule(_localctx, 722, RULE_nonReserved);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(8214);
_la = _input.LA(1);
if ( !(_la==DAYS || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & -3927138875067072511L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 8573859731775120419L) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & 1786987863640367103L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -1252761490469167143L) != 0) || ((((_la - 391)) & ~0x3f) == 0 && ((1L << (_la - 391)) & -2334635800102163585L) != 0) || ((((_la - 456)) & ~0x3f) == 0 && ((1L << (_la - 456)) & 9222670387358137151L) != 0) || ((((_la - 520)) & ~0x3f) == 0 && ((1L << (_la - 520)) & -894527767538830211L) != 0) || ((((_la - 584)) & ~0x3f) == 0 && ((1L << (_la - 584)) & -7342142259167539995L) != 0) || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & -2305842422950835435L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 4:
return block_end_sempred((Block_endContext)_localctx, predIndex);
case 12:
return expr_stmt_sempred((Expr_stmtContext)_localctx, predIndex);
case 50:
return create_routine_params_sempred((Create_routine_paramsContext)_localctx, predIndex);
case 91:
return bool_expr_sempred((Bool_exprContext)_localctx, predIndex);
case 97:
return expr_sempred((ExprContext)_localctx, predIndex);
case 118:
return func_param_sempred((Func_paramContext)_localctx, predIndex);
case 249:
return queryTerm_sempred((QueryTermContext)_localctx, predIndex);
case 252:
return querySpecification_sempred((QuerySpecificationContext)_localctx, predIndex);
case 320:
return booleanExpression_sempred((BooleanExpressionContext)_localctx, predIndex);
case 324:
return valueExpression_sempred((ValueExpressionContext)_localctx, predIndex);
case 325:
return primaryExpression_sempred((PrimaryExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean block_end_sempred(Block_endContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return !_input.LT(2).getText().equalsIgnoreCase("TRANSACTION");
}
return true;
}
private boolean expr_stmt_sempred(Expr_stmtContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return !_input.LT(1).getText().equalsIgnoreCase("GO");
}
return true;
}
private boolean create_routine_params_sempred(Create_routine_paramsContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return !_input.LT(1).getText().equalsIgnoreCase("IS") &&
!_input.LT(1).getText().equalsIgnoreCase("AS") &&
!(_input.LT(1).getText().equalsIgnoreCase("DYNAMIC") && _input.LT(2).getText().equalsIgnoreCase("RESULT"))
;
}
return true;
}
private boolean bool_expr_sempred(Bool_exprContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 2);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 4:
return precpred(_ctx, 13);
case 5:
return precpred(_ctx, 12);
case 6:
return precpred(_ctx, 14);
}
return true;
}
private boolean func_param_sempred(Func_paramContext _localctx, int predIndex) {
switch (predIndex) {
case 7:
return !_input.LT(1).getText().equalsIgnoreCase("INTO");
}
return true;
}
private boolean queryTerm_sempred(QueryTermContext _localctx, int predIndex) {
switch (predIndex) {
case 8:
return precpred(_ctx, 2);
case 9:
return precpred(_ctx, 1);
}
return true;
}
private boolean querySpecification_sempred(QuerySpecificationContext _localctx, int predIndex) {
switch (predIndex) {
case 10:
return doris_legacy_SQL_syntax;
}
return true;
}
private boolean booleanExpression_sempred(BooleanExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 11:
return precpred(_ctx, 4);
case 12:
return precpred(_ctx, 3);
case 13:
return precpred(_ctx, 2);
case 14:
return precpred(_ctx, 1);
}
return true;
}
private boolean valueExpression_sempred(ValueExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 15:
return precpred(_ctx, 3);
case 16:
return precpred(_ctx, 2);
case 17:
return precpred(_ctx, 1);
}
return true;
}
private boolean primaryExpression_sempred(PrimaryExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 18:
return precpred(_ctx, 11);
case 19:
return precpred(_ctx, 10);
case 20:
return precpred(_ctx, 5);
case 21:
return precpred(_ctx, 1);
}
return true;
}
private static final String _serializedATNSegment0 =
"\u0004\u0001\u02d9\u2019\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
"@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+
"E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+
"J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+
"O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+
"T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+
"Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+
"^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+
"c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+
"h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+
"m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+
"r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+
"w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+
"|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+
"\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+
"\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+
"\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+
"\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+
"\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+
"\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007"+
"\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007"+
"\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007"+
"\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007"+
"\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007"+
"\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007"+
"\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007"+
"\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007"+
"\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007"+
"\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007"+
"\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+
"\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+
"\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+
"\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007"+
"\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007"+
"\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007"+
"\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007"+
"\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007"+
"\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007"+
"\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007"+
"\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007"+
"\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007"+
"\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007"+
"\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007"+
"\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0002\u00da\u0007"+
"\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc\u0002\u00dd\u0007"+
"\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df\u0002\u00e0\u0007"+
"\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2\u0002\u00e3\u0007"+
"\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5\u0002\u00e6\u0007"+
"\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8\u0002\u00e9\u0007"+
"\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb\u0002\u00ec\u0007"+
"\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee\u0002\u00ef\u0007"+
"\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1\u0002\u00f2\u0007"+
"\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4\u0002\u00f5\u0007"+
"\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7\u0002\u00f8\u0007"+
"\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa\u0002\u00fb\u0007"+
"\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd\u0002\u00fe\u0007"+
"\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100\u0002\u0101\u0007"+
"\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103\u0002\u0104\u0007"+
"\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106\u0002\u0107\u0007"+
"\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109\u0002\u010a\u0007"+
"\u010a\u0002\u010b\u0007\u010b\u0002\u010c\u0007\u010c\u0002\u010d\u0007"+
"\u010d\u0002\u010e\u0007\u010e\u0002\u010f\u0007\u010f\u0002\u0110\u0007"+
"\u0110\u0002\u0111\u0007\u0111\u0002\u0112\u0007\u0112\u0002\u0113\u0007"+
"\u0113\u0002\u0114\u0007\u0114\u0002\u0115\u0007\u0115\u0002\u0116\u0007"+
"\u0116\u0002\u0117\u0007\u0117\u0002\u0118\u0007\u0118\u0002\u0119\u0007"+
"\u0119\u0002\u011a\u0007\u011a\u0002\u011b\u0007\u011b\u0002\u011c\u0007"+
"\u011c\u0002\u011d\u0007\u011d\u0002\u011e\u0007\u011e\u0002\u011f\u0007"+
"\u011f\u0002\u0120\u0007\u0120\u0002\u0121\u0007\u0121\u0002\u0122\u0007"+
"\u0122\u0002\u0123\u0007\u0123\u0002\u0124\u0007\u0124\u0002\u0125\u0007"+
"\u0125\u0002\u0126\u0007\u0126\u0002\u0127\u0007\u0127\u0002\u0128\u0007"+
"\u0128\u0002\u0129\u0007\u0129\u0002\u012a\u0007\u012a\u0002\u012b\u0007"+
"\u012b\u0002\u012c\u0007\u012c\u0002\u012d\u0007\u012d\u0002\u012e\u0007"+
"\u012e\u0002\u012f\u0007\u012f\u0002\u0130\u0007\u0130\u0002\u0131\u0007"+
"\u0131\u0002\u0132\u0007\u0132\u0002\u0133\u0007\u0133\u0002\u0134\u0007"+
"\u0134\u0002\u0135\u0007\u0135\u0002\u0136\u0007\u0136\u0002\u0137\u0007"+
"\u0137\u0002\u0138\u0007\u0138\u0002\u0139\u0007\u0139\u0002\u013a\u0007"+
"\u013a\u0002\u013b\u0007\u013b\u0002\u013c\u0007\u013c\u0002\u013d\u0007"+
"\u013d\u0002\u013e\u0007\u013e\u0002\u013f\u0007\u013f\u0002\u0140\u0007"+
"\u0140\u0002\u0141\u0007\u0141\u0002\u0142\u0007\u0142\u0002\u0143\u0007"+
"\u0143\u0002\u0144\u0007\u0144\u0002\u0145\u0007\u0145\u0002\u0146\u0007"+
"\u0146\u0002\u0147\u0007\u0147\u0002\u0148\u0007\u0148\u0002\u0149\u0007"+
"\u0149\u0002\u014a\u0007\u014a\u0002\u014b\u0007\u014b\u0002\u014c\u0007"+
"\u014c\u0002\u014d\u0007\u014d\u0002\u014e\u0007\u014e\u0002\u014f\u0007"+
"\u014f\u0002\u0150\u0007\u0150\u0002\u0151\u0007\u0151\u0002\u0152\u0007"+
"\u0152\u0002\u0153\u0007\u0153\u0002\u0154\u0007\u0154\u0002\u0155\u0007"+
"\u0155\u0002\u0156\u0007\u0156\u0002\u0157\u0007\u0157\u0002\u0158\u0007"+
"\u0158\u0002\u0159\u0007\u0159\u0002\u015a\u0007\u015a\u0002\u015b\u0007"+
"\u015b\u0002\u015c\u0007\u015c\u0002\u015d\u0007\u015d\u0002\u015e\u0007"+
"\u015e\u0002\u015f\u0007\u015f\u0002\u0160\u0007\u0160\u0002\u0161\u0007"+
"\u0161\u0002\u0162\u0007\u0162\u0002\u0163\u0007\u0163\u0002\u0164\u0007"+
"\u0164\u0002\u0165\u0007\u0165\u0002\u0166\u0007\u0166\u0002\u0167\u0007"+
"\u0167\u0002\u0168\u0007\u0168\u0002\u0169\u0007\u0169\u0001\u0000\u0001"+
"\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001\u02da\b\u0001\u0001"+
"\u0001\u0003\u0001\u02dd\b\u0001\u0004\u0001\u02df\b\u0001\u000b\u0001"+
"\f\u0001\u02e0\u0001\u0002\u0003\u0002\u02e4\b\u0002\u0001\u0002\u0001"+
"\u0002\u0001\u0002\u0003\u0002\u02e9\b\u0002\u0001\u0002\u0001\u0002\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u02f0\b\u0003\u0001\u0003\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u02f6\b\u0003\u0003\u0003\u02f8"+
"\b\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0004"+
"\u0005\u02ff\b\u0005\u000b\u0005\f\u0005\u0300\u0001\u0005\u0003\u0005"+
"\u0304\b\u0005\u0003\u0005\u0306\b\u0005\u0001\u0006\u0001\u0006\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0333"+
"\b\u0007\u0001\b\u0001\b\u0001\t\u0001\t\u0004\t\u0339\b\t\u000b\t\f\t"+
"\u033a\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001"+
"\u000b\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0003\r\u034b\b"+
"\r\u0001\r\u0001\r\u0001\r\u0005\r\u0350\b\r\n\r\f\r\u0353\t\r\u0003\r"+
"\u0355\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003\u000e"+
"\u035b\b\u000e\u0001\u000f\u0001\u000f\u0003\u000f\u035f\b\u000f\u0001"+
"\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+
"\u000f\u0003\u000f\u0368\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003"+
"\u000f\u036d\b\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+
"\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u0378"+
"\b\u0011\n\u0011\f\u0011\u037b\t\u0011\u0001\u0011\u0001\u0011\u0003\u0011"+
"\u037f\b\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+
"\u0005\u0011\u0386\b\u0011\n\u0011\f\u0011\u0389\t\u0011\u0001\u0011\u0001"+
"\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0005"+
"\u0012\u0392\b\u0012\n\u0012\f\u0012\u0395\t\u0012\u0001\u0012\u0001\u0012"+
"\u0003\u0012\u0399\b\u0012\u0001\u0012\u0003\u0012\u039c\b\u0012\u0001"+
"\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+
"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003"+
"\u0013\u03aa\b\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001"+
"\u0014\u0003\u0014\u03b1\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
"\u0014\u0001\u0014\u0005\u0014\u03b8\b\u0014\n\u0014\f\u0014\u03bb\t\u0014"+
"\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015"+
"\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
"\u03c8\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0005\u0017"+
"\u03ce\b\u0017\n\u0017\f\u0017\u03d1\t\u0017\u0001\u0018\u0001\u0018\u0001"+
"\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u03d9\b\u0018\n"+
"\u0018\f\u0018\u03dc\t\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
"\u0019\u0001\u0019\u0005\u0019\u03e3\b\u0019\n\u0019\f\u0019\u03e6\t\u0019"+
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u03ec\b\u001a"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0005\u001b\u03f1\b\u001b\n\u001b"+
"\f\u001b\u03f4\t\u001b\u0001\u001b\u0003\u001b\u03f7\b\u001b\u0001\u001b"+
"\u0001\u001b\u0003\u001b\u03fb\b\u001b\u0001\u001b\u0005\u001b\u03fe\b"+
"\u001b\n\u001b\f\u001b\u0401\t\u001b\u0001\u001b\u0003\u001b\u0404\b\u001b"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u0409\b\u001b\u0001\u001b"+
"\u0001\u001b\u0003\u001b\u040d\b\u001b\u0001\u001b\u0001\u001b\u0003\u001b"+
"\u0411\b\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d"+
"\u0001\u001d\u0001\u001d\u0001\u001d\u0003\u001d\u041b\b\u001d\u0001\u001d"+
"\u0001\u001d\u0003\u001d\u041f\b\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+
"\u0003\u001d\u0424\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e"+
"\u0429\b\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u042d\b\u001e\u0001"+
"\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+
" \u0001 \u0001 \u0003 \u043a\b \u0001 \u0001 \u0001!\u0001!\u0001!\u0001"+
"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u044a"+
"\b!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0003"+
"!\u0469\b!\u0003!\u046b\b!\u0001\"\u0001\"\u0001\"\u0003\"\u0470\b\"\u0001"+
"\"\u0001\"\u0003\"\u0474\b\"\u0001\"\u0001\"\u0001#\u0003#\u0479\b#\u0001"+
"#\u0001#\u0001#\u0001#\u0001#\u0003#\u0480\b#\u0001#\u0003#\u0483\b#\u0001"+
"$\u0003$\u0486\b$\u0001$\u0001$\u0001$\u0003$\u048b\b$\u0001$\u0001$\u0003"+
"$\u048f\b$\u0003$\u0491\b$\u0001%\u0001%\u0001%\u0001%\u0003%\u0497\b"+
"%\u0001%\u0003%\u049a\b%\u0001%\u0001%\u0001%\u0003%\u049f\b%\u0001%\u0001"+
"%\u0003%\u04a3\b%\u0001%\u0003%\u04a6\b%\u0001%\u0001%\u0001&\u0001&\u0001"+
"&\u0003&\u04ad\b&\u0001\'\u0001\'\u0001\'\u0001\'\u0003\'\u04b3\b\'\u0001"+
"\'\u0003\'\u04b6\b\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+
"\'\u0001\'\u0003\'\u04c0\b\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0005"+
"(\u04c7\b(\n(\f(\u04ca\t(\u0001)\u0001)\u0001)\u0001)\u0003)\u04d0\b)"+
"\u0001)\u0001)\u0001)\u0001)\u0001)\u0003)\u04d7\b)\u0003)\u04d9\b)\u0001"+
"*\u0001*\u0001*\u0001*\u0003*\u04df\b*\u0001*\u0003*\u04e2\b*\u0001*\u0001"+
"*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u04ed\b*\u0001"+
"+\u0001+\u0001+\u0001+\u0001+\u0005+\u04f4\b+\n+\f+\u04f7\t+\u0001,\u0001"+
",\u0001,\u0003,\u04fc\b,\u0001-\u0001-\u0001-\u0001-\u0003-\u0502\b-\u0001"+
"-\u0003-\u0505\b-\u0001-\u0001-\u0001-\u0003-\u050a\b-\u0001-\u0003-\u050d"+
"\b-\u0001-\u0003-\u0510\b-\u0001-\u0003-\u0513\b-\u0001-\u0003-\u0516"+
"\b-\u0001-\u0001-\u0001-\u0001-\u0003-\u051c\b-\u0001.\u0001.\u0001.\u0001"+
".\u0003.\u0522\b.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+
"/\u0003/\u052c\b/\u00010\u00010\u00010\u00010\u00010\u00011\u00011\u0001"+
"1\u00011\u00011\u00031\u0538\b1\u00011\u00011\u00031\u053c\b1\u00012\u0001"+
"2\u00012\u00012\u00012\u00012\u00052\u0544\b2\n2\f2\u0547\t2\u00012\u0001"+
"2\u00012\u00012\u00012\u00012\u00052\u054f\b2\n2\f2\u0552\t2\u00032\u0554"+
"\b2\u00013\u00013\u00013\u00013\u00013\u00033\u055b\b3\u00013\u00013\u0001"+
"3\u00033\u0560\b3\u00013\u00053\u0563\b3\n3\f3\u0566\t3\u00013\u00033"+
"\u0569\b3\u00013\u00013\u00013\u00013\u00013\u00013\u00033\u0571\b3\u0001"+
"3\u00013\u00033\u0575\b3\u00013\u00053\u0578\b3\n3\f3\u057b\t3\u00013"+
"\u00033\u057e\b3\u00033\u0580\b3\u00014\u00044\u0583\b4\u000b4\f4\u0584"+
"\u00015\u00015\u00015\u00015\u00015\u00015\u00035\u058d\b5\u00015\u0001"+
"5\u00015\u00035\u0592\b5\u00016\u00016\u00036\u0596\b6\u00016\u00016\u0001"+
"6\u00016\u00016\u00016\u00036\u059e\b6\u00016\u00016\u00016\u00016\u0005"+
"6\u05a4\b6\n6\f6\u05a7\t6\u00036\u05a9\b6\u00016\u00036\u05ac\b6\u0001"+
"7\u00017\u00017\u00037\u05b1\b7\u00018\u00018\u00018\u00018\u00018\u0005"+
"8\u05b8\b8\n8\f8\u05bb\t8\u00018\u00038\u05be\b8\u00018\u00018\u00018"+
"\u00019\u00019\u00019\u00019\u00019\u00039\u05c8\b9\u0001:\u0001:\u0001"+
":\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001<\u0001"+
"<\u0001<\u0001=\u0001=\u0001=\u0003=\u05db\b=\u0001>\u0001>\u0003>\u05df"+
"\b>\u0001>\u0001>\u0003>\u05e3\b>\u0001?\u0001?\u0001?\u0001?\u0001@\u0001"+
"@\u0003@\u05eb\b@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001"+
"B\u0001B\u0001B\u0001C\u0001C\u0003C\u05f9\bC\u0001D\u0001D\u0001D\u0001"+
"D\u0001D\u0003D\u0600\bD\u0001D\u0001D\u0003D\u0604\bD\u0001E\u0001E\u0001"+
"E\u0001E\u0001E\u0003E\u060b\bE\u0003E\u060d\bE\u0001F\u0001F\u0003F\u0611"+
"\bF\u0001F\u0001F\u0003F\u0615\bF\u0001F\u0001F\u0001F\u0001F\u0005F\u061b"+
"\bF\nF\fF\u061e\tF\u0001F\u0003F\u0621\bF\u0001G\u0001G\u0001G\u0001H"+
"\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0003"+
"I\u0630\bI\u0001J\u0003J\u0633\bJ\u0001J\u0001J\u0003J\u0637\bJ\u0001"+
"K\u0001K\u0001L\u0001L\u0001L\u0003L\u063e\bL\u0001L\u0001L\u0001L\u0001"+
"L\u0001L\u0003L\u0645\bL\u0003L\u0647\bL\u0001M\u0001M\u0003M\u064b\b"+
"M\u0001N\u0001N\u0001N\u0001N\u0003N\u0651\bN\u0001O\u0003O\u0654\bO\u0001"+
"O\u0001O\u0001O\u0001O\u0001P\u0003P\u065b\bP\u0001P\u0001P\u0003P\u065f"+
"\bP\u0001P\u0003P\u0662\bP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001R\u0001"+
"R\u0001R\u0001R\u0003R\u066d\bR\u0001R\u0003R\u0670\bR\u0001R\u0001R\u0001"+
"R\u0001S\u0001S\u0001S\u0001T\u0001T\u0003T\u067a\bT\u0001T\u0001T\u0001"+
"T\u0005T\u067f\bT\nT\fT\u0682\tT\u0001T\u0003T\u0685\bT\u0001T\u0001T"+
"\u0003T\u0689\bT\u0001T\u0001T\u0001T\u0005T\u068e\bT\nT\fT\u0691\tT\u0001"+
"T\u0003T\u0694\bT\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0003U\u069c"+
"\bU\u0001V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0003"+
"W\u06a7\bW\u0001W\u0001W\u0003W\u06ab\bW\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001X\u0001X\u0001X\u0001X\u0003X\u06b6\bX\u0001X\u0001X\u0001X\u0001"+
"X\u0001X\u0003X\u06bd\bX\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001"+
"Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0003Y\u06cb\bY\u0001Z\u0001Z\u0001"+
"Z\u0001Z\u0005Z\u06d1\bZ\nZ\fZ\u06d4\tZ\u0001[\u0001[\u0003[\u06d8\b["+
"\u0001[\u0001[\u0001[\u0001[\u0001[\u0003[\u06df\b[\u0001[\u0001[\u0001"+
"[\u0001[\u0005[\u06e5\b[\n[\f[\u06e8\t[\u0001\\\u0001\\\u0001\\\u0003"+
"\\\u06ed\b\\\u0001]\u0001]\u0001]\u0003]\u06f2\b]\u0001]\u0001]\u0001"+
"]\u0001]\u0001]\u0001]\u0001]\u0001]\u0003]\u06fc\b]\u0001^\u0001^\u0001"+
"^\u0001^\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+
"`\u0003`\u070b\b`\u0001`\u0003`\u070e\b`\u0001a\u0001a\u0001a\u0001a\u0001"+
"a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001"+
"a\u0001a\u0001a\u0001a\u0003a\u0722\ba\u0001a\u0001a\u0001a\u0001a\u0001"+
"a\u0001a\u0001a\u0001a\u0005a\u072c\ba\na\fa\u072f\ta\u0001b\u0001b\u0001"+
"b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u0739\bb\u0001c\u0001c\u0001"+
"c\u0001c\u0001d\u0001d\u0001e\u0001e\u0001e\u0001e\u0001e\u0005e\u0746"+
"\be\ne\fe\u0749\te\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+
"f\u0001f\u0001f\u0003f\u0755\bf\u0001g\u0001g\u0003g\u0759\bg\u0001h\u0001"+
"h\u0001h\u0001h\u0001h\u0001h\u0001h\u0004h\u0762\bh\u000bh\fh\u0763\u0001"+
"h\u0001h\u0003h\u0768\bh\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001"+
"i\u0001i\u0004i\u0772\bi\u000bi\fi\u0773\u0001i\u0001i\u0003i\u0778\b"+
"i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001k\u0003"+
"k\u0783\bk\u0001k\u0001k\u0001k\u0003k\u0788\bk\u0001k\u0001k\u0001k\u0003"+
"k\u078d\bk\u0001k\u0001k\u0003k\u0791\bk\u0001k\u0001k\u0003k\u0795\b"+
"k\u0001k\u0001k\u0001k\u0003k\u079a\bk\u0001k\u0001k\u0003k\u079e\bk\u0001"+
"k\u0001k\u0003k\u07a2\bk\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+
"k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+
"k\u0001k\u0001k\u0001k\u0001k\u0003k\u07b9\bk\u0003k\u07bb\bk\u0001k\u0001"+
"k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+
"k\u0001k\u0001k\u0001k\u0001k\u0003k\u07cd\bk\u0003k\u07cf\bk\u0001k\u0001"+
"k\u0001k\u0001k\u0001k\u0001k\u0003k\u07d7\bk\u0001k\u0001k\u0001k\u0003"+
"k\u07dc\bk\u0001k\u0001k\u0001k\u0003k\u07e1\bk\u0001k\u0001k\u0001k\u0003"+
"k\u07e6\bk\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+
"k\u0001k\u0001k\u0003k\u07f3\bk\u0001k\u0001k\u0001k\u0003k\u07f8\bk\u0001"+
"k\u0001k\u0001k\u0003k\u07fd\bk\u0001k\u0001k\u0001k\u0003k\u0802\bk\u0001"+
"k\u0001k\u0001k\u0003k\u0807\bk\u0001k\u0001k\u0001k\u0003k\u080c\bk\u0001"+
"k\u0001k\u0001k\u0003k\u0811\bk\u0001k\u0001k\u0001k\u0003k\u0816\bk\u0003"+
"k\u0818\bk\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0003m\u0820\bm\u0001"+
"m\u0001m\u0001m\u0003m\u0825\bm\u0005m\u0827\bm\nm\fm\u082a\tm\u0001n"+
"\u0001n\u0001n\u0003n\u082f\bn\u0001n\u0003n\u0832\bn\u0001n\u0001n\u0001"+
"o\u0001o\u0001o\u0001o\u0001o\u0005o\u083b\bo\no\fo\u083e\to\u0001p\u0001"+
"p\u0001p\u0001p\u0001p\u0001p\u0001p\u0003p\u0847\bp\u0001p\u0001p\u0001"+
"p\u0001p\u0001p\u0001p\u0003p\u084f\bp\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0001p\u0001p\u0003p\u0858\bp\u0001p\u0001p\u0001p\u0001p\u0003p\u085e"+
"\bp\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0001p\u0001p\u0001p\u0005p\u086d\bp\np\fp\u0870\tp\u0003p\u0872\bp"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0001p\u0001p\u0005p\u0880\bp\np\fp\u0883\tp\u0003p\u0885\bp\u0001p"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0001p\u0005p\u0893\bp\np\fp\u0896\tp\u0003p\u0898\bp\u0001p\u0001p"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0005p\u08a6\bp\np\fp\u08a9\tp\u0003p\u08ab\bp\u0001p\u0001p\u0001p"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0005"+
"p\u08b9\bp\np\fp\u08bc\tp\u0003p\u08be\bp\u0001p\u0001p\u0001p\u0001p"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0005p\u08cc"+
"\bp\np\fp\u08cf\tp\u0003p\u08d1\bp\u0001p\u0001p\u0001p\u0001p\u0001p"+
"\u0001p\u0001p\u0001p\u0001p\u0001p\u0005p\u08dd\bp\np\fp\u08e0\tp\u0001"+
"p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0004"+
"p\u08ec\bp\u000bp\fp\u08ed\u0001p\u0001p\u0003p\u08f2\bp\u0001p\u0001"+
"p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+
"p\u0001p\u0001p\u0003p\u0902\bp\u0001p\u0001p\u0001p\u0001p\u0003p\u0908"+
"\bp\u0001q\u0001q\u0001q\u0003q\u090d\bq\u0001q\u0001q\u0001r\u0001r\u0003"+
"r\u0913\br\u0001s\u0001s\u0003s\u0917\bs\u0001s\u0001s\u0001s\u0001t\u0001"+
"t\u0003t\u091e\bt\u0001t\u0001t\u0001t\u0001u\u0001u\u0001u\u0005u\u0926"+
"\bu\nu\fu\u0929\tu\u0001v\u0001v\u0001v\u0001v\u0003v\u092f\bv\u0003v"+
"\u0931\bv\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001w\u0003w\u093a"+
"\bw\u0001x\u0005x\u093d\bx\nx\fx\u0940\tx\u0001y\u0001y\u0001y\u0001z"+
"\u0001z\u0001z\u0001z\u0003z\u0949\bz\u0001z\u0001z\u0001z\u0005z\u094e"+
"\bz\nz\fz\u0951\tz\u0003z\u0953\bz\u0001{\u0001{\u0001{\u0001|\u0001|"+
"\u0001|\u0001}\u0003}\u095c\b}\u0001}\u0001}\u0001}\u0003}\u0961\b}\u0001"+
"~\u0001~\u0001~\u0005~\u0966\b~\n~\f~\u0969\t~\u0001\u007f\u0001\u007f"+
"\u0001\u0080\u0003\u0080\u096e\b\u0080\u0001\u0080\u0001\u0080\u0001\u0081"+
"\u0003\u0081\u0973\b\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082"+
"\u0001\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0085\u0005\u0085"+
"\u097e\b\u0085\n\u0085\f\u0085\u0981\t\u0085\u0001\u0085\u0003\u0085\u0984"+
"\b\u0085\u0001\u0085\u0004\u0085\u0987\b\u0085\u000b\u0085\f\u0085\u0988"+
"\u0001\u0085\u0005\u0085\u098c\b\u0085\n\u0085\f\u0085\u098f\t\u0085\u0001"+
"\u0085\u0005\u0085\u0992\b\u0085\n\u0085\f\u0085\u0995\t\u0085\u0001\u0085"+
"\u0001\u0085\u0001\u0086\u0005\u0086\u099a\b\u0086\n\u0086\f\u0086\u099d"+
"\t\u0086\u0001\u0086\u0003\u0086\u09a0\b\u0086\u0001\u0086\u0005\u0086"+
"\u09a3\b\u0086\n\u0086\f\u0086\u09a6\t\u0086\u0001\u0086\u0001\u0086\u0001"+
"\u0087\u0001\u0087\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001"+
"\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0005\u0088\u09b4\b\u0088\n"+
"\u0088\f\u0088\u09b7\t\u0088\u0003\u0088\u09b9\b\u0088\u0001\u0088\u0001"+
"\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u09c1"+
"\b\u0088\u0001\u0088\u0003\u0088\u09c4\b\u0088\u0001\u0088\u0001\u0088"+
"\u0001\u0088\u0001\u0088\u0005\u0088\u09ca\b\u0088\n\u0088\f\u0088\u09cd"+
"\t\u0088\u0001\u0088\u0001\u0088\u0005\u0088\u09d1\b\u0088\n\u0088\f\u0088"+
"\u09d4\t\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088"+
"\u09da\b\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088"+
"\u0001\u0088\u0001\u0088\u0003\u0088\u09e3\b\u0088\u0001\u0088\u0001\u0088"+
"\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u09ea\b\u0088\u0001\u0088"+
"\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u09f1\b\u0088"+
"\u0001\u0088\u0001\u0088\u0003\u0088\u09f5\b\u0088\u0003\u0088\u09f7\b"+
"\u0088\u0001\u0089\u0003\u0089\u09fa\b\u0089\u0001\u0089\u0001\u0089\u0003"+
"\u0089\u09fe\b\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001"+
"\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0003"+
"\u0089\u0a0a\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+
"\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+
"\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+
"\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u0a20\b\u008a\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003"+
"\u008b\u0a28\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0003\u008b\u0a2f\b\u008b\u0001\u008b\u0003\u008b\u0a32\b\u008b"+
"\u0001\u008b\u0001\u008b\u0003\u008b\u0a36\b\u008b\u0001\u008b\u0003\u008b"+
"\u0a39\b\u008b\u0003\u008b\u0a3b\b\u008b\u0001\u008b\u0003\u008b\u0a3e"+
"\b\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0a42\b\u008b\u0001\u008b"+
"\u0001\u008b\u0003\u008b\u0a46\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+
"\u0001\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0a4e\b\u008b\u0001\u008b"+
"\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0a55\b\u008b"+
"\u0001\u008b\u0001\u008b\u0003\u008b\u0a59\b\u008b\u0003\u008b\u0a5b\b"+
"\u008b\u0001\u008b\u0003\u008b\u0a5e\b\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0003\u008b\u0a6a\b\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0a78\b\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003"+
"\u008b\u0a80\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0003\u008b\u0a87\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0003\u008b\u0a8e\b\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0003\u008b\u0a93\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+
"\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0aad\b\u008b\u0001\u008c\u0001"+
"\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001"+
"\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0aba\b\u008c\u0003"+
"\u008c\u0abc\b\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0ac0\b\u008c"+
"\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0ac5\b\u008c\u0003\u008c"+
"\u0ac7\b\u008c\u0001\u008c\u0003\u008c\u0aca\b\u008c\u0001\u008c\u0001"+
"\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+
"\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+
"\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+
"\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0ae2\b\u008d\u0001\u008e\u0001"+
"\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008f\u0003"+
"\u008f\u0aeb\b\u008f\u0001\u008f\u0003\u008f\u0aee\b\u008f\u0001\u008f"+
"\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0af4\b\u008f\u0001\u008f"+
"\u0001\u008f\u0003\u008f\u0af8\b\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+
"\u0001\u008f\u0003\u008f\u0afe\b\u008f\u0001\u008f\u0003\u008f\u0b01\b"+
"\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0b06\b\u008f\u0001"+
"\u008f\u0003\u008f\u0b09\b\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+
"\u008f\u0003\u008f\u0b0f\b\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0b13"+
"\b\u008f\u0001\u008f\u0003\u008f\u0b16\b\u008f\u0001\u008f\u0001\u008f"+
"\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0b1e\b\u008f"+
"\u0001\u008f\u0003\u008f\u0b21\b\u008f\u0001\u008f\u0003\u008f\u0b24\b"+
"\u008f\u0001\u008f\u0003\u008f\u0b27\b\u008f\u0001\u008f\u0001\u008f\u0001"+
"\u008f\u0001\u008f\u0003\u008f\u0b2d\b\u008f\u0001\u008f\u0001\u008f\u0001"+
"\u008f\u0003\u008f\u0b32\b\u008f\u0001\u008f\u0003\u008f\u0b35\b\u008f"+
"\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+
"\u0001\u008f\u0005\u008f\u0b3e\b\u008f\n\u008f\f\u008f\u0b41\t\u008f\u0001"+
"\u008f\u0001\u008f\u0003\u008f\u0b45\b\u008f\u0001\u008f\u0003\u008f\u0b48"+
"\b\u008f\u0001\u008f\u0003\u008f\u0b4b\b\u008f\u0001\u008f\u0001\u008f"+
"\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0b52\b\u008f\u0001\u008f"+
"\u0003\u008f\u0b55\b\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f"+
"\u0b5a\b\u008f\u0001\u008f\u0003\u008f\u0b5d\b\u008f\u0001\u008f\u0003"+
"\u008f\u0b60\b\u008f\u0001\u0090\u0001\u0090\u0003\u0090\u0b64\b\u0090"+
"\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b6a\b\u0090"+
"\u0001\u0090\u0001\u0090\u0003\u0090\u0b6e\b\u0090\u0001\u0090\u0001\u0090"+
"\u0001\u0090\u0001\u0090\u0003\u0090\u0b74\b\u0090\u0001\u0090\u0003\u0090"+
"\u0b77\b\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b7b\b\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b80\b\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b88"+
"\b\u0090\u0003\u0090\u0b8a\b\u0090\u0001\u0090\u0001\u0090\u0003\u0090"+
"\u0b8e\b\u0090\u0001\u0090\u0003\u0090\u0b91\b\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b98\b\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0b9d\b\u0090\u0003\u0090\u0b9f"+
"\b\u0090\u0003\u0090\u0ba1\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090"+
"\u0001\u0090\u0001\u0090\u0003\u0090\u0ba8\b\u0090\u0001\u0090\u0003\u0090"+
"\u0bab\b\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0baf\b\u0090\u0001"+
"\u0090\u0001\u0090\u0003\u0090\u0bb3\b\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0bb8\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0bbe\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0003\u0090\u0bc5\b\u0090\u0001\u0090\u0001\u0090\u0003"+
"\u0090\u0bc9\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0bd0\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0bd6\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0bde\b\u0090\u0003\u0090\u0be0"+
"\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0be8\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003"+
"\u0090\u0bf3\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0003\u0090\u0c01\b\u0090\u0001\u0090\u0001\u0090\u0003"+
"\u0090\u0c05\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0c0e\b\u0090\u0001\u0090\u0001"+
"\u0090\u0003\u0090\u0c12\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+
"\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0c1b\b\u0090\u0001"+
"\u0090\u0001\u0090\u0003\u0090\u0c1f\b\u0090\u0003\u0090\u0c21\b\u0090"+
"\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091"+
"\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0c2c\b\u0091\u0001\u0091"+
"\u0003\u0091\u0c2f\b\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0c33\b"+
"\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001"+
"\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001"+
"\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0c43\b\u0091\u0001\u0092\u0001"+
"\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+
"\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u0c51"+
"\b\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+
"\u0092\u0001\u0092\u0003\u0092\u0c5a\b\u0092\u0001\u0092\u0001\u0092\u0001"+
"\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u0c63"+
"\b\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+
"\u0092\u0001\u0092\u0003\u0092\u0c6c\b\u0092\u0001\u0092\u0003\u0092\u0c6f"+
"\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+
"\u0093\u0003\u0093\u0c77\b\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+
"\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+
"\u0093\u0001\u0093\u0001\u0093\u0003\u0093\u0c85\b\u0093\u0001\u0094\u0001"+
"\u0094\u0003\u0094\u0c89\b\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001"+
"\u0094\u0003\u0094\u0c8f\b\u0094\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+
"\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0003\u0095\u0c98\b\u0095\u0001"+
"\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+
"\u0095\u0001\u0095\u0005\u0095\u0ca2\b\u0095\n\u0095\f\u0095\u0ca5\t\u0095"+
"\u0003\u0095\u0ca7\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0003\u0095\u0cb0\b\u0095\u0001\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0003\u0095\u0cb7\b\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0005\u0095\u0cbd\b\u0095"+
"\n\u0095\f\u0095\u0cc0\t\u0095\u0003\u0095\u0cc2\b\u0095\u0001\u0095\u0003"+
"\u0095\u0cc5\b\u0095\u0001\u0095\u0003\u0095\u0cc8\b\u0095\u0001\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0005\u0095\u0cd4\b\u0095\n\u0095"+
"\f\u0095\u0cd7\t\u0095\u0001\u0095\u0001\u0095\u0003\u0095\u0cdb\b\u0095"+
"\u0001\u0095\u0003\u0095\u0cde\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+
"\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+
"\u0001\u0095\u0005\u0095\u0cea\b\u0095\n\u0095\f\u0095\u0ced\t\u0095\u0001"+
"\u0095\u0001\u0095\u0003\u0095\u0cf1\b\u0095\u0001\u0095\u0003\u0095\u0cf4"+
"\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0003"+
"\u0095\u0cfb\b\u0095\u0003\u0095\u0cfd\b\u0095\u0001\u0096\u0001\u0096"+
"\u0001\u0096\u0001\u0096\u0003\u0096\u0d03\b\u0096\u0001\u0097\u0001\u0097"+
"\u0001\u0097\u0003\u0097\u0d08\b\u0097\u0001\u0097\u0001\u0097\u0003\u0097"+
"\u0d0c\b\u0097\u0001\u0097\u0003\u0097\u0d0f\b\u0097\u0001\u0097\u0003"+
"\u0097\u0d12\b\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0d18\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d21\b\u0098\u0003\u0098\u0d23"+
"\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0d2b\b\u0098\u0003\u0098\u0d2d\b\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0d3d\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0d41\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0003\u0098\u0d48\b\u0098\u0001\u0098\u0003\u0098\u0d4b\b\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d52"+
"\b\u0098\u0001\u0098\u0003\u0098\u0d55\b\u0098\u0001\u0098\u0001\u0098"+
"\u0003\u0098\u0d59\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0d5e\b\u0098\u0001\u0098\u0003\u0098\u0d61\b\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0d65\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0d6a\b\u0098\u0001\u0098\u0003\u0098\u0d6d\b\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d74\b\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d79\b\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0d7d\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0d81\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d86\b"+
"\u0098\u0001\u0098\u0003\u0098\u0d89\b\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0003\u0098\u0d8f\b\u0098\u0001\u0098\u0003\u0098\u0d92"+
"\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d98"+
"\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0d9f\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0db8\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0dbe\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0dc3\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0dc9\b\u0098\u0001\u0098\u0003\u0098\u0dcc\b\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0003\u0098\u0dd7\b\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0de2\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0de6\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0003\u0098\u0ded\b\u0098\u0001\u0098\u0003\u0098\u0df0\b\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0df5\b\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0dfb\b\u0098\u0001\u0098\u0003"+
"\u0098\u0dfe\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0003\u0098\u0e0c\b\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0e13\b\u0098\u0001\u0098\u0003"+
"\u0098\u0e16\b\u0098\u0001\u0098\u0003\u0098\u0e19\b\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0e1d\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0e21\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0e26\b"+
"\u0098\u0001\u0098\u0003\u0098\u0e29\b\u0098\u0001\u0098\u0003\u0098\u0e2c"+
"\b\u0098\u0001\u0098\u0003\u0098\u0e2f\b\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0003\u0098\u0e35\b\u0098\u0001\u0098\u0003\u0098"+
"\u0e38\b\u0098\u0001\u0098\u0003\u0098\u0e3b\b\u0098\u0001\u0098\u0003"+
"\u0098\u0e3e\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0e44\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0e4d\b\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0e51\b\u0098\u0001\u0098\u0003\u0098\u0e54\b\u0098"+
"\u0001\u0098\u0003\u0098\u0e57\b\u0098\u0001\u0098\u0003\u0098\u0e5a\b"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0e64\b\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0e68\b\u0098\u0001\u0098\u0003\u0098\u0e6b\b\u0098"+
"\u0001\u0098\u0003\u0098\u0e6e\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0e72\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0e78\b\u0098\u0001\u0098\u0003\u0098\u0e7b\b\u0098\u0001\u0098\u0003"+
"\u0098\u0e7e\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0005\u0098\u0e8c\b\u0098\n\u0098\f\u0098\u0e8f\t\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0e96\b\u0098\u0001\u0098\u0003\u0098\u0e99\b\u0098\u0001\u0098\u0003"+
"\u0098\u0e9c\b\u0098\u0001\u0098\u0003\u0098\u0e9f\b\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0ea5\b\u0098\u0001\u0098"+
"\u0003\u0098\u0ea8\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0003\u0098\u0eae\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0003\u0098\u0eb4\b\u0098\u0001\u0098\u0003\u0098\u0eb7\b\u0098\u0001"+
"\u0098\u0001\u0098\u0003\u0098\u0ebb\b\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0ec0\b\u0098\u0001\u0098\u0003\u0098\u0ec3\b\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0eca\b\u0098\u0001\u0098\u0003\u0098\u0ecd\b\u0098\u0001\u0098\u0003"+
"\u0098\u0ed0\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0ed6\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0003\u0098\u0ede\b\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0ee3\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0eec\b\u0098\u0001"+
"\u0098\u0001\u0098\u0003\u0098\u0ef0\b\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0efd\b\u0098\u0001\u0098\u0003"+
"\u0098\u0f00\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f05"+
"\b\u0098\u0001\u0098\u0003\u0098\u0f08\b\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0f0d\b\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0f11\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0f17\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098"+
"\u0f1d\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0f25\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0f2b\b\u0098\u0001\u0098\u0003\u0098\u0f2e\b"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f34"+
"\b\u0098\u0001\u0098\u0003\u0098\u0f37\b\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0003\u0098\u0f3d\b\u0098\u0001\u0098\u0003\u0098"+
"\u0f40\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f4a\b\u0098\u0001\u0098"+
"\u0003\u0098\u0f4d\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0003\u0098\u0f54\b\u0098\u0001\u0098\u0003\u0098\u0f57\b"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f69"+
"\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f74\b\u0098\u0003"+
"\u0098\u0f76\b\u0098\u0003\u0098\u0f78\b\u0098\u0001\u0098\u0001\u0098"+
"\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f7f\b\u0098\u0001\u0098"+
"\u0003\u0098\u0f82\b\u0098\u0001\u0098\u0003\u0098\u0f85\b\u0098\u0001"+
"\u0098\u0003\u0098\u0f88\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0f8e\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0f94\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0f9c\b\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0fa8\b\u0098\u0001\u0098\u0001"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+
"\u0098\u0003\u0098\u0fb2\b\u0098\u0001\u0098\u0003\u0098\u0fb5\b\u0098"+
"\u0001\u0098\u0003\u0098\u0fb8\b\u0098\u0001\u0098\u0003\u0098\u0fbb\b"+
"\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003"+
"\u0098\u0fc2\b\u0098\u0003\u0098\u0fc4\b\u0098\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099"+
"\u0fcd\b\u0099\u0001\u0099\u0003\u0099\u0fd0\b\u0099\u0001\u0099\u0001"+
"\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0fd8"+
"\b\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0fdc\b\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0005\u0099\u0fe1\b\u0099\n\u0099\f\u0099\u0fe4"+
"\t\u0099\u0003\u0099\u0fe6\b\u0099\u0001\u0099\u0003\u0099\u0fe9\b\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0003\u0099\u0ff1\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u100c\b\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u1013\b\u0099"+
"\u0003\u0099\u1015\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+
"\u0001\u0099\u0001\u0099\u0003\u0099\u101d\b\u0099\u0001\u0099\u0003\u0099"+
"\u1020\b\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u1024\b\u0099\u0001"+
"\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001"+
"\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001"+
"\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u1036\b\u0099\u0001"+
"\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001"+
"\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u1042\b\u009a\u0001"+
"\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0001"+
"\u009c\u0001\u009c\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001"+
"\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+
"\u009f\u0001\u009f\u0005\u009f\u1058\b\u009f\n\u009f\f\u009f\u105b\t\u009f"+
"\u0001\u009f\u0001\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0"+
"\u1062\b\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0"+
"\u1068\b\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0\u106c\b\u00a0\u0001"+
"\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+
"\u00a1\u0003\u00a1\u1075\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+
"\u00a1\u0003\u00a1\u107b\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+
"\u00a1\u0001\u00a1\u0003\u00a1\u1082\b\u00a1\u0003\u00a1\u1084\b\u00a1"+
"\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2\u1089\b\u00a2\u0001\u00a2"+
"\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2"+
"\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2"+
"\u1097\b\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2"+
"\u109d\b\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0003\u00a3\u10a2\b"+
"\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0003\u00a3\u10a8"+
"\b\u00a3\u0001\u00a3\u0003\u00a3\u10ab\b\u00a3\u0001\u00a3\u0001\u00a3"+
"\u0001\u00a3\u0003\u00a3\u10b0\b\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3"+
"\u0003\u00a3\u10b5\b\u00a3\u0003\u00a3\u10b7\b\u00a3\u0001\u00a4\u0001"+
"\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4\u10bd\b\u00a4\u0001\u00a4\u0003"+
"\u00a4\u10c0\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003"+
"\u00a4\u10c6\b\u00a4\u0001\u00a4\u0003\u00a4\u10c9\b\u00a4\u0001\u00a4"+
"\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+
"\u0003\u00a4\u10d2\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+
"\u0001\u00a4\u0001\u00a4\u0005\u00a4\u10da\b\u00a4\n\u00a4\f\u00a4\u10dd"+
"\t\u00a4\u0001\u00a4\u0003\u00a4\u10e0\b\u00a4\u0001\u00a4\u0001\u00a4"+
"\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+
"\u0001\u00a4\u0005\u00a4\u10eb\b\u00a4\n\u00a4\f\u00a4\u10ee\t\u00a4\u0001"+
"\u00a4\u0003\u00a4\u10f1\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+
"\u00a4\u0001\u00a4\u0001\u00a4\u0005\u00a4\u10f9\b\u00a4\n\u00a4\f\u00a4"+
"\u10fc\t\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4"+
"\u1102\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4"+
"\u1108\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+
"\u0003\u00a4\u110f\b\u00a4\u0003\u00a4\u1111\b\u00a4\u0001\u00a5\u0001"+
"\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u1117\b\u00a5\u0001\u00a5\u0001"+
"\u00a5\u0003\u00a5\u111b\b\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001"+
"\u00a5\u0003\u00a5\u1121\b\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u1125"+
"\b\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u112b"+
"\b\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u112f\b\u00a5\u0001\u00a5"+
"\u0001\u00a5\u0001\u00a5\u0003\u00a5\u1134\b\u00a5\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6"+
"\u113d\b\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u1165\b\u00a6\u0001\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u116c\b\u00a6"+
"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6"+
"\u1173\b\u00a6\u0001\u00a6\u0003\u00a6\u1176\b\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u117c\b\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u1188\b\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u1195\b\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u11a1\b\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0003\u00a6\u11aa\b\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0003\u00a6\u11b6\b\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0003\u00a6\u11bd\b\u00a6\u0001\u00a6\u0001\u00a6\u0001"+
"\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u11c5\b\u00a6\u0003"+
"\u00a6\u11c7\b\u00a6\u0001\u00a7\u0001\u00a7\u0003\u00a7\u11cb\b\u00a7"+
"\u0001\u00a7\u0003\u00a7\u11ce\b\u00a7\u0001\u00a7\u0003\u00a7\u11d1\b"+
"\u00a7\u0001\u00a7\u0003\u00a7\u11d4\b\u00a7\u0001\u00a7\u0001\u00a7\u0003"+
"\u00a7\u11d8\b\u00a7\u0001\u00a7\u0003\u00a7\u11db\b\u00a7\u0001\u00a8"+
"\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u11e1\b\u00a8\u0001\u00a9"+
"\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u11e7\b\u00a9\u0003\u00a9"+
"\u11e9\b\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u11ed\b\u00a9\u0001"+
"\u00a9\u0001\u00a9\u0003\u00a9\u11f1\b\u00a9\u0001\u00a9\u0003\u00a9\u11f4"+
"\b\u00a9\u0001\u00a9\u0003\u00a9\u11f7\b\u00a9\u0001\u00a9\u0003\u00a9"+
"\u11fa\b\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u11fe\b\u00a9\u0001"+
"\u00a9\u0001\u00a9\u0003\u00a9\u1202\b\u00a9\u0001\u00a9\u0003\u00a9\u1205"+
"\b\u00a9\u0001\u00a9\u0003\u00a9\u1208\b\u00a9\u0001\u00a9\u0003\u00a9"+
"\u120b\b\u00a9\u0003\u00a9\u120d\b\u00a9\u0001\u00aa\u0001\u00aa\u0001"+
"\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0003"+
"\u00aa\u1217\b\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+
"\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+
"\u00aa\u0001\u00aa\u0003\u00aa\u1225\b\u00aa\u0001\u00aa\u0001\u00aa\u0001"+
"\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa\u122c\b\u00aa\u0001\u00aa\u0001"+
"\u00aa\u0001\u00aa\u0001\u00aa\u0005\u00aa\u1232\b\u00aa\n\u00aa\f\u00aa"+
"\u1235\t\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+
"\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa"+
"\u1241\b\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+
"\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+
"\u0001\u00aa\u0003\u00aa\u124f\b\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+
"\u0001\u00aa\u0001\u00aa\u0003\u00aa\u1256\b\u00aa\u0001\u00aa\u0001\u00aa"+
"\u0001\u00aa\u0001\u00aa\u0005\u00aa\u125c\b\u00aa\n\u00aa\f\u00aa\u125f"+
"\t\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa\u1263\b\u00aa\u0001\u00ab"+
"\u0001\u00ab\u0003\u00ab\u1267\b\u00ab\u0001\u00ab\u0003\u00ab\u126a\b"+
"\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0005\u00ac\u126f\b\u00ac\n"+
"\u00ac\f\u00ac\u1272\t\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0005\u00ad\u127a\b\u00ad\n\u00ad\f\u00ad"+
"\u127d\t\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad"+
"\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0005\u00ad\u1287\b\u00ad\n\u00ad"+
"\f\u00ad\u128a\t\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad"+
"\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0005\u00ad\u1294\b\u00ad"+
"\n\u00ad\f\u00ad\u1297\t\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0003\u00ad\u12a4\b\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u12cf\b\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0003\u00ad\u12df\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0003\u00ad\u12e6\b\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u12ee\b\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003"+
"\u00ad\u12f6\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003"+
"\u00ad\u12fc\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0003\u00ad\u1310\b\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0003\u00ad\u1316\b\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+
"\u00ad\u0003\u00ad\u1321\b\u00ad\u0003\u00ad\u1323\b\u00ad\u0001\u00ae"+
"\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0005\u00ae\u132a\b\u00ae"+
"\n\u00ae\f\u00ae\u132d\t\u00ae\u0001\u00ae\u0003\u00ae\u1330\b\u00ae\u0001"+
"\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0005\u00ae\u1337"+
"\b\u00ae\n\u00ae\f\u00ae\u133a\t\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae"+
"\u0001\u00ae\u0001\u00ae\u0005\u00ae\u1341\b\u00ae\n\u00ae\f\u00ae\u1344"+
"\t\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0005\u00ae\u1358\b\u00ae\n\u00ae\f\u00ae\u135b\t\u00ae\u0001\u00ae"+
"\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0005\u00ae"+
"\u1363\b\u00ae\n\u00ae\f\u00ae\u1366\t\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0003\u00ae\u1371\b\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+
"\u00ae\u0001\u00ae\u0005\u00ae\u1378\b\u00ae\n\u00ae\f\u00ae\u137b\t\u00ae"+
"\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae"+
"\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0003\u00ae\u1387\b\u00ae"+
"\u0001\u00af\u0001\u00af\u0003\u00af\u138b\b\u00af\u0001\u00b0\u0001\u00b0"+
"\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u1392\b\u00b0\u0001\u00b0"+
"\u0003\u00b0\u1395\b\u00b0\u0001\u00b0\u0003\u00b0\u1398\b\u00b0\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u139e\b\u00b1\u0001"+
"\u00b1\u0003\u00b1\u13a1\b\u00b1\u0001\u00b1\u0003\u00b1\u13a4\b\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0005\u00b1\u13ac\b\u00b1\n\u00b1\f\u00b1\u13af\t\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0003\u00b1\u13b3\b\u00b1\u0001\u00b1\u0003\u00b1\u13b6\b\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13bc\b\u00b1"+
"\u0001\u00b1\u0003\u00b1\u13bf\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0003\u00b1\u13c5\b\u00b1\u0001\u00b1\u0003\u00b1\u13c8\b"+
"\u00b1\u0001\u00b1\u0003\u00b1\u13cb\b\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0003\u00b1\u13d1\b\u00b1\u0001\u00b1\u0003\u00b1\u13d4"+
"\b\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13d8\b\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13dd\b\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13e3\b\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13ea\b\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13ef\b\u00b1\u0003\u00b1\u13f1\b"+
"\u00b1\u0003\u00b1\u13f3\b\u00b1\u0001\u00b1\u0003\u00b1\u13f6\b\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0003\u00b1\u13fa\b\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0003\u00b1\u13ff\b\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1"+
"\u1403\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1408\b"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u140c\b\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0003\u00b1\u1411\b\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1418\b\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003"+
"\u00b1\u1421\b\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1425\b\u00b1"+
"\u0001\u00b1\u0003\u00b1\u1428\b\u00b1\u0001\u00b1\u0003\u00b1\u142b\b"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003"+
"\u00b1\u1432\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0003\u00b1\u144b\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1453\b\u00b1\u0001\u00b1\u0001"+
"\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003"+
"\u00b1\u145c\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1461"+
"\b\u00b1\u0003\u00b1\u1463\b\u00b1\u0003\u00b1\u1465\b\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0003\u00b1\u1475\b\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1"+
"\u1479\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u1483\b\u00b1\u0001\u00b1"+
"\u0003\u00b1\u1486\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+
"\u0003\u00b1\u148c\b\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2"+
"\u0001\u00b2\u0003\u00b2\u1493\b\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2"+
"\u0001\u00b2\u0001\u00b2\u0003\u00b2\u149a\b\u00b2\u0001\u00b2\u0001\u00b2"+
"\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0003\u00b2\u14a1\b\u00b2\u0001\u00b3"+
"\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0003\u00b3\u14a8\b\u00b3"+
"\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0003\u00b3"+
"\u14af\b\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+
"\u0003\u00b3\u14b6\b\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4"+
"\u0003\u00b4\u14bc\b\u00b4\u0001\u00b4\u0003\u00b4\u14bf\b\u00b4\u0001"+
"\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003\u00b5\u14c5\b\u00b5\u0001"+
"\u00b5\u0003\u00b5\u14c8\b\u00b5\u0001\u00b5\u0003\u00b5\u14cb\b\u00b5"+
"\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001\u00b7\u0001\u00b7"+
"\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+
"\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0003\u00b7"+
"\u14de\b\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9"+
"\u0001\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba"+
"\u14ea\b\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bb"+
"\u0001\u00bb\u0003\u00bb\u14f2\b\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bc"+
"\u0001\u00bc\u0001\u00bc\u0003\u00bc\u14f9\b\u00bc\u0001\u00bd\u0001\u00bd"+
"\u0001\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1505\b\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0003\u00bf\u1509\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0003\u00bf\u150f\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf"+
"\u1514\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1519\b"+
"\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u151e\b\u00bf\u0001"+
"\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003"+
"\u00bf\u1526\b\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u152a\b\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1530\b\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf"+
"\u1537\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1542\b\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf"+
"\u1549\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1553\b\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf"+
"\u155b\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0003\u00bf\u1563\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0003\u00bf\u156a\b\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1571\b\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf"+
"\u1579\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
"\u0001\u00bf\u0001\u00bf\u0003\u00bf\u1582\b\u00bf\u0003\u00bf\u1584\b"+
"\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003"+
"\u00bf\u158b\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001"+
"\u00bf\u0003\u00bf\u1592\b\u00bf\u0001\u00bf\u0003\u00bf\u1595\b\u00bf"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u159b\b\u00c0"+
"\u0001\u00c0\u0003\u00c0\u159e\b\u00c0\u0001\u00c0\u0001\u00c0\u0005\u00c0"+
"\u15a2\b\u00c0\n\u00c0\f\u00c0\u15a5\t\u00c0\u0001\u00c0\u0003\u00c0\u15a8"+
"\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0005"+
"\u00c0\u15af\b\u00c0\n\u00c0\f\u00c0\u15b2\t\u00c0\u0001\u00c0\u0003\u00c0"+
"\u15b5\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u15c0\b\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0"+
"\u15c7\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u15d2\b\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u15d8\b\u00c0"+
"\u0001\u00c0\u0003\u00c0\u15db\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u15f0\b\u00c0"+
"\u0001\u00c0\u0003\u00c0\u15f3\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u1602\b\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u1607\b\u00c0\u0001\u00c0"+
"\u0003\u00c0\u160a\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u1614\b\u00c0"+
"\u0001\u00c0\u0001\u00c0\u0003\u00c0\u1618\b\u00c0\u0001\u00c0\u0003\u00c0"+
"\u161b\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0"+
"\u1621\b\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0"+
"\u1627\b\u00c0\u0001\u00c0\u0003\u00c0\u162a\b\u00c0\u0001\u00c0\u0001"+
"\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u1631\b\u00c0\u0001"+
"\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001"+
"\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0003\u00c1\u163d\b\u00c1\u0001"+
"\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0003"+
"\u00c1\u1645\b\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0003\u00c2\u164c\b\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1650"+
"\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u1657\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u165d\b\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1661\b\u00c2"+
"\u0001\u00c2\u0003\u00c2\u1664\b\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2"+
"\u1668\b\u00c2\u0001\u00c2\u0003\u00c2\u166b\b\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1671\b\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u1676\b\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u167d\b\u00c2\u0001\u00c2\u0003"+
"\u00c2\u1680\b\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1684\b\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2"+
"\u168b\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1690\b"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u1697\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16a2"+
"\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u16a9\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16ae"+
"\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16b3\b\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16bf\b\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16c4\b\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16cb\b\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0003\u00c2\u16d3\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16db\b\u00c2\u0001\u00c2\u0003\u00c2"+
"\u16de\b\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u16e2\b\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u16e6\b\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u16ec\b\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u16f0\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u16f8\b\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u16fc\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u1704\b\u00c2\u0001\u00c2\u0001\u00c2\u0003"+
"\u00c2\u1708\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0003\u00c2\u1710\b\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1718\b\u00c2\u0001"+
"\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u171f"+
"\b\u00c2\u0001\u00c2\u0003\u00c2\u1722\b\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1729\b\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1734\b\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0003\u00c2\u1738\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1740\b\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0003\u00c2\u1744\b\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0003\u00c2\u174c\b\u00c2\u0001\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2\u1753\b\u00c2\u0001\u00c2"+
"\u0001\u00c2\u0003\u00c2\u1757\b\u00c2\u0003\u00c2\u1759\b\u00c2\u0001"+
"\u00c3\u0001\u00c3\u0001\u00c3\u0005\u00c3\u175e\b\u00c3\n\u00c3\f\u00c3"+
"\u1761\t\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0003\u00c4"+
"\u1767\b\u00c4\u0003\u00c4\u1769\b\u00c4\u0001\u00c5\u0001\u00c5\u0001"+
"\u00c5\u0005\u00c5\u176e\b\u00c5\n\u00c5\f\u00c5\u1771\t\u00c5\u0001\u00c6"+
"\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0003\u00c6\u1777\b\u00c6\u0001\u00c7"+
"\u0001\u00c7\u0003\u00c7\u177b\b\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7"+
"\u0001\u00c7\u0003\u00c7\u1781\b\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8"+
"\u0003\u00c8\u1786\b\u00c8\u0003\u00c8\u1788\b\u00c8\u0001\u00c8\u0001"+
"\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0003\u00c8\u1790"+
"\b\u00c8\u0003\u00c8\u1792\b\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8"+
"\u0001\u00c8\u0001\u00c8\u0003\u00c8\u1799\b\u00c8\u0003\u00c8\u179b\b"+
"\u00c8\u0001\u00c8\u0001\u00c8\u0003\u00c8\u179f\b\u00c8\u0001\u00c8\u0001"+
"\u00c8\u0001\u00c8\u0001\u00c8\u0003\u00c8\u17a5\b\u00c8\u0003\u00c8\u17a7"+
"\b\u00c8\u0001\u00c8\u0003\u00c8\u17aa\b\u00c8\u0001\u00c9\u0001\u00c9"+
"\u0001\u00c9\u0005\u00c9\u17af\b\u00c9\n\u00c9\f\u00c9\u17b2\t\u00c9\u0001"+
"\u00ca\u0001\u00ca\u0003\u00ca\u17b6\b\u00ca\u0001\u00cb\u0001\u00cb\u0001"+
"\u00cb\u0003\u00cb\u17bb\b\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0003"+
"\u00cb\u17c0\b\u00cb\u0005\u00cb\u17c2\b\u00cb\n\u00cb\f\u00cb\u17c5\t"+
"\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001"+
"\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0003"+
"\u00cb\u17d2\b\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0003\u00cb\u17d7"+
"\b\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001"+
"\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0003"+
"\u00cb\u17e4\b\u00cb\u0003\u00cb\u17e6\b\u00cb\u0001\u00cc\u0001\u00cc"+
"\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0003\u00cc\u17ed\b\u00cc\u0001\u00cd"+
"\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd"+
"\u17f5\b\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd\u17f9\b\u00cd\u0001"+
"\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd\u17fe\b\u00cd\u0001\u00cd\u0001"+
"\u00cd\u0001\u00cd\u0003\u00cd\u1803\b\u00cd\u0001\u00cd\u0001\u00cd\u0001"+
"\u00cd\u0003\u00cd\u1808\b\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001"+
"\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd\u1810\b\u00cd\u0001\u00cd\u0001"+
"\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0003"+
"\u00cd\u1819\b\u00cd\u0001\u00cd\u0003\u00cd\u181c\b\u00cd\u0001\u00ce"+
"\u0001\u00ce\u0001\u00ce\u0003\u00ce\u1821\b\u00ce\u0003\u00ce\u1823\b"+
"\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003\u00ce\u1829"+
"\b\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003"+
"\u00ce\u1830\b\u00ce\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001"+
"\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001"+
"\u00d0\u0001\u00d0\u0003\u00d0\u183e\b\u00d0\u0001\u00d1\u0001\u00d1\u0003"+
"\u00d1\u1842\b\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0003\u00d1\u1847"+
"\b\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0003\u00d1\u184d"+
"\b\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0003\u00d2\u1853"+
"\b\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0003"+
"\u00d2\u185a\b\u00d2\u0001\u00d2\u0003\u00d2\u185d\b\u00d2\u0001\u00d2"+
"\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0003\u00d2\u1863\b\u00d2\u0001\u00d3"+
"\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u1869\b\u00d3\u0001\u00d3"+
"\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u186f\b\u00d3\u0001\u00d3"+
"\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3"+
"\u0001\u00d3\u0003\u00d3\u1879\b\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3"+
"\u187d\b\u00d3\u0001\u00d3\u0003\u00d3\u1880\b\u00d3\u0003\u00d3\u1882"+
"\b\u00d3\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003\u00d4\u1887\b\u00d4"+
"\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003\u00d4\u188c\b\u00d4\u0001\u00d5"+
"\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u1893\b\u00d5"+
"\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5"+
"\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u189f\b\u00d5"+
"\u0003\u00d5\u18a1\b\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6"+
"\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6"+
"\u0001\u00d6\u0001\u00d6\u0003\u00d6\u18af\b\u00d6\u0001\u00d7\u0003\u00d7"+
"\u18b2\b\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0003\u00d7\u18b7\b"+
"\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001"+
"\u00d7\u0003\u00d7\u18bf\b\u00d7\u0001\u00d8\u0003\u00d8\u18c2\b\u00d8"+
"\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u18c7\b\u00d8\u0001\u00d8"+
"\u0001\u00d8\u0001\u00d8\u0003\u00d8\u18cc\b\u00d8\u0001\u00d8\u0001\u00d8"+
"\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0005\u00d9\u18d4\b\u00d9"+
"\n\u00d9\f\u00d9\u18d7\t\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00da\u0001"+
"\u00da\u0003\u00da\u18dd\b\u00da\u0001\u00db\u0003\u00db\u18e0\b\u00db"+
"\u0001\u00db\u0003\u00db\u18e3\b\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+
"\u0001\u00db\u0001\u00db\u0001\u00db\u0005\u00db\u18eb\b\u00db\n\u00db"+
"\f\u00db\u18ee\t\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+
"\u0001\u00db\u0003\u00db\u18f5\b\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+
"\u0001\u00db\u0003\u00db\u18fb\b\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+
"\u0001\u00db\u0003\u00db\u1901\b\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+
"\u0003\u00db\u1906\b\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0003\u00db"+
"\u190b\b\u00db\u0001\u00db\u0003\u00db\u190e\b\u00db\u0001\u00db\u0003"+
"\u00db\u1911\b\u00db\u0001\u00db\u0003\u00db\u1914\b\u00db\u0001\u00db"+
"\u0003\u00db\u1917\b\u00db\u0001\u00db\u0003\u00db\u191a\b\u00db\u0001"+
"\u00db\u0003\u00db\u191d\b\u00db\u0001\u00db\u0003\u00db\u1920\b\u00db"+
"\u0001\u00db\u0003\u00db\u1923\b\u00db\u0001\u00db\u0003\u00db\u1926\b"+
"\u00db\u0001\u00db\u0003\u00db\u1929\b\u00db\u0001\u00db\u0001\u00db\u0001"+
"\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001"+
"\u00db\u0003\u00db\u1934\b\u00db\u0001\u00db\u0003\u00db\u1937\b\u00db"+
"\u0001\u00db\u0003\u00db\u193a\b\u00db\u0001\u00db\u0003\u00db\u193d\b"+
"\u00db\u0001\u00db\u0003\u00db\u1940\b\u00db\u0003\u00db\u1942\b\u00db"+
"\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd"+
"\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0003\u00dd\u194e\b\u00dd"+
"\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0003\u00de"+
"\u1955\b\u00de\u0001\u00df\u0001\u00df\u0001\u00e0\u0001\u00e0\u0003\u00e0"+
"\u195b\b\u00e0\u0001\u00e1\u0001\u00e1\u0003\u00e1\u195f\b\u00e1\u0001"+
"\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1964\b\u00e2\u0001\u00e3\u0001"+
"\u00e3\u0001\u00e3\u0005\u00e3\u1969\b\u00e3\n\u00e3\f\u00e3\u196c\t\u00e3"+
"\u0001\u00e4\u0001\u00e4\u0003\u00e4\u1970\b\u00e4\u0001\u00e5\u0001\u00e5"+
"\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0003\u00e5"+
"\u1979\b\u00e5\u0003\u00e5\u197b\b\u00e5\u0001\u00e6\u0001\u00e6\u0001"+
"\u00e6\u0001\u00e6\u0003\u00e6\u1981\b\u00e6\u0001\u00e6\u0003\u00e6\u1984"+
"\b\u00e6\u0001\u00e7\u0001\u00e7\u0003\u00e7\u1988\b\u00e7\u0001\u00e7"+
"\u0003\u00e7\u198b\b\u00e7\u0001\u00e7\u0003\u00e7\u198e\b\u00e7\u0001"+
"\u00e8\u0001\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001"+
"\u00ea\u0001\u00ea\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0003"+
"\u00eb\u199c\b\u00eb\u0001\u00ec\u0001\u00ec\u0001\u00ed\u0001\u00ed\u0001"+
"\u00ed\u0001\u00ed\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001"+
"\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00f0\u0001\u00f0\u0001"+
"\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001\u00f1\u0001"+
"\u00f1\u0001\u00f1\u0001\u00f1\u0005\u00f1\u19b7\b\u00f1\n\u00f1\f\u00f1"+
"\u19ba\t\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2"+
"\u0001\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+
"\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+
"\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+
"\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+
"\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0003\u00f3\u19dc\b\u00f3\u0003\u00f3"+
"\u19de\b\u00f3\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4"+
"\u0001\u00f4\u0001\u00f4\u0003\u00f4\u19e7\b\u00f4\u0001\u00f5\u0001\u00f5"+
"\u0003\u00f5\u19eb\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+
"\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u19f4\b\u00f5\u0001\u00f5"+
"\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u19fa\b\u00f5\u0001\u00f5"+
"\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u1a00\b\u00f5\u0001\u00f5"+
"\u0003\u00f5\u1a03\b\u00f5\u0001\u00f5\u0003\u00f5\u1a06\b\u00f5\u0001"+
"\u00f5\u0003\u00f5\u1a09\b\u00f5\u0001\u00f5\u0003\u00f5\u1a0c\b\u00f5"+
"\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+
"\u0003\u00f6\u1a14\b\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7"+
"\u0001\u00f7\u0001\u00f7\u0003\u00f7\u1a1c\b\u00f7\u0001\u00f7\u0003\u00f7"+
"\u1a1f\b\u00f7\u0001\u00f8\u0003\u00f8\u1a22\b\u00f8\u0001\u00f8\u0001"+
"\u00f8\u0001\u00f8\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001"+
"\u00f9\u0001\u00f9\u0003\u00f9\u1a2d\b\u00f9\u0001\u00f9\u0001\u00f9\u0001"+
"\u00f9\u0001\u00f9\u0003\u00f9\u1a33\b\u00f9\u0001\u00f9\u0005\u00f9\u1a36"+
"\b\u00f9\n\u00f9\f\u00f9\u1a39\t\u00f9\u0001\u00fa\u0001\u00fa\u0001\u00fb"+
"\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0003\u00fb"+
"\u1a43\b\u00fb\u0001\u00fc\u0001\u00fc\u0003\u00fc\u1a47\b\u00fc\u0001"+
"\u00fc\u0003\u00fc\u1a4a\b\u00fc\u0001\u00fc\u0003\u00fc\u1a4d\b\u00fc"+
"\u0001\u00fc\u0003\u00fc\u1a50\b\u00fc\u0001\u00fc\u0003\u00fc\u1a53\b"+
"\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fd\u0001\u00fd\u0001"+
"\u00fd\u0001\u00fd\u0005\u00fd\u1a5c\b\u00fd\n\u00fd\f\u00fd\u1a5f\t\u00fd"+
"\u0001\u00fe\u0001\u00fe\u0003\u00fe\u1a63\b\u00fe\u0001\u00fe\u0001\u00fe"+
"\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00ff\u0001\u00ff\u0001\u00ff"+
"\u0001\u00ff\u0005\u00ff\u1a6e\b\u00ff\n\u00ff\f\u00ff\u1a71\t\u00ff\u0001"+
"\u00ff\u0001\u00ff\u0001\u0100\u0001\u0100\u0003\u0100\u1a77\b\u0100\u0001"+
"\u0100\u0001\u0100\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001"+
"\u0101\u0001\u0101\u0001\u0101\u0003\u0101\u1a82\b\u0101\u0001\u0102\u0001"+
"\u0102\u0001\u0102\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0104\u0003"+
"\u0104\u1a8b\b\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0003\u0104\u1a90"+
"\b\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0003\u0104\u1a95\b\u0104"+
"\u0005\u0104\u1a97\b\u0104\n\u0104\f\u0104\u1a9a\t\u0104\u0001\u0105\u0001"+
"\u0105\u0001\u0105\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001"+
"\u0106\u0001\u0107\u0001\u0107\u0001\u0107\u0005\u0107\u1aa7\b\u0107\n"+
"\u0107\f\u0107\u1aaa\t\u0107\u0001\u0108\u0001\u0108\u0005\u0108\u1aae"+
"\b\u0108\n\u0108\f\u0108\u1ab1\t\u0108\u0001\u0109\u0001\u0109\u0001\u0109"+
"\u0003\u0109\u1ab6\b\u0109\u0001\u0109\u0001\u0109\u0003\u0109\u1aba\b"+
"\u0109\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001"+
"\u010a\u0001\u010a\u0001\u010a\u0003\u010a\u1ac4\b\u010a\u0001\u010b\u0001"+
"\u010b\u0001\u010b\u0001\u010b\u0005\u010b\u1aca\b\u010b\n\u010b\f\u010b"+
"\u1acd\t\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+
"\u0001\u010b\u0005\u010b\u1ad5\b\u010b\n\u010b\f\u010b\u1ad8\t\u010b\u0001"+
"\u010b\u0001\u010b\u0003\u010b\u1adc\b\u010b\u0001\u010c\u0001\u010c\u0001"+
"\u010c\u0001\u010c\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001"+
"\u010d\u0005\u010d\u1ae7\b\u010d\n\u010d\f\u010d\u1aea\t\u010d\u0003\u010d"+
"\u1aec\b\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+
"\u0001\u010d\u0005\u010d\u1af4\b\u010d\n\u010d\f\u010d\u1af7\t\u010d\u0003"+
"\u010d\u1af9\b\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001"+
"\u010d\u0001\u010d\u0001\u010d\u0005\u010d\u1b02\b\u010d\n\u010d\f\u010d"+
"\u1b05\t\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+
"\u0005\u010d\u1b0c\b\u010d\n\u010d\f\u010d\u1b0f\t\u010d\u0001\u010d\u0001"+
"\u010d\u0003\u010d\u1b13\b\u010d\u0003\u010d\u1b15\b\u010d\u0001\u010e"+
"\u0001\u010e\u0001\u010e\u0001\u010e\u0005\u010e\u1b1b\b\u010e\n\u010e"+
"\f\u010e\u1b1e\t\u010e\u0003\u010e\u1b20\b\u010e\u0001\u010e\u0001\u010e"+
"\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u0110\u0001\u0110\u0003\u0110"+
"\u1b29\b\u0110\u0001\u0110\u0005\u0110\u1b2c\b\u0110\n\u0110\f\u0110\u1b2f"+
"\t\u0110\u0001\u0110\u0001\u0110\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+
"\u0111\u0003\u0111\u1b37\b\u0111\u0001\u0111\u0005\u0111\u1b3a\b\u0111"+
"\n\u0111\f\u0111\u1b3d\t\u0111\u0001\u0111\u0001\u0111\u0003\u0111\u1b41"+
"\b\u0111\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0003\u0112\u1b47"+
"\b\u0112\u0003\u0112\u1b49\b\u0112\u0001\u0112\u0003\u0112\u1b4c\b\u0112"+
"\u0001\u0113\u0001\u0113\u0001\u0113\u0001\u0113\u0003\u0113\u1b52\b\u0113"+
"\u0001\u0114\u0001\u0114\u0001\u0114\u0005\u0114\u1b57\b\u0114\n\u0114"+
"\f\u0114\u1b5a\t\u0114\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115"+
"\u0001\u0115\u0001\u0115\u0001\u0115\u0005\u0115\u1b63\b\u0115\n\u0115"+
"\f\u0115\u1b66\t\u0115\u0003\u0115\u1b68\b\u0115\u0001\u0115\u0001\u0115"+
"\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0005\u0115\u1b70\b\u0115"+
"\n\u0115\f\u0115\u1b73\t\u0115\u0001\u0116\u0003\u0116\u1b76\b\u0116\u0001"+
"\u0116\u0003\u0116\u1b79\b\u0116\u0001\u0117\u0001\u0117\u0001\u0117\u0001"+
"\u0117\u0001\u0117\u0005\u0117\u1b80\b\u0117\n\u0117\f\u0117\u1b83\t\u0117"+
"\u0001\u0118\u0001\u0118\u0003\u0118\u1b87\b\u0118\u0001\u0118\u0001\u0118"+
"\u0003\u0118\u1b8b\b\u0118\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+
"\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+
"\u0003\u0119\u1b97\b\u0119\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a"+
"\u0001\u011a\u0005\u011a\u1b9e\b\u011a\n\u011a\f\u011a\u1ba1\t\u011a\u0001"+
"\u011b\u0003\u011b\u1ba4\b\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0003"+
"\u011b\u1ba9\b\u011b\u0001\u011b\u0001\u011b\u0003\u011b\u1bad\b\u011b"+
"\u0001\u011b\u0001\u011b\u0003\u011b\u1bb1\b\u011b\u0001\u011b\u0001\u011b"+
"\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b"+
"\u0003\u011b\u1bbb\b\u011b\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c"+
"\u0003\u011c\u1bc1\b\u011c\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d"+
"\u0001\u011e\u0001\u011e\u0001\u011e\u0005\u011e\u1bca\b\u011e\n\u011e"+
"\f\u011e\u1bcd\t\u011e\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f"+
"\u0001\u011f\u0003\u011f\u1bd4\b\u011f\u0001\u011f\u0001\u011f\u0001\u0120"+
"\u0001\u0120\u0003\u0120\u1bda\b\u0120\u0001\u0120\u0003\u0120\u1bdd\b"+
"\u0120\u0001\u0120\u0003\u0120\u1be0\b\u0120\u0001\u0120\u0003\u0120\u1be3"+
"\b\u0120\u0001\u0120\u0003\u0120\u1be6\b\u0120\u0001\u0120\u0001\u0120"+
"\u0003\u0120\u1bea\b\u0120\u0001\u0120\u0003\u0120\u1bed\b\u0120\u0001"+
"\u0120\u0005\u0120\u1bf0\b\u0120\n\u0120\f\u0120\u1bf3\t\u0120\u0001\u0120"+
"\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0005\u0120\u1bfa\b\u0120"+
"\n\u0120\f\u0120\u1bfd\t\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0003"+
"\u0120\u1c02\b\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001"+
"\u0120\u0001\u0120\u0001\u0120\u0003\u0120\u1c0b\b\u0120\u0001\u0121\u0001"+
"\u0121\u0001\u0121\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001"+
"\u0122\u0001\u0123\u0001\u0123\u0001\u0123\u0005\u0123\u1c18\b\u0123\n"+
"\u0123\f\u0123\u1c1b\t\u0123\u0001\u0124\u0001\u0124\u0001\u0124\u0001"+
"\u0124\u0001\u0125\u0001\u0125\u0003\u0125\u1c23\b\u0125\u0001\u0126\u0001"+
"\u0126\u0003\u0126\u1c27\b\u0126\u0001\u0127\u0003\u0127\u1c2a\b\u0127"+
"\u0001\u0127\u0001\u0127\u0003\u0127\u1c2e\b\u0127\u0003\u0127\u1c30\b"+
"\u0127\u0001\u0128\u0001\u0128\u0001\u0128\u0005\u0128\u1c35\b\u0128\n"+
"\u0128\f\u0128\u1c38\t\u0128\u0001\u0129\u0001\u0129\u0001\u0129\u0005"+
"\u0129\u1c3d\b\u0129\n\u0129\f\u0129\u1c40\t\u0129\u0001\u012a\u0001\u012a"+
"\u0001\u012a\u0003\u012a\u1c45\b\u012a\u0001\u012b\u0001\u012b\u0001\u012b"+
"\u0005\u012b\u1c4a\b\u012b\n\u012b\f\u012b\u1c4d\t\u012b\u0001\u012c\u0001"+
"\u012c\u0001\u012c\u0003\u012c\u1c52\b\u012c\u0001\u012c\u0003\u012c\u1c55"+
"\b\u012c\u0001\u012c\u0001\u012c\u0003\u012c\u1c59\b\u012c\u0001\u012c"+
"\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0003\u012c\u1c60\b\u012c"+
"\u0001\u012c\u0003\u012c\u1c63\b\u012c\u0001\u012c\u0003\u012c\u1c66\b"+
"\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0003"+
"\u012c\u1c6d\b\u012c\u0003\u012c\u1c6f\b\u012c\u0001\u012c\u0001\u012c"+
"\u0001\u012c\u0003\u012c\u1c74\b\u012c\u0001\u012c\u0001\u012c\u0003\u012c"+
"\u1c78\b\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c"+
"\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c"+
"\u0003\u012c\u1c85\b\u012c\u0003\u012c\u1c87\b\u012c\u0003\u012c\u1c89"+
"\b\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001"+
"\u012c\u0001\u012c\u0003\u012c\u1c92\b\u012c\u0003\u012c\u1c94\b\u012c"+
"\u0001\u012c\u0001\u012c\u0003\u012c\u1c98\b\u012c\u0001\u012d\u0001\u012d"+
"\u0001\u012d\u0005\u012d\u1c9d\b\u012d\n\u012d\f\u012d\u1ca0\t\u012d\u0001"+
"\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1ca6\b\u012e\u0001"+
"\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1cac\b\u012e\u0001"+
"\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1cb3"+
"\b\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1cb7\b\u012e\u0001\u012f"+
"\u0001\u012f\u0001\u012f\u0005\u012f\u1cbc\b\u012f\n\u012f\f\u012f\u1cbf"+
"\t\u012f\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0003\u0130\u1cc5"+
"\b\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0003\u0130\u1ccb"+
"\b\u0130\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0003\u0131\u1cd1"+
"\b\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001"+
"\u0131\u0003\u0131\u1cd9\b\u0131\u0001\u0132\u0001\u0132\u0001\u0132\u0001"+
"\u0132\u0003\u0132\u1cdf\b\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001"+
"\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0133\u0001"+
"\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0003"+
"\u0133\u1cf0\b\u0133\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0003"+
"\u0134\u1cf6\b\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0003\u0134\u1cfb"+
"\b\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0005\u0134\u1d01"+
"\b\u0134\n\u0134\f\u0134\u1d04\t\u0134\u0001\u0134\u0001\u0134\u0001\u0134"+
"\u0003\u0134\u1d09\b\u0134\u0003\u0134\u1d0b\b\u0134\u0001\u0135\u0001"+
"\u0135\u0001\u0135\u0001\u0135\u0005\u0135\u1d11\b\u0135\n\u0135\f\u0135"+
"\u1d14\t\u0135\u0001\u0135\u0001\u0135\u0001\u0136\u0003\u0136\u1d19\b"+
"\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0003\u0136\u1d1f"+
"\b\u0136\u0001\u0137\u0001\u0137\u0001\u0137\u0005\u0137\u1d24\b\u0137"+
"\n\u0137\f\u0137\u1d27\t\u0137\u0001\u0138\u0001\u0138\u0001\u0138\u0001"+
"\u0138\u0001\u0138\u0003\u0138\u1d2e\b\u0138\u0001\u0138\u0003\u0138\u1d31"+
"\b\u0138\u0001\u0139\u0001\u0139\u0001\u013a\u0001\u013a\u0001\u013a\u0001"+
"\u013a\u0001\u013a\u0005\u013a\u1d3a\b\u013a\n\u013a\f\u013a\u1d3d\t\u013a"+
"\u0001\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b"+
"\u0005\u013b\u1d45\b\u013b\n\u013b\f\u013b\u1d48\t\u013b\u0001\u013c\u0001"+
"\u013c\u0003\u013c\u1d4c\b\u013c\u0001\u013c\u0003\u013c\u1d4f\b\u013c"+
"\u0001\u013d\u0001\u013d\u0001\u013d\u0005\u013d\u1d54\b\u013d\n\u013d"+
"\f\u013d\u1d57\t\u013d\u0001\u013e\u0001\u013e\u0003\u013e\u1d5b\b\u013e"+
"\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f"+
"\u0001\u013f\u0001\u013f\u0004\u013f\u1d65\b\u013f\u000b\u013f\f\u013f"+
"\u1d66\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0003\u013f\u1d6d"+
"\b\u013f\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+
"\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+
"\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+
"\u0140\u0001\u0140\u0001\u0140\u0003\u0140\u1d83\b\u0140\u0003\u0140\u1d85"+
"\b\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+
"\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+
"\u0140\u0005\u0140\u1d93\b\u0140\n\u0140\f\u0140\u1d96\t\u0140\u0001\u0141"+
"\u0001\u0141\u0001\u0141\u0001\u0141\u0005\u0141\u1d9c\b\u0141\n\u0141"+
"\f\u0141\u1d9f\t\u0141\u0003\u0141\u1da1\b\u0141\u0001\u0141\u0001\u0141"+
"\u0001\u0142\u0001\u0142\u0001\u0142\u0003\u0142\u1da8\b\u0142\u0001\u0143"+
"\u0003\u0143\u1dab\b\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143"+
"\u0001\u0143\u0001\u0143\u0003\u0143\u1db3\b\u0143\u0001\u0143\u0001\u0143"+
"\u0001\u0143\u0003\u0143\u1db8\b\u0143\u0001\u0143\u0001\u0143\u0001\u0143"+
"\u0001\u0143\u0003\u0143\u1dbe\b\u0143\u0001\u0143\u0003\u0143\u1dc1\b"+
"\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0003\u0143\u1dc6\b\u0143\u0001"+
"\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0003"+
"\u0143\u1dce\b\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001"+
"\u0143\u0005\u0143\u1dd5\b\u0143\n\u0143\f\u0143\u1dd8\t\u0143\u0001\u0143"+
"\u0001\u0143\u0001\u0143\u0001\u0143\u0003\u0143\u1dde\b\u0143\u0001\u0143"+
"\u0001\u0143\u0001\u0143\u0003\u0143\u1de3\b\u0143\u0001\u0143\u0003\u0143"+
"\u1de6\b\u0143\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0003\u0144"+
"\u1dec\b\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144"+
"\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0005\u0144"+
"\u1df8\b\u0144\n\u0144\f\u0144\u1dfb\t\u0144\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0004\u0145\u1e07\b\u0145\u000b\u0145\f\u0145\u1e08"+
"\u0001\u0145\u0001\u0145\u0003\u0145\u1e0d\b\u0145\u0001\u0145\u0001\u0145"+
"\u0001\u0145\u0001\u0145\u0001\u0145\u0004\u0145\u1e14\b\u0145\u000b\u0145"+
"\f\u0145\u1e15\u0001\u0145\u0001\u0145\u0003\u0145\u1e1a\b\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0005\u0145\u1e31\b\u0145\n\u0145\f\u0145"+
"\u1e34\t\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1e38\b\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0003\u0145\u1e54\b\u0145\u0001\u0145\u0001\u0145\u0003"+
"\u0145\u1e58\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1e63"+
"\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0003\u0145\u1e6b\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003"+
"\u0145\u1e70\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003"+
"\u0145\u1e7c\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+
"\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003"+
"\u0145\u1e88\b\u0145\u0005\u0145\u1e8a\b\u0145\n\u0145\f\u0145\u1e8d\t"+
"\u0145\u0001\u0146\u0001\u0146\u0001\u0146\u0003\u0146\u1e92\b\u0146\u0003"+
"\u0146\u1e94\b\u0146\u0001\u0147\u0001\u0147\u0001\u0147\u0003\u0147\u1e99"+
"\b\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0005\u0147\u1e9e\b\u0147"+
"\n\u0147\f\u0147\u1ea1\t\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001"+
"\u0147\u0001\u0147\u0005\u0147\u1ea8\b\u0147\n\u0147\f\u0147\u1eab\t\u0147"+
"\u0003\u0147\u1ead\b\u0147\u0003\u0147\u1eaf\b\u0147\u0001\u0147\u0001"+
"\u0147\u0001\u0147\u0003\u0147\u1eb4\b\u0147\u0001\u0148\u0001\u0148\u0001"+
"\u0148\u0003\u0148\u1eb9\b\u0148\u0001\u0148\u0001\u0148\u0001\u0149\u0001"+
"\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001"+
"\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001"+
"\u0149\u0001\u0149\u0001\u0149\u0003\u0149\u1ecd\b\u0149\u0001\u014a\u0001"+
"\u014a\u0003\u014a\u1ed1\b\u014a\u0001\u014a\u0003\u014a\u1ed4\b\u014a"+
"\u0001\u014a\u0003\u014a\u1ed7\b\u014a\u0001\u014a\u0001\u014a\u0001\u014b"+
"\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b"+
"\u0001\u014b\u0001\u014b\u0003\u014b\u1ee4\b\u014b\u0001\u014c\u0001\u014c"+
"\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d"+
"\u0001\u014d\u0003\u014d\u1eef\b\u014d\u0001\u014e\u0001\u014e\u0001\u014e"+
"\u0005\u014e\u1ef4\b\u014e\n\u014e\f\u014e\u1ef7\t\u014e\u0001\u014f\u0003"+
"\u014f\u1efa\b\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0003\u014f\u1eff"+
"\b\u014f\u0001\u014f\u0003\u014f\u1f02\b\u014f\u0001\u014f\u0001\u014f"+
"\u0003\u014f\u1f06\b\u014f\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150"+
"\u0001\u0150\u0001\u0150\u0003\u0150\u1f0e\b\u0150\u0001\u0150\u0001\u0150"+
"\u0001\u0150\u0003\u0150\u1f13\b\u0150\u0001\u0150\u0001\u0150\u0005\u0150"+
"\u1f17\b\u0150\n\u0150\f\u0150\u1f1a\t\u0150\u0001\u0150\u0001\u0150\u0001"+
"\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0003\u0150\u1f22\b\u0150\u0001"+
"\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0005\u0150\u1f29"+
"\b\u0150\n\u0150\f\u0150\u1f2c\t\u0150\u0001\u0150\u0001\u0150\u0001\u0150"+
"\u0001\u0150\u0001\u0150\u0005\u0150\u1f33\b\u0150\n\u0150\f\u0150\u1f36"+
"\t\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0003\u0150\u1f3b\b\u0150"+
"\u0001\u0151\u0001\u0151\u0001\u0152\u0001\u0152\u0001\u0153\u0001\u0153"+
"\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0154\u0001\u0154\u0001\u0154"+
"\u0001\u0154\u0001\u0155\u0001\u0155\u0001\u0156\u0001\u0156\u0003\u0156"+
"\u1f4e\b\u0156\u0001\u0156\u0003\u0156\u1f51\b\u0156\u0001\u0157\u0001"+
"\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+
"\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+
"\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+
"\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0005"+
"\u0157\u1f6c\b\u0157\n\u0157\f\u0157\u1f6f\t\u0157\u0001\u0157\u0001\u0157"+
"\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157"+
"\u0005\u0157\u1f79\b\u0157\n\u0157\f\u0157\u1f7c\t\u0157\u0001\u0157\u0003"+
"\u0157\u1f7f\b\u0157\u0003\u0157\u1f81\b\u0157\u0001\u0158\u0001\u0158"+
"\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+
"\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+
"\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+
"\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+
"\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0003\u0158"+
"\u1fa2\b\u0158\u0001\u0159\u0001\u0159\u0001\u0159\u0005\u0159\u1fa7\b"+
"\u0159\n\u0159\f\u0159\u1faa\t\u0159\u0001\u015a\u0001\u015a\u0001\u015a"+
"\u0001\u015a\u0003\u015a\u1fb0\b\u015a\u0001\u015b\u0001\u015b\u0001\u015b"+
"\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b"+
"\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b"+
"\u0001\u015b\u0001\u015b\u0001\u015b\u0003\u015b\u1fc4\b\u015b\u0001\u015c"+
"\u0001\u015c\u0001\u015c\u0005\u015c\u1fc9\b\u015c\n\u015c\f\u015c\u1fcc"+
"\t\u015c\u0001\u015d\u0003\u015d\u1fcf\b\u015d\u0001\u015d\u0001\u015d"+
"\u0001\u015d\u0001\u015d\u0003\u015d\u1fd5\b\u015d\u0001\u015e\u0001\u015e"+
"\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u0160\u0001\u0160\u0001\u0160"+
"\u0003\u0160\u1fdf\b\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0003\u0160"+
"\u1fe4\b\u0160\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0003\u0161"+
"\u1fea\b\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162"+
"\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0003\u0162"+
"\u1ff6\b\u0162\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0164\u0001\u0164"+
"\u0004\u0164\u1ffd\b\u0164\u000b\u0164\f\u0164\u1ffe\u0001\u0164\u0003"+
"\u0164\u2002\b\u0164\u0001\u0165\u0001\u0165\u0001\u0166\u0001\u0166\u0001"+
"\u0166\u0003\u0166\u2009\b\u0166\u0001\u0167\u0001\u0167\u0001\u0168\u0003"+
"\u0168\u200e\b\u0168\u0001\u0168\u0001\u0168\u0003\u0168\u2012\b\u0168"+
"\u0001\u0168\u0003\u0168\u2015\b\u0168\u0001\u0169\u0001\u0169\u0001\u0169"+
"\u0003\u093e\u09cb\u09d2\u0006\u00b6\u00c2\u01f2\u0280\u0288\u028a\u016a"+
"\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a"+
"\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+
"\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+
"\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+
"\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca"+
"\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2"+
"\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa"+
"\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112"+
"\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a"+
"\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142"+
"\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a"+
"\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172"+
"\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a"+
"\u018c\u018e\u0190\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2"+
"\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba"+
"\u01bc\u01be\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2"+
"\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea"+
"\u01ec\u01ee\u01f0\u01f2\u01f4\u01f6\u01f8\u01fa\u01fc\u01fe\u0200\u0202"+
"\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a"+
"\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232"+
"\u0234\u0236\u0238\u023a\u023c\u023e\u0240\u0242\u0244\u0246\u0248\u024a"+
"\u024c\u024e\u0250\u0252\u0254\u0256\u0258\u025a\u025c\u025e\u0260\u0262"+
"\u0264\u0266\u0268\u026a\u026c\u026e\u0270\u0272\u0274\u0276\u0278\u027a"+
"\u027c\u027e\u0280\u0282\u0284\u0286\u0288\u028a\u028c\u028e\u0290\u0292"+
"\u0294\u0296\u0298\u029a\u029c\u029e\u02a0\u02a2\u02a4\u02a6\u02a8\u02aa"+
"\u02ac\u02ae\u02b0\u02b2\u02b4\u02b6\u02b8\u02ba\u02bc\u02be\u02c0\u02c2"+
"\u02c4\u02c6\u02c8\u02ca\u02cc\u02ce\u02d0\u02d2\u0000[\u0003\u0000\u00b5"+
"\u00b5\u02ba\u02ba\u02c8\u02c8\u0002\u0000\u014f\u014f\u02a7\u02a7\u0001"+
"\u0000IJ\u0003\u0000\u00d1\u00d1\u016d\u016d\u01a2\u01a2\u0002\u0000\u000f"+
"\u000f\u0012\u0012\u0002\u0000\u001b\u001b33\u0002\u0000vv\u0288\u0288"+
"\u0002\u0000\u01d1\u01d1\u02cf\u02cf\u0002\u0000\u000e\u000e\u00fb\u00fb"+
"\u0002\u0000\u0011\u0011\u001e\u001e\u0002\u0000\u00d1\u00d1\u01a2\u01a2"+
"\u0002\u0000tt\u0238\u0238\u0001\u0000\u0212\u0213\u0002\u0000\u00d8\u00d8"+
"\u0173\u0173\u0004\u0000\u001d\u001d%%CCcc\u0002\u000000\u015a\u015a\u0001"+
"\u0000-.\u0003\u0000\u017a\u017a\u01be\u01be\u024e\u024e\u0004\u0000\u0003"+
"\u0004YYnn\u009d\u009d\u0002\u0000aa\u01ed\u01ed\u0002\u0000\u024e\u024e"+
"\u0281\u0281\u0004\u0000OO\u00db\u00db\u0141\u0141\u027a\u027a\u0002\u0000"+
"OO\u009b\u009b\u0002\u0000\u008c\u008c\u00f1\u00f1\u0002\u0000\u00cd\u00cd"+
"\u01f1\u01f1\u0003\u0000\u01b8\u01b8\u0226\u0226\u023c\u023c\u0001\u0000"+
"\u02b9\u02ba\u0001\u0000\u02b7\u02b8\u0005\u0000!!ST{{\u012d\u012d\u024a"+
"\u024a\u0002\u0000\u0018\u0018\u02c1\u02c1\u0003\u000077DD]]\u0002\u0000"+
"\u00c8\u00c8\u013b\u013b\u0002\u0000\u00d2\u00d2\u0136\u0136\u0002\u0000"+
"\u0163\u0163\u0286\u0286\u000f\u0000\u0001\t\u000b\u001a\u001c\u001e "+
",/fhuw\u0083\u0085\u009c\u009e\u00a6\u00ad\u00b3\u0120\u0120\u0122\u0123"+
"\u014a\u014a\u01ad\u01ad\u0206\u0206\u0002\u0000\u0176\u0176\u0213\u0213"+
"\u0002\u0000\u00d5\u00d5\u02cf\u02cf\u0002\u0000\u0160\u0160\u0276\u0276"+
"\u0003\u0000\u00c6\u00c6\u0148\u0148\u028f\u028f\u0002\u0000\u0204\u0204"+
"\u0234\u0234\u0002\u0000\u0172\u0172\u0191\u0191\u0002\u0000\u02ca\u02ca"+
"\u02cf\u02cf\u0002\u0000\u0159\u0159\u01ed\u01ed\u0001\u0000\u029e\u029f"+
"\u0002\u0000\u0125\u0125\u0248\u0248\u0002\u0000\u0126\u0126\u0249\u0249"+
"\u0002\u0000\u0106\u0106\u0166\u0166\u0002\u0000\u0154\u0154\u02a5\u02a5"+
"\u0002\u0000\u0193\u0194\u01ac\u01ad\u0003\u0000\u00cf\u00cf\u0134\u0134"+
"\u01d4\u01d4\u0003\u0000\u0124\u0124\u022e\u022e\u0281\u0281\u0001\u0000"+
"\u0144\u0145\u0003\u0000!!\u018b\u018b\u01da\u01da\u0002\u0000\u0191\u0191"+
"\u027e\u027e\u0002\u0000\u00c6\u00c6\u026f\u026f\u0003\u0000\u00e3\u00e3"+
"\u019f\u019f\u01e4\u01e4\u0004\u0000\u00ec\u00ec\u0183\u0183\u01be\u01be"+
"\u0244\u0244\u0003\u0000\u012d\u012d\u018a\u018a\u024a\u024a\u0001\u0000"+
"\u00bf\u00c0\u0002\u0000\u01ee\u01ee\u02ad\u02ad\u0001\u0000\u01f9\u01fa"+
"\u0002\u0000\u01bc\u01bc\u021d\u021d\u0002\u0000\u0133\u0133\u0190\u0190"+
"\u0002\u0000\u00d5\u00d5\u010b\u010b\u0005\u0000\u0147\u0147\u017d\u017d"+
"\u0208\u0208\u0283\u0283\u02a0\u02a0\u0002\u0000\u0136\u0137\u015d\u015d"+
"\n\u0000\u00c8\u00c8\u00cb\u00cb\u013e\u013e\u01c3\u01c3\u01d3\u01d3\u01f0"+
"\u01f0\u01f8\u01f8\u0205\u0205\u023a\u023a\u0253\u0253\u0003\u0000\u0158"+
"\u0158\u01d8\u01d8\u028e\u028e\u0002\u0000\u0169\u0169\u01b1\u01b1\b\u0000"+
"\u00e5\u00e5\u0179\u0179\u0187\u0187\u01d1\u01d1\u01d7\u01d7\u0219\u0219"+
"\u022b\u022c\u0269\u0269\u0002\u0000\u01e7\u01e7\u02bf\u02bf\u0001\u0000"+
"\u01a4\u01a5\u0002\u0000\u00cd\u00cd\u02be\u02be\u0002\u0000\u0226\u0226"+
"\u023c\u023c\u0001\u0000\u01c7\u01cd\u0002\u0000\u02b7\u02b8\u02bc\u02bc"+
"\u0002\u0000\u0140\u0140\u02b9\u02bb\u0004\u0000\u02b7\u02b8\u02bd\u02bd"+
"\u02c0\u02c0\u02c2\u02c2\u0002\u0000\u017a\u017a\u024e\u024e\u0002\u0000"+
"\u0127\u0127\u027c\u027c\u0002\u0000\u0255\u0255\u0292\u0292\u0001\u0000"+
"\u0199\u019a\u0002\u0000\u021d\u021d\u0243\u0243\u0002\u0000\u016c\u016c"+
"\u020f\u020f\u0004\u0000\u0127\u0127\u012a\u012a\u012c\u012c\u027c\u027c"+
"\u0001\u0000\u02b0\u02b6\u0007\u0000\u012d\u012d\u018a\u018a\u01d9\u01d9"+
"\u01dc\u01dc\u024a\u024a\u02a6\u02a6\u02af\u02af\u0002\u0000\u02b9\u02b9"+
"\u02cf\u02cf\u0001\u0000\u01ce\u01cf\u0001\u0000\u02d0\u02d1d\u0000!!"+
"\u0086\u0086\u00bd\u00be\u00c1\u00c1\u00c4\u00c7\u00cb\u00cb\u00d0\u00d0"+
"\u00d3\u00d4\u00d6\u00d7\u00d9\u00dc\u00df\u00df\u00e2\u00f0\u00f2\u00f4"+
"\u00f8\u00fd\u00ff\u0100\u0102\u0104\u0106\u0112\u0114\u0118\u011a\u011b"+
"\u011f\u0124\u0127\u0130\u0133\u0133\u0135\u0135\u0138\u0139\u013c\u013d"+
"\u0141\u0142\u0146\u0146\u0149\u014a\u014c\u0152\u0154\u0157\u0159\u0159"+
"\u015c\u015c\u0160\u0160\u0162\u0162\u0164\u0169\u0170\u0171\u0174\u0174"+
"\u0176\u0176\u0178\u017a\u017d\u017d\u017f\u0181\u0183\u0185\u0187\u018d"+
"\u018f\u0190\u0192\u0192\u0194\u0194\u019f\u01a1\u01a3\u01a8\u01aa\u01ab"+
"\u01af\u01af\u01b1\u01b1\u01b3\u01b4\u01b6\u01b7\u01ba\u01bb\u01be\u01c3"+
"\u01c5\u01c6\u01c8\u01cd\u01d0\u01d1\u01d3\u01d7\u01d9\u01df\u01e1\u01e6"+
"\u01e9\u01e9\u01eb\u01ec\u01ee\u01f0\u01f7\u01f8\u01fa\u0206\u0208\u0208"+
"\u020a\u020e\u0212\u0212\u0214\u021c\u0221\u0224\u022a\u022d\u022f\u0238"+
"\u023a\u023a\u023c\u023c\u023f\u0241\u0244\u0248\u024a\u024a\u024d\u024f"+
"\u0252\u0253\u0256\u0256\u0258\u025b\u025d\u0269\u026f\u026f\u0273\u0276"+
"\u0278\u0279\u027b\u027c\u0281\u0281\u0283\u0284\u0287\u0288\u028a\u028a"+
"\u028c\u028c\u0290\u0291\u0293\u0293\u0296\u0296\u0298\u0298\u029a\u02a6"+
"\u02ab\u02ab\u02af\u02af\u02c5\u02c7\u25a0\u0000\u02d4\u0001\u0000\u0000"+
"\u0000\u0002\u02de\u0001\u0000\u0000\u0000\u0004\u02e3\u0001\u0000\u0000"+
"\u0000\u0006\u02f7\u0001\u0000\u0000\u0000\b\u02f9\u0001\u0000\u0000\u0000"+
"\n\u0305\u0001\u0000\u0000\u0000\f\u0307\u0001\u0000\u0000\u0000\u000e"+
"\u0332\u0001\u0000\u0000\u0000\u0010\u0334\u0001\u0000\u0000\u0000\u0012"+
"\u0336\u0001\u0000\u0000\u0000\u0014\u033c\u0001\u0000\u0000\u0000\u0016"+
"\u0342\u0001\u0000\u0000\u0000\u0018\u0344\u0001\u0000\u0000\u0000\u001a"+
"\u0354\u0001\u0000\u0000\u0000\u001c\u035a\u0001\u0000\u0000\u0000\u001e"+
"\u036c\u0001\u0000\u0000\u0000 \u036e\u0001\u0000\u0000\u0000\"\u0373"+
"\u0001\u0000\u0000\u0000$\u0398\u0001\u0000\u0000\u0000&\u03a2\u0001\u0000"+
"\u0000\u0000(\u03ad\u0001\u0000\u0000\u0000*\u03c1\u0001\u0000\u0000\u0000"+
",\u03c3\u0001\u0000\u0000\u0000.\u03c9\u0001\u0000\u0000\u00000\u03d2"+
"\u0001\u0000\u0000\u00002\u03dd\u0001\u0000\u0000\u00004\u03eb\u0001\u0000"+
"\u0000\u00006\u0410\u0001\u0000\u0000\u00008\u0412\u0001\u0000\u0000\u0000"+
":\u041a\u0001\u0000\u0000\u0000<\u0425\u0001\u0000\u0000\u0000>\u042e"+
"\u0001\u0000\u0000\u0000@\u0431\u0001\u0000\u0000\u0000B\u046a\u0001\u0000"+
"\u0000\u0000D\u046c\u0001\u0000\u0000\u0000F\u0482\u0001\u0000\u0000\u0000"+
"H\u0490\u0001\u0000\u0000\u0000J\u0499\u0001\u0000\u0000\u0000L\u04a9"+
"\u0001\u0000\u0000\u0000N\u04b5\u0001\u0000\u0000\u0000P\u04c1\u0001\u0000"+
"\u0000\u0000R\u04d8\u0001\u0000\u0000\u0000T\u04e1\u0001\u0000\u0000\u0000"+
"V\u04ee\u0001\u0000\u0000\u0000X\u04fb\u0001\u0000\u0000\u0000Z\u0504"+
"\u0001\u0000\u0000\u0000\\\u051d\u0001\u0000\u0000\u0000^\u0525\u0001"+
"\u0000\u0000\u0000`\u052d\u0001\u0000\u0000\u0000b\u0532\u0001\u0000\u0000"+
"\u0000d\u0553\u0001\u0000\u0000\u0000f\u057f\u0001\u0000\u0000\u0000h"+
"\u0582\u0001\u0000\u0000\u0000j\u0591\u0001\u0000\u0000\u0000l\u0593\u0001"+
"\u0000\u0000\u0000n\u05b0\u0001\u0000\u0000\u0000p\u05b2\u0001\u0000\u0000"+
"\u0000r\u05c2\u0001\u0000\u0000\u0000t\u05c9\u0001\u0000\u0000\u0000v"+
"\u05cf\u0001\u0000\u0000\u0000x\u05d4\u0001\u0000\u0000\u0000z\u05d7\u0001"+
"\u0000\u0000\u0000|\u05dc\u0001\u0000\u0000\u0000~\u05e4\u0001\u0000\u0000"+
"\u0000\u0080\u05ea\u0001\u0000\u0000\u0000\u0082\u05ec\u0001\u0000\u0000"+
"\u0000\u0084\u05f2\u0001\u0000\u0000\u0000\u0086\u05f6\u0001\u0000\u0000"+
"\u0000\u0088\u05fa\u0001\u0000\u0000\u0000\u008a\u0605\u0001\u0000\u0000"+
"\u0000\u008c\u060e\u0001\u0000\u0000\u0000\u008e\u0622\u0001\u0000\u0000"+
"\u0000\u0090\u0625\u0001\u0000\u0000\u0000\u0092\u062f\u0001\u0000\u0000"+
"\u0000\u0094\u0632\u0001\u0000\u0000\u0000\u0096\u0638\u0001\u0000\u0000"+
"\u0000\u0098\u063a\u0001\u0000\u0000\u0000\u009a\u0648\u0001\u0000\u0000"+
"\u0000\u009c\u0650\u0001\u0000\u0000\u0000\u009e\u0653\u0001\u0000\u0000"+
"\u0000\u00a0\u065e\u0001\u0000\u0000\u0000\u00a2\u0665\u0001\u0000\u0000"+
"\u0000\u00a4\u0668\u0001\u0000\u0000\u0000\u00a6\u0674\u0001\u0000\u0000"+
"\u0000\u00a8\u0677\u0001\u0000\u0000\u0000\u00aa\u0695\u0001\u0000\u0000"+
"\u0000\u00ac\u069d\u0001\u0000\u0000\u0000\u00ae\u06a2\u0001\u0000\u0000"+
"\u0000\u00b0\u06b1\u0001\u0000\u0000\u0000\u00b2\u06ca\u0001\u0000\u0000"+
"\u0000\u00b4\u06cc\u0001\u0000\u0000\u0000\u00b6\u06de\u0001\u0000\u0000"+
"\u0000\u00b8\u06ec\u0001\u0000\u0000\u0000\u00ba\u06fb\u0001\u0000\u0000"+
"\u0000\u00bc\u06fd\u0001\u0000\u0000\u0000\u00be\u0701\u0001\u0000\u0000"+
"\u0000\u00c0\u070d\u0001\u0000\u0000\u0000\u00c2\u0721\u0001\u0000\u0000"+
"\u0000\u00c4\u0738\u0001\u0000\u0000\u0000\u00c6\u073a\u0001\u0000\u0000"+
"\u0000\u00c8\u073e\u0001\u0000\u0000\u0000\u00ca\u0740\u0001\u0000\u0000"+
"\u0000\u00cc\u0754\u0001\u0000\u0000\u0000\u00ce\u0758\u0001\u0000\u0000"+
"\u0000\u00d0\u075a\u0001\u0000\u0000\u0000\u00d2\u076b\u0001\u0000\u0000"+
"\u0000\u00d4\u077b\u0001\u0000\u0000\u0000\u00d6\u0817\u0001\u0000\u0000"+
"\u0000\u00d8\u0819\u0001\u0000\u0000\u0000\u00da\u081b\u0001\u0000\u0000"+
"\u0000\u00dc\u082b\u0001\u0000\u0000\u0000\u00de\u0835\u0001\u0000\u0000"+
"\u0000\u00e0\u0907\u0001\u0000\u0000\u0000\u00e2\u0909\u0001\u0000\u0000"+
"\u0000\u00e4\u0912\u0001\u0000\u0000\u0000\u00e6\u0916\u0001\u0000\u0000"+
"\u0000\u00e8\u091d\u0001\u0000\u0000\u0000\u00ea\u0922\u0001\u0000\u0000"+
"\u0000\u00ec\u092a\u0001\u0000\u0000\u0000\u00ee\u0939\u0001\u0000\u0000"+
"\u0000\u00f0\u093e\u0001\u0000\u0000\u0000\u00f2\u0941\u0001\u0000\u0000"+
"\u0000\u00f4\u0952\u0001\u0000\u0000\u0000\u00f6\u0954\u0001\u0000\u0000"+
"\u0000\u00f8\u0957\u0001\u0000\u0000\u0000\u00fa\u095b\u0001\u0000\u0000"+
"\u0000\u00fc\u0962\u0001\u0000\u0000\u0000\u00fe\u096a\u0001\u0000\u0000"+
"\u0000\u0100\u096d\u0001\u0000\u0000\u0000\u0102\u0972\u0001\u0000\u0000"+
"\u0000\u0104\u0976\u0001\u0000\u0000\u0000\u0106\u0978\u0001\u0000\u0000"+
"\u0000\u0108\u097a\u0001\u0000\u0000\u0000\u010a\u097f\u0001\u0000\u0000"+
"\u0000\u010c\u099b\u0001\u0000\u0000\u0000\u010e\u09a9\u0001\u0000\u0000"+
"\u0000\u0110\u09f6\u0001\u0000\u0000\u0000\u0112\u0a09\u0001\u0000\u0000"+
"\u0000\u0114\u0a1f\u0001\u0000\u0000\u0000\u0116\u0aac\u0001\u0000\u0000"+
"\u0000\u0118\u0aae\u0001\u0000\u0000\u0000\u011a\u0ae1\u0001\u0000\u0000"+
"\u0000\u011c\u0ae3\u0001\u0000\u0000\u0000\u011e\u0b5f\u0001\u0000\u0000"+
"\u0000\u0120\u0c20\u0001\u0000\u0000\u0000\u0122\u0c42\u0001\u0000\u0000"+
"\u0000\u0124\u0c6e\u0001\u0000\u0000\u0000\u0126\u0c84\u0001\u0000\u0000"+
"\u0000\u0128\u0c8e\u0001\u0000\u0000\u0000\u012a\u0cfc\u0001\u0000\u0000"+
"\u0000\u012c\u0cfe\u0001\u0000\u0000\u0000\u012e\u0d04\u0001\u0000\u0000"+
"\u0000\u0130\u0fc3\u0001\u0000\u0000\u0000\u0132\u1035\u0001\u0000\u0000"+
"\u0000\u0134\u1041\u0001\u0000\u0000\u0000\u0136\u1043\u0001\u0000\u0000"+
"\u0000\u0138\u1047\u0001\u0000\u0000\u0000\u013a\u104b\u0001\u0000\u0000"+
"\u0000\u013c\u104e\u0001\u0000\u0000\u0000\u013e\u1052\u0001\u0000\u0000"+
"\u0000\u0140\u106b\u0001\u0000\u0000\u0000\u0142\u1083\u0001\u0000\u0000"+
"\u0000\u0144\u109c\u0001\u0000\u0000\u0000\u0146\u10b6\u0001\u0000\u0000"+
"\u0000\u0148\u1110\u0001\u0000\u0000\u0000\u014a\u1133\u0001\u0000\u0000"+
"\u0000\u014c\u11c6\u0001\u0000\u0000\u0000\u014e\u11c8\u0001\u0000\u0000"+
"\u0000\u0150\u11e0\u0001\u0000\u0000\u0000\u0152\u120c\u0001\u0000\u0000"+
"\u0000\u0154\u1262\u0001\u0000\u0000\u0000\u0156\u1269\u0001\u0000\u0000"+
"\u0000\u0158\u126b\u0001\u0000\u0000\u0000\u015a\u1322\u0001\u0000\u0000"+
"\u0000\u015c\u1386\u0001\u0000\u0000\u0000\u015e\u1388\u0001\u0000\u0000"+
"\u0000\u0160\u138c\u0001\u0000\u0000\u0000\u0162\u148b\u0001\u0000\u0000"+
"\u0000\u0164\u14a0\u0001\u0000\u0000\u0000\u0166\u14b5\u0001\u0000\u0000"+
"\u0000\u0168\u14bb\u0001\u0000\u0000\u0000\u016a\u14c4\u0001\u0000\u0000"+
"\u0000\u016c\u14cc\u0001\u0000\u0000\u0000\u016e\u14dd\u0001\u0000\u0000"+
"\u0000\u0170\u14df\u0001\u0000\u0000\u0000\u0172\u14e2\u0001\u0000\u0000"+
"\u0000\u0174\u14e5\u0001\u0000\u0000\u0000\u0176\u14ed\u0001\u0000\u0000"+
"\u0000\u0178\u14f8\u0001\u0000\u0000\u0000\u017a\u14fa\u0001\u0000\u0000"+
"\u0000\u017c\u14fd\u0001\u0000\u0000\u0000\u017e\u1594\u0001\u0000\u0000"+
"\u0000\u0180\u1630\u0001\u0000\u0000\u0000\u0182\u1644\u0001\u0000\u0000"+
"\u0000\u0184\u1758\u0001\u0000\u0000\u0000\u0186\u175a\u0001\u0000\u0000"+
"\u0000\u0188\u1768\u0001\u0000\u0000\u0000\u018a\u176a\u0001\u0000\u0000"+
"\u0000\u018c\u1772\u0001\u0000\u0000\u0000\u018e\u1778\u0001\u0000\u0000"+
"\u0000\u0190\u1787\u0001\u0000\u0000\u0000\u0192\u17ab\u0001\u0000\u0000"+
"\u0000\u0194\u17b5\u0001\u0000\u0000\u0000\u0196\u17e5\u0001\u0000\u0000"+
"\u0000\u0198\u17e7\u0001\u0000\u0000\u0000\u019a\u181b\u0001\u0000\u0000"+
"\u0000\u019c\u182f\u0001\u0000\u0000\u0000\u019e\u1831\u0001\u0000\u0000"+
"\u0000\u01a0\u1834\u0001\u0000\u0000\u0000\u01a2\u184c\u0001\u0000\u0000"+
"\u0000\u01a4\u1862\u0001\u0000\u0000\u0000\u01a6\u1881\u0001\u0000\u0000"+
"\u0000\u01a8\u1883\u0001\u0000\u0000\u0000\u01aa\u18a0\u0001\u0000\u0000"+
"\u0000\u01ac\u18ae\u0001\u0000\u0000\u0000\u01ae\u18be\u0001\u0000\u0000"+
"\u0000\u01b0\u18c1\u0001\u0000\u0000\u0000\u01b2\u18cf\u0001\u0000\u0000"+
"\u0000\u01b4\u18dc\u0001\u0000\u0000\u0000\u01b6\u1941\u0001\u0000\u0000"+
"\u0000\u01b8\u1943\u0001\u0000\u0000\u0000\u01ba\u194d\u0001\u0000\u0000"+
"\u0000\u01bc\u194f\u0001\u0000\u0000\u0000\u01be\u1956\u0001\u0000\u0000"+
"\u0000\u01c0\u195a\u0001\u0000\u0000\u0000\u01c2\u195e\u0001\u0000\u0000"+
"\u0000\u01c4\u1963\u0001\u0000\u0000\u0000\u01c6\u1965\u0001\u0000\u0000"+
"\u0000\u01c8\u196f\u0001\u0000\u0000\u0000\u01ca\u1971\u0001\u0000\u0000"+
"\u0000\u01cc\u197c\u0001\u0000\u0000\u0000\u01ce\u1985\u0001\u0000\u0000"+
"\u0000\u01d0\u198f\u0001\u0000\u0000\u0000\u01d2\u1991\u0001\u0000\u0000"+
"\u0000\u01d4\u1993\u0001\u0000\u0000\u0000\u01d6\u199b\u0001\u0000\u0000"+
"\u0000\u01d8\u199d\u0001\u0000\u0000\u0000\u01da\u199f\u0001\u0000\u0000"+
"\u0000\u01dc\u19a3\u0001\u0000\u0000\u0000\u01de\u19a7\u0001\u0000\u0000"+
"\u0000\u01e0\u19ab\u0001\u0000\u0000\u0000\u01e2\u19b1\u0001\u0000\u0000"+
"\u0000\u01e4\u19bd\u0001\u0000\u0000\u0000\u01e6\u19dd\u0001\u0000\u0000"+
"\u0000\u01e8\u19df\u0001\u0000\u0000\u0000\u01ea\u19e8\u0001\u0000\u0000"+
"\u0000\u01ec\u1a13\u0001\u0000\u0000\u0000\u01ee\u1a15\u0001\u0000\u0000"+
"\u0000\u01f0\u1a21\u0001\u0000\u0000\u0000\u01f2\u1a26\u0001\u0000\u0000"+
"\u0000\u01f4\u1a3a\u0001\u0000\u0000\u0000\u01f6\u1a42\u0001\u0000\u0000"+
"\u0000\u01f8\u1a44\u0001\u0000\u0000\u0000\u01fa\u1a57\u0001\u0000\u0000"+
"\u0000\u01fc\u1a60\u0001\u0000\u0000\u0000\u01fe\u1a69\u0001\u0000\u0000"+
"\u0000\u0200\u1a74\u0001\u0000\u0000\u0000\u0202\u1a81\u0001\u0000\u0000"+
"\u0000\u0204\u1a83\u0001\u0000\u0000\u0000\u0206\u1a86\u0001\u0000\u0000"+
"\u0000\u0208\u1a8a\u0001\u0000\u0000\u0000\u020a\u1a9b\u0001\u0000\u0000"+
"\u0000\u020c\u1a9e\u0001\u0000\u0000\u0000\u020e\u1aa3\u0001\u0000\u0000"+
"\u0000\u0210\u1aab\u0001\u0000\u0000\u0000\u0212\u1ab2\u0001\u0000\u0000"+
"\u0000\u0214\u1ac3\u0001\u0000\u0000\u0000\u0216\u1adb\u0001\u0000\u0000"+
"\u0000\u0218\u1add\u0001\u0000\u0000\u0000\u021a\u1b14\u0001\u0000\u0000"+
"\u0000\u021c\u1b16\u0001\u0000\u0000\u0000\u021e\u1b23\u0001\u0000\u0000"+
"\u0000\u0220\u1b26\u0001\u0000\u0000\u0000\u0222\u1b32\u0001\u0000\u0000"+
"\u0000\u0224\u1b4b\u0001\u0000\u0000\u0000\u0226\u1b4d\u0001\u0000\u0000"+
"\u0000\u0228\u1b53\u0001\u0000\u0000\u0000\u022a\u1b5b\u0001\u0000\u0000"+
"\u0000\u022c\u1b75\u0001\u0000\u0000\u0000\u022e\u1b7a\u0001\u0000\u0000"+
"\u0000\u0230\u1b84\u0001\u0000\u0000\u0000\u0232\u1b96\u0001\u0000\u0000"+
"\u0000\u0234\u1b98\u0001\u0000\u0000\u0000\u0236\u1bba\u0001\u0000\u0000"+
"\u0000\u0238\u1bc0\u0001\u0000\u0000\u0000\u023a\u1bc2\u0001\u0000\u0000"+
"\u0000\u023c\u1bc6\u0001\u0000\u0000\u0000\u023e\u1bce\u0001\u0000\u0000"+
"\u0000\u0240\u1c0a\u0001\u0000\u0000\u0000\u0242\u1c0c\u0001\u0000\u0000"+
"\u0000\u0244\u1c0f\u0001\u0000\u0000\u0000\u0246\u1c14\u0001\u0000\u0000"+
"\u0000\u0248\u1c1c\u0001\u0000\u0000\u0000\u024a\u1c22\u0001\u0000\u0000"+
"\u0000\u024c\u1c26\u0001\u0000\u0000\u0000\u024e\u1c2f\u0001\u0000\u0000"+
"\u0000\u0250\u1c31\u0001\u0000\u0000\u0000\u0252\u1c39\u0001\u0000\u0000"+
"\u0000\u0254\u1c41\u0001\u0000\u0000\u0000\u0256\u1c46\u0001\u0000\u0000"+
"\u0000\u0258\u1c4e\u0001\u0000\u0000\u0000\u025a\u1c99\u0001\u0000\u0000"+
"\u0000\u025c\u1ca1\u0001\u0000\u0000\u0000\u025e\u1cb8\u0001\u0000\u0000"+
"\u0000\u0260\u1cc4\u0001\u0000\u0000\u0000\u0262\u1ccc\u0001\u0000\u0000"+
"\u0000\u0264\u1cda\u0001\u0000\u0000\u0000\u0266\u1ce8\u0001\u0000\u0000"+
"\u0000\u0268\u1cf1\u0001\u0000\u0000\u0000\u026a\u1d0c\u0001\u0000\u0000"+
"\u0000\u026c\u1d1e\u0001\u0000\u0000\u0000\u026e\u1d20\u0001\u0000\u0000"+
"\u0000\u0270\u1d28\u0001\u0000\u0000\u0000\u0272\u1d32\u0001\u0000\u0000"+
"\u0000\u0274\u1d34\u0001\u0000\u0000\u0000\u0276\u1d40\u0001\u0000\u0000"+
"\u0000\u0278\u1d49\u0001\u0000\u0000\u0000\u027a\u1d50\u0001\u0000\u0000"+
"\u0000\u027c\u1d5a\u0001\u0000\u0000\u0000\u027e\u1d6c\u0001\u0000\u0000"+
"\u0000\u0280\u1d84\u0001\u0000\u0000\u0000\u0282\u1d97\u0001\u0000\u0000"+
"\u0000\u0284\u1da7\u0001\u0000\u0000\u0000\u0286\u1de5\u0001\u0000\u0000"+
"\u0000\u0288\u1deb\u0001\u0000\u0000\u0000\u028a\u1e6f\u0001\u0000\u0000"+
"\u0000\u028c\u1e93\u0001\u0000\u0000\u0000\u028e\u1e95\u0001\u0000\u0000"+
"\u0000\u0290\u1eb8\u0001\u0000\u0000\u0000\u0292\u1ecc\u0001\u0000\u0000"+
"\u0000\u0294\u1ece\u0001\u0000\u0000\u0000\u0296\u1ee3\u0001\u0000\u0000"+
"\u0000\u0298\u1ee5\u0001\u0000\u0000\u0000\u029a\u1eee\u0001\u0000\u0000"+
"\u0000\u029c\u1ef0\u0001\u0000\u0000\u0000\u029e\u1f05\u0001\u0000\u0000"+
"\u0000\u02a0\u1f3a\u0001\u0000\u0000\u0000\u02a2\u1f3c\u0001\u0000\u0000"+
"\u0000\u02a4\u1f3e\u0001\u0000\u0000\u0000\u02a6\u1f40\u0001\u0000\u0000"+
"\u0000\u02a8\u1f45\u0001\u0000\u0000\u0000\u02aa\u1f49\u0001\u0000\u0000"+
"\u0000\u02ac\u1f4b\u0001\u0000\u0000\u0000\u02ae\u1f80\u0001\u0000\u0000"+
"\u0000\u02b0\u1fa1\u0001\u0000\u0000\u0000\u02b2\u1fa3\u0001\u0000\u0000"+
"\u0000\u02b4\u1fab\u0001\u0000\u0000\u0000\u02b6\u1fc3\u0001\u0000\u0000"+
"\u0000\u02b8\u1fc5\u0001\u0000\u0000\u0000\u02ba\u1fce\u0001\u0000\u0000"+
"\u0000\u02bc\u1fd6\u0001\u0000\u0000\u0000\u02be\u1fd8\u0001\u0000\u0000"+
"\u0000\u02c0\u1fdb\u0001\u0000\u0000\u0000\u02c2\u1fe9\u0001\u0000\u0000"+
"\u0000\u02c4\u1ff5\u0001\u0000\u0000\u0000\u02c6\u1ff7\u0001\u0000\u0000"+
"\u0000\u02c8\u2001\u0001\u0000\u0000\u0000\u02ca\u2003\u0001\u0000\u0000"+
"\u0000\u02cc\u2008\u0001\u0000\u0000\u0000\u02ce\u200a\u0001\u0000\u0000"+
"\u0000\u02d0\u2014\u0001\u0000\u0000\u0000\u02d2\u2016\u0001\u0000\u0000"+
"\u0000\u02d4\u02d5\u0003\u0002\u0001\u0000\u02d5\u02d6\u0005\u0000\u0000"+
"\u0001\u02d6\u0001\u0001\u0000\u0000\u0000\u02d7\u02da\u0003\u0004\u0002"+
"\u0000\u02d8\u02da\u0003\u000e\u0007\u0000\u02d9\u02d7\u0001\u0000\u0000"+
"\u0000\u02d9\u02d8\u0001\u0000\u0000\u0000\u02da\u02dc\u0001\u0000\u0000"+
"\u0000\u02db\u02dd\u00059\u0000\u0000\u02dc\u02db\u0001\u0000\u0000\u0000"+
"\u02dc\u02dd\u0001\u0000\u0000\u0000\u02dd\u02df\u0001\u0000\u0000\u0000"+
"\u02de\u02d9\u0001\u0000\u0000\u0000\u02df\u02e0\u0001\u0000\u0000\u0000"+
"\u02e0\u02de\u0001\u0000\u0000\u0000\u02e0\u02e1\u0001\u0000\u0000\u0000"+
"\u02e1\u0003\u0001\u0000\u0000\u0000\u02e2\u02e4\u00030\u0018\u0000\u02e3"+
"\u02e2\u0001\u0000\u0000\u0000\u02e3\u02e4\u0001\u0000\u0000\u0000\u02e4"+
"\u02e5\u0001\u0000\u0000\u0000\u02e5\u02e6\u0005\u00db\u0000\u0000\u02e6"+
"\u02e8\u0003\u0002\u0001\u0000\u02e7\u02e9\u0003\u0012\t\u0000\u02e8\u02e7"+
"\u0001\u0000\u0000\u0000\u02e8\u02e9\u0001\u0000\u0000\u0000\u02e9\u02ea"+
"\u0001\u0000\u0000\u0000\u02ea\u02eb\u0003\b\u0004\u0000\u02eb\u0005\u0001"+
"\u0000\u0000\u0000\u02ec\u02ed\u0005\u00db\u0000\u0000\u02ed\u02ef\u0003"+
"\u0002\u0001\u0000\u02ee\u02f0\u0003\u0012\t\u0000\u02ef\u02ee\u0001\u0000"+
"\u0000\u0000\u02ef\u02f0\u0001\u0000\u0000\u0000\u02f0\u02f1\u0001\u0000"+
"\u0000\u0000\u02f1\u02f2\u0003\b\u0004\u0000\u02f2\u02f8\u0001\u0000\u0000"+
"\u0000\u02f3\u02f5\u0003\u000e\u0007\u0000\u02f4\u02f6\u0005\u00b5\u0000"+
"\u0000\u02f5\u02f4\u0001\u0000\u0000\u0000\u02f5\u02f6\u0001\u0000\u0000"+
"\u0000\u02f6\u02f8\u0001\u0000\u0000\u0000\u02f7\u02ec\u0001\u0000\u0000"+
"\u0000\u02f7\u02f3\u0001\u0000\u0000\u0000\u02f8\u0007\u0001\u0000\u0000"+
"\u0000\u02f9\u02fa\u0004\u0004\u0000\u0000\u02fa\u02fb\u0005\u014f\u0000"+
"\u0000\u02fb\t\u0001\u0000\u0000\u0000\u02fc\u0306\u0003\u0004\u0002\u0000"+
"\u02fd\u02ff\u0003\u000e\u0007\u0000\u02fe\u02fd\u0001\u0000\u0000\u0000"+
"\u02ff\u0300\u0001\u0000\u0000\u0000\u0300\u02fe\u0001\u0000\u0000\u0000"+
"\u0300\u0301\u0001\u0000\u0000\u0000\u0301\u0303\u0001\u0000\u0000\u0000"+
"\u0302\u0304\u00059\u0000\u0000\u0303\u0302\u0001\u0000\u0000\u0000\u0303"+
"\u0304\u0001\u0000\u0000\u0000\u0304\u0306\u0001\u0000\u0000\u0000\u0305"+
"\u02fc\u0001\u0000\u0000\u0000\u0305\u02fe\u0001\u0000\u0000\u0000\u0306"+
"\u000b\u0001\u0000\u0000\u0000\u0307\u0308\u0003\u0112\u0089\u0000\u0308"+
"\r\u0001\u0000\u0000\u0000\u0309\u0333\u0003\f\u0006\u0000\u030a\u0333"+
"\u0003\u001a\r\u0000\u030b\u0333\u0003&\u0013\u0000\u030c\u0333\u0003"+
"(\u0014\u0000\u030d\u0333\u0003*\u0015\u0000\u030e\u0333\u0003,\u0016"+
"\u0000\u030f\u0333\u0003\u0090H\u0000\u0310\u0333\u0003J%\u0000\u0311"+
"\u0333\u0003N\'\u0000\u0312\u0333\u0003T*\u0000\u0313\u0333\u0003Z-\u0000"+
"\u0314\u0333\u0003.\u0017\u0000\u0315\u0333\u0003\\.\u0000\u0316\u0333"+
"\u0003^/\u0000\u0317\u0333\u0003`0\u0000\u0318\u0333\u0003b1\u0000\u0319"+
"\u0333\u0003l6\u0000\u031a\u0333\u0003|>\u0000\u031b\u0333\u0003\u008c"+
"F\u0000\u031c\u0333\u0003\u00aeW\u0000\u031d\u0333\u0003\u00b0X\u0000"+
"\u031e\u0333\u0003n7\u0000\u031f\u0333\u0003z=\u0000\u0320\u0333\u0003"+
"~?\u0000\u0321\u0333\u0003\u0086C\u0000\u0322\u0333\u0003\u0088D\u0000"+
"\u0323\u0333\u0003\u008aE\u0000\u0324\u0333\u0003\u0092I\u0000\u0325\u0333"+
"\u0003\u0094J\u0000\u0326\u0333\u0003\u0096K\u0000\u0327\u0333\u0003\u0098"+
"L\u0000\u0328\u0333\u0003\u009aM\u0000\u0329\u0333\u0003\u00a6S\u0000"+
"\u032a\u0333\u0003\u00a8T\u0000\u032b\u0333\u0003\u00aaU\u0000\u032c\u0333"+
"\u0003\u00acV\u0000\u032d\u0333\u0003\u00b2Y\u0000\u032e\u0333\u0003\u00ee"+
"w\u0000\u032f\u0333\u0003\u0016\u000b\u0000\u0330\u0333\u0003\u0018\f"+
"\u0000\u0331\u0333\u0003\u0010\b\u0000\u0332\u0309\u0001\u0000\u0000\u0000"+
"\u0332\u030a\u0001\u0000\u0000\u0000\u0332\u030b\u0001\u0000\u0000\u0000"+
"\u0332\u030c\u0001\u0000\u0000\u0000\u0332\u030d\u0001\u0000\u0000\u0000"+
"\u0332\u030e\u0001\u0000\u0000\u0000\u0332\u030f\u0001\u0000\u0000\u0000"+
"\u0332\u0310\u0001\u0000\u0000\u0000\u0332\u0311\u0001\u0000\u0000\u0000"+
"\u0332\u0312\u0001\u0000\u0000\u0000\u0332\u0313\u0001\u0000\u0000\u0000"+
"\u0332\u0314\u0001\u0000\u0000\u0000\u0332\u0315\u0001\u0000\u0000\u0000"+
"\u0332\u0316\u0001\u0000\u0000\u0000\u0332\u0317\u0001\u0000\u0000\u0000"+
"\u0332\u0318\u0001\u0000\u0000\u0000\u0332\u0319\u0001\u0000\u0000\u0000"+
"\u0332\u031a\u0001\u0000\u0000\u0000\u0332\u031b\u0001\u0000\u0000\u0000";
private static final String _serializedATNSegment1 =
"\u0332\u031c\u0001\u0000\u0000\u0000\u0332\u031d\u0001\u0000\u0000\u0000"+
"\u0332\u031e\u0001\u0000\u0000\u0000\u0332\u031f\u0001\u0000\u0000\u0000"+
"\u0332\u0320\u0001\u0000\u0000\u0000\u0332\u0321\u0001\u0000\u0000\u0000"+
"\u0332\u0322\u0001\u0000\u0000\u0000\u0332\u0323\u0001\u0000\u0000\u0000"+
"\u0332\u0324\u0001\u0000\u0000\u0000\u0332\u0325\u0001\u0000\u0000\u0000"+
"\u0332\u0326\u0001\u0000\u0000\u0000\u0332\u0327\u0001\u0000\u0000\u0000"+
"\u0332\u0328\u0001\u0000\u0000\u0000\u0332\u0329\u0001\u0000\u0000\u0000"+
"\u0332\u032a\u0001\u0000\u0000\u0000\u0332\u032b\u0001\u0000\u0000\u0000"+
"\u0332\u032c\u0001\u0000\u0000\u0000\u0332\u032d\u0001\u0000\u0000\u0000"+
"\u0332\u032e\u0001\u0000\u0000\u0000\u0332\u032f\u0001\u0000\u0000\u0000"+
"\u0332\u0330\u0001\u0000\u0000\u0000\u0332\u0331\u0001\u0000\u0000\u0000"+
"\u0333\u000f\u0001\u0000\u0000\u0000\u0334\u0335\u0007\u0000\u0000\u0000"+
"\u0335\u0011\u0001\u0000\u0000\u0000\u0336\u0338\u00051\u0000\u0000\u0337"+
"\u0339\u0003\u0014\n\u0000\u0338\u0337\u0001\u0000\u0000\u0000\u0339\u033a"+
"\u0001\u0000\u0000\u0000\u033a\u0338\u0001\u0000\u0000\u0000\u033a\u033b"+
"\u0001\u0000\u0000\u0000\u033b\u0013\u0001\u0000\u0000\u0000\u033c\u033d"+
"\u0005\u02a7\u0000\u0000\u033d\u033e\u0005\u02d3\u0000\u0000\u033e\u033f"+
"\u0005\u027a\u0000\u0000\u033f\u0340\u0003\u0002\u0001\u0000\u0340\u0341"+
"\b\u0001\u0000\u0000\u0341\u0015\u0001\u0000\u0000\u0000\u0342\u0343\u0005"+
"\u01e8\u0000\u0000\u0343\u0017\u0001\u0000\u0000\u0000\u0344\u0345\u0004"+
"\f\u0001\u0000\u0345\u0346\u0003\u00c2a\u0000\u0346\u0019\u0001\u0000"+
"\u0000\u0000\u0347\u0348\u0005\u0250\u0000\u0000\u0348\u0355\u0003\u009c"+
"N\u0000\u0349\u034b\u0005\u0250\u0000\u0000\u034a\u0349\u0001\u0000\u0000"+
"\u0000\u034a\u034b\u0001\u0000\u0000\u0000\u034b\u034c\u0001\u0000\u0000"+
"\u0000\u034c\u0351\u0003\u001c\u000e\u0000\u034d\u034e\u0005\u00b8\u0000"+
"\u0000\u034e\u0350\u0003\u001c\u000e\u0000\u034f\u034d\u0001\u0000\u0000"+
"\u0000\u0350\u0353\u0001\u0000\u0000\u0000\u0351\u034f\u0001\u0000\u0000"+
"\u0000\u0351\u0352\u0001\u0000\u0000\u0000\u0352\u0355\u0001\u0000\u0000"+
"\u0000\u0353\u0351\u0001\u0000\u0000\u0000\u0354\u0347\u0001\u0000\u0000"+
"\u0000\u0354\u034a\u0001\u0000\u0000\u0000\u0355\u001b\u0001\u0000\u0000"+
"\u0000\u0356\u035b\u0003\u001e\u000f\u0000\u0357\u035b\u0003\"\u0011\u0000"+
"\u0358\u035b\u0003$\u0012\u0000\u0359\u035b\u0003 \u0010\u0000\u035a\u0356"+
"\u0001\u0000\u0000\u0000\u035a\u0357\u0001\u0000\u0000\u0000\u035a\u0358"+
"\u0001\u0000\u0000\u0000\u035a\u0359\u0001\u0000\u0000\u0000\u035b\u001d"+
"\u0001\u0000\u0000\u0000\u035c\u035e\u0003\u00fa}\u0000\u035d\u035f\u0005"+
"\u02c3\u0000\u0000\u035e\u035d\u0001\u0000\u0000\u0000\u035e\u035f\u0001"+
"\u0000\u0000\u0000\u035f\u0360\u0001\u0000\u0000\u0000\u0360\u0361\u0005"+
"\u02b0\u0000\u0000\u0361\u0362\u0003\u00c2a\u0000\u0362\u036d\u0001\u0000"+
"\u0000\u0000\u0363\u0364\u0005\u00b6\u0000\u0000\u0364\u0365\u0003\u00fa"+
"}\u0000\u0365\u0367\u0005\u00b7\u0000\u0000\u0366\u0368\u0005\u02c3\u0000"+
"\u0000\u0367\u0366\u0001\u0000\u0000\u0000\u0367\u0368\u0001\u0000\u0000"+
"\u0000\u0368\u0369\u0001\u0000\u0000\u0000\u0369\u036a\u0005\u02b0\u0000"+
"\u0000\u036a\u036b\u0003\u00c2a\u0000\u036b\u036d\u0001\u0000\u0000\u0000"+
"\u036c\u035c\u0001\u0000\u0000\u0000\u036c\u0363\u0001\u0000\u0000\u0000"+
"\u036d\u001f\u0001\u0000\u0000\u0000\u036e\u036f\u0003\u00e2q\u0000\u036f"+
"\u0370\u0005\u02c3\u0000\u0000\u0370\u0371\u0005\u02b0\u0000\u0000\u0371"+
"\u0372\u0003\u00c2a\u0000\u0372!\u0001\u0000\u0000\u0000\u0373\u0374\u0005"+
"\u00b6\u0000\u0000\u0374\u0379\u0003\u00fa}\u0000\u0375\u0376\u0005\u00b8"+
"\u0000\u0000\u0376\u0378\u0003\u00fa}\u0000\u0377\u0375\u0001\u0000\u0000"+
"\u0000\u0378\u037b\u0001\u0000\u0000\u0000\u0379\u0377\u0001\u0000\u0000"+
"\u0000\u0379\u037a\u0001\u0000\u0000\u0000\u037a\u037c\u0001\u0000\u0000"+
"\u0000\u037b\u0379\u0001\u0000\u0000\u0000\u037c\u037e\u0005\u00b7\u0000"+
"\u0000\u037d\u037f\u0005\u02c3\u0000\u0000\u037e\u037d\u0001\u0000\u0000"+
"\u0000\u037e\u037f\u0001\u0000\u0000\u0000\u037f\u0380\u0001\u0000\u0000"+
"\u0000\u0380\u0381\u0005\u02b0\u0000\u0000\u0381\u0382\u0005\u00b6\u0000"+
"\u0000\u0382\u0387\u0003\u00c2a\u0000\u0383\u0384\u0005\u00b8\u0000\u0000"+
"\u0384\u0386\u0003\u00c2a\u0000\u0385\u0383\u0001\u0000\u0000\u0000\u0386"+
"\u0389\u0001\u0000\u0000\u0000\u0387\u0385\u0001\u0000\u0000\u0000\u0387"+
"\u0388\u0001\u0000\u0000\u0000\u0388\u038a\u0001\u0000\u0000\u0000\u0389"+
"\u0387\u0001\u0000\u0000\u0000\u038a\u038b\u0005\u00b7\u0000\u0000\u038b"+
"#\u0001\u0000\u0000\u0000\u038c\u0399\u0003\u00fa}\u0000\u038d\u038e\u0005"+
"\u00b6\u0000\u0000\u038e\u0393\u0003\u00fa}\u0000\u038f\u0390\u0005\u00b8"+
"\u0000\u0000\u0390\u0392\u0003\u00fa}\u0000\u0391\u038f\u0001\u0000\u0000"+
"\u0000\u0392\u0395\u0001\u0000\u0000\u0000\u0393\u0391\u0001\u0000\u0000"+
"\u0000\u0393\u0394\u0001\u0000\u0000\u0000\u0394\u0396\u0001\u0000\u0000"+
"\u0000\u0395\u0393\u0001\u0000\u0000\u0000\u0396\u0397\u0005\u00b7\u0000"+
"\u0000\u0397\u0399\u0001\u0000\u0000\u0000\u0398\u038c\u0001\u0000\u0000"+
"\u0000\u0398\u038d\u0001\u0000\u0000\u0000\u0399\u039b\u0001\u0000\u0000"+
"\u0000\u039a\u039c\u0005\u02c3\u0000\u0000\u039b\u039a\u0001\u0000\u0000"+
"\u0000\u039b\u039c\u0001\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000"+
"\u0000\u039d\u039e\u0005\u02b0\u0000\u0000\u039e\u039f\u0005\u00b6\u0000"+
"\u0000\u039f\u03a0\u0003\u01f0\u00f8\u0000\u03a0\u03a1\u0005\u00b7\u0000"+
"\u0000\u03a1%\u0001\u0000\u0000\u0000\u03a2\u03a3\u0005\u0002\u0000\u0000"+
"\u03a3\u03a4\u0003\u00fa}\u0000\u03a4\u03a5\u0005 \u0000\u0000\u03a5\u03a9"+
"\u0005\u016d\u0000\u0000\u03a6\u03a7\u0005r\u0000\u0000\u03a7\u03aa\u0005"+
"\u0250\u0000\u0000\u03a8\u03aa\u0005\u0213\u0000\u0000\u03a9\u03a6\u0001"+
"\u0000\u0000\u0000\u03a9\u03a8\u0001\u0000\u0000\u0000\u03aa\u03ab\u0001"+
"\u0000\u0000\u0000\u03ab\u03ac\u0003\u00fa}\u0000\u03ac\'\u0001\u0000"+
"\u0000\u0000\u03ad\u03b0\u0005\u0005\u0000\u0000\u03ae\u03af\u0005r\u0000"+
"\u0000\u03af\u03b1\u0005\u0250\u0000\u0000\u03b0\u03ae\u0001\u0000\u0000"+
"\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001\u0000\u0000"+
"\u0000\u03b2\u03b3\u0007\u0002\u0000\u0000\u03b3\u03b4\u0005\u00b6\u0000"+
"\u0000\u03b4\u03b9\u0003\u00fa}\u0000\u03b5\u03b6\u0005\u00b8\u0000\u0000"+
"\u03b6\u03b8\u0003\u00fa}\u0000\u03b7\u03b5\u0001\u0000\u0000\u0000\u03b8"+
"\u03bb\u0001\u0000\u0000\u0000\u03b9\u03b7\u0001\u0000\u0000\u0000\u03b9"+
"\u03ba\u0001\u0000\u0000\u0000\u03ba\u03bc\u0001\u0000\u0000\u0000\u03bb"+
"\u03b9\u0001\u0000\u0000\u0000\u03bc\u03bd\u0005\u00b7\u0000\u0000\u03bd"+
"\u03be\u0005\u02aa\u0000\u0000\u03be\u03bf\u0005\u0213\u0000\u0000\u03bf"+
"\u03c0\u0003\u00fa}\u0000\u03c0)\u0001\u0000\u0000\u0000\u03c1\u03c2\u0005"+
"\r\u0000\u0000\u03c2+\u0001\u0000\u0000\u0000\u03c3\u03c7\u0005\u00f4"+
"\u0000\u0000\u03c4\u03c8\u0003\u00e4r\u0000\u03c5\u03c8\u0003\u00e2q\u0000"+
"\u03c6\u03c8\u0003\u0250\u0128\u0000\u03c7\u03c4\u0001\u0000\u0000\u0000"+
"\u03c7\u03c5\u0001\u0000\u0000\u0000\u03c7\u03c6\u0001\u0000\u0000\u0000"+
"\u03c8-\u0001\u0000\u0000\u0000\u03c9\u03ca\u0005#\u0000\u0000\u03ca\u03cf"+
"\u00034\u001a\u0000\u03cb\u03cc\u0005\u00b8\u0000\u0000\u03cc\u03ce\u0003"+
"4\u001a\u0000\u03cd\u03cb\u0001\u0000\u0000\u0000\u03ce\u03d1\u0001\u0000"+
"\u0000\u0000\u03cf\u03cd\u0001\u0000\u0000\u0000\u03cf\u03d0\u0001\u0000"+
"\u0000\u0000\u03d0/\u0001\u0000\u0000\u0000\u03d1\u03cf\u0001\u0000\u0000"+
"\u0000\u03d2\u03d3\u0005#\u0000\u0000\u03d3\u03d4\u00034\u001a\u0000\u03d4"+
"\u03da\u0005\u00b5\u0000\u0000\u03d5\u03d6\u00034\u001a\u0000\u03d6\u03d7"+
"\u0005\u00b5\u0000\u0000\u03d7\u03d9\u0001\u0000\u0000\u0000\u03d8\u03d5"+
"\u0001\u0000\u0000\u0000\u03d9\u03dc\u0001\u0000\u0000\u0000\u03da\u03d8"+
"\u0001\u0000\u0000\u0000\u03da\u03db\u0001\u0000\u0000\u0000\u03db1\u0001"+
"\u0000\u0000\u0000\u03dc\u03da\u0001\u0000\u0000\u0000\u03dd\u03de\u0003"+
"4\u001a\u0000\u03de\u03e4\u0005\u00b5\u0000\u0000\u03df\u03e0\u00034\u001a"+
"\u0000\u03e0\u03e1\u0005\u00b5\u0000\u0000\u03e1\u03e3\u0001\u0000\u0000"+
"\u0000\u03e2\u03df\u0001\u0000\u0000\u0000\u03e3\u03e6\u0001\u0000\u0000"+
"\u0000\u03e4\u03e2\u0001\u0000\u0000\u0000\u03e4\u03e5\u0001\u0000\u0000"+
"\u0000\u03e53\u0001\u0000\u0000\u0000\u03e6\u03e4\u0001\u0000\u0000\u0000"+
"\u03e7\u03ec\u0003:\u001d\u0000\u03e8\u03ec\u00038\u001c\u0000\u03e9\u03ec"+
"\u0003@ \u0000\u03ea\u03ec\u00036\u001b\u0000\u03eb\u03e7\u0001\u0000"+
"\u0000\u0000\u03eb\u03e8\u0001\u0000\u0000\u0000\u03eb\u03e9\u0001\u0000"+
"\u0000\u0000\u03eb\u03ea\u0001\u0000\u0000\u0000\u03ec5\u0001\u0000\u0000"+
"\u0000\u03ed\u03f2\u0003\u00fa}\u0000\u03ee\u03ef\u0005\u00b8\u0000\u0000"+
"\u03ef\u03f1\u0003\u00fa}\u0000\u03f0\u03ee\u0001\u0000\u0000\u0000\u03f1"+
"\u03f4\u0001\u0000\u0000\u0000\u03f2\u03f0\u0001\u0000\u0000\u0000\u03f2"+
"\u03f3\u0001\u0000\u0000\u0000\u03f3\u03f6\u0001\u0000\u0000\u0000\u03f4"+
"\u03f2\u0001\u0000\u0000\u0000\u03f5\u03f7\u0005\u00d1\u0000\u0000\u03f6"+
"\u03f5\u0001\u0000\u0000\u0000\u03f6\u03f7\u0001\u0000\u0000\u0000\u03f7"+
"\u03f8\u0001\u0000\u0000\u0000\u03f8\u03fa\u0003B!\u0000\u03f9\u03fb\u0003"+
"D\"\u0000\u03fa\u03f9\u0001\u0000\u0000\u0000\u03fa\u03fb\u0001\u0000"+
"\u0000\u0000\u03fb\u03ff\u0001\u0000\u0000\u0000\u03fc\u03fe\u0003F#\u0000"+
"\u03fd\u03fc\u0001\u0000\u0000\u0000\u03fe\u0401\u0001\u0000\u0000\u0000"+
"\u03ff\u03fd\u0001\u0000\u0000\u0000\u03ff\u0400\u0001\u0000\u0000\u0000"+
"\u0400\u0403\u0001\u0000\u0000\u0000\u0401\u03ff\u0001\u0000\u0000\u0000"+
"\u0402\u0404\u0003H$\u0000\u0403\u0402\u0001\u0000\u0000\u0000\u0403\u0404"+
"\u0001\u0000\u0000\u0000\u0404\u0411\u0001\u0000\u0000\u0000\u0405\u0406"+
"\u0003\u00fa}\u0000\u0406\u0408\u0005\u001a\u0000\u0000\u0407\u0409\u0005"+
"\u00d1\u0000\u0000\u0408\u0407\u0001\u0000\u0000\u0000\u0408\u0409\u0001"+
"\u0000\u0000\u0000\u0409\u040a\u0001\u0000\u0000\u0000\u040a\u040c\u0003"+
"B!\u0000\u040b\u040d\u0003D\"\u0000\u040c\u040b\u0001\u0000\u0000\u0000"+
"\u040c\u040d\u0001\u0000\u0000\u0000\u040d\u040e\u0001\u0000\u0000\u0000"+
"\u040e\u040f\u0003H$\u0000\u040f\u0411\u0001\u0000\u0000\u0000\u0410\u03ed"+
"\u0001\u0000\u0000\u0000\u0410\u0405\u0001\u0000\u0000\u0000\u04117\u0001"+
"\u0000\u0000\u0000\u0412\u0413\u0003\u00fa}\u0000\u0413\u0414\u0005\u0019"+
"\u0000\u0000\u04149\u0001\u0000\u0000\u0000\u0415\u0416\u0005 \u0000\u0000"+
"\u0416\u041b\u0003\u00fa}\u0000\u0417\u0418\u0003\u00fa}\u0000\u0418\u0419"+
"\u0005 \u0000\u0000\u0419\u041b\u0001\u0000\u0000\u0000\u041a\u0415\u0001"+
"\u0000\u0000\u0000\u041a\u0417\u0001\u0000\u0000\u0000\u041b\u041e\u0001"+
"\u0000\u0000\u0000\u041c\u041f\u0003<\u001e\u0000\u041d\u041f\u0003>\u001f"+
"\u0000\u041e\u041c\u0001\u0000\u0000\u0000\u041e\u041d\u0001\u0000\u0000"+
"\u0000\u041e\u041f\u0001\u0000\u0000\u0000\u041f\u0420\u0001\u0000\u0000"+
"\u0000\u0420\u0423\u0007\u0003\u0000\u0000\u0421\u0424\u0003\u01f0\u00f8"+
"\u0000\u0422\u0424\u0003\u00c2a\u0000\u0423\u0421\u0001\u0000\u0000\u0000"+
"\u0423\u0422\u0001\u0000\u0000\u0000\u0424;\u0001\u0000\u0000\u0000\u0425"+
"\u0426\u0005\u02aa\u0000\u0000\u0426\u0428\u0005t\u0000\u0000\u0427\u0429"+
"\u0005\u01ee\u0000\u0000\u0428\u0427\u0001\u0000\u0000\u0000\u0428\u0429"+
"\u0001\u0000\u0000\u0000\u0429\u042c\u0001\u0000\u0000\u0000\u042a\u042b"+
"\u0005\u027e\u0000\u0000\u042b\u042d\u0007\u0004\u0000\u0000\u042c\u042a"+
"\u0001\u0000\u0000\u0000\u042c\u042d\u0001\u0000\u0000\u0000\u042d=\u0001"+
"\u0000\u0000\u0000\u042e\u042f\u0005\u009c\u0000\u0000\u042f\u0430\u0005"+
"t\u0000\u0000\u0430?\u0001\u0000\u0000\u0000\u0431\u0432\u0007\u0005\u0000"+
"\u0000\u0432\u0433\u0005:\u0000\u0000\u0433\u0439\u0005\u016d\u0000\u0000"+
"\u0434\u043a\u0005\u0087\u0000\u0000\u0435\u043a\u0005\u008a\u0000\u0000"+
"\u0436\u0437\u0005\u01e7\u0000\u0000\u0437\u043a\u00057\u0000\u0000\u0438"+
"\u043a\u0003\u00fa}\u0000\u0439\u0434\u0001\u0000\u0000\u0000\u0439\u0435"+
"\u0001\u0000\u0000\u0000\u0439\u0436\u0001\u0000\u0000\u0000\u0439\u0438"+
"\u0001\u0000\u0000\u0000\u043a\u043b\u0001\u0000\u0000\u0000\u043b\u043c"+
"\u0003\u0006\u0003\u0000\u043cA\u0001\u0000\u0000\u0000\u043d\u046b\u0005"+
"\u00fb\u0000\u0000\u043e\u046b\u0005\u00de\u0000\u0000\u043f\u046b\u0005"+
"\b\u0000\u0000\u0440\u046b\u0005\t\u0000\u0000\u0441\u046b\u0005\n\u0000"+
"\u0000\u0442\u046b\u0005\u000b\u0000\u0000\u0443\u046b\u0005\u0127\u0000"+
"\u0000\u0444\u046b\u0005\u0128\u0000\u0000\u0445\u046b\u0005\"\u0000\u0000"+
"\u0446\u046b\u0005\u012e\u0000\u0000\u0447\u0449\u0005\u0143\u0000\u0000"+
"\u0448\u044a\u0005h\u0000\u0000\u0449\u0448\u0001\u0000\u0000\u0000\u0449"+
"\u044a\u0001\u0000\u0000\u0000\u044a\u046b\u0001\u0000\u0000\u0000\u044b"+
"\u046b\u0005\u016a\u0000\u0000\u044c\u046b\u0005\u0199\u0000\u0000\u044d"+
"\u046b\u0005@\u0000\u0000\u044e\u046b\u0005A\u0000\u0000\u044f\u046b\u0005"+
"B\u0000\u0000\u0450\u046b\u0005\u019a\u0000\u0000\u0451\u046b\u0005V\u0000"+
"\u0000\u0452\u046b\u0005X\u0000\u0000\u0453\u046b\u0005_\u0000\u0000\u0454"+
"\u046b\u0005^\u0000\u0000\u0455\u046b\u0005g\u0000\u0000\u0456\u046b\u0005"+
"\u021f\u0000\u0000\u0457\u0458\u0005s\u0000\u0000\u0458\u046b\u0005\u0099"+
"\u0000\u0000\u0459\u046b\u0005\u0083\u0000\u0000\u045a\u046b\u0005\u0082"+
"\u0000\u0000\u045b\u046b\u0005\u0084\u0000\u0000\u045c\u046b\u0005\u0257"+
"\u0000\u0000\u045d\u046b\u0005\u0085\u0000\u0000\u045e\u046b\u0005\u0267"+
"\u0000\u0000\u045f\u046b\u0005\u0091\u0000\u0000\u0460\u046b\u0005\u027c"+
"\u0000\u0000\u0461\u046b\u0005\u027d\u0000\u0000\u0462\u046b\u0005\u029a"+
"\u0000\u0000\u0463\u046b\u0005\u0098\u0000\u0000\u0464\u046b\u0005\u009e"+
"\u0000\u0000\u0465\u0468\u0003\u00fc~\u0000\u0466\u0467\u0005\u02bb\u0000"+
"\u0000\u0467\u0469\u0007\u0006\u0000\u0000\u0468\u0466\u0001\u0000\u0000"+
"\u0000\u0468\u0469\u0001\u0000\u0000\u0000\u0469\u046b\u0001\u0000\u0000"+
"\u0000\u046a\u043d\u0001\u0000\u0000\u0000\u046a\u043e\u0001\u0000\u0000"+
"\u0000\u046a\u043f\u0001\u0000\u0000\u0000\u046a\u0440\u0001\u0000\u0000"+
"\u0000\u046a\u0441\u0001\u0000\u0000\u0000\u046a\u0442\u0001\u0000\u0000"+
"\u0000\u046a\u0443\u0001\u0000\u0000\u0000\u046a\u0444\u0001\u0000\u0000"+
"\u0000\u046a\u0445\u0001\u0000\u0000\u0000\u046a\u0446\u0001\u0000\u0000"+
"\u0000\u046a\u0447\u0001\u0000\u0000\u0000\u046a\u044b\u0001\u0000\u0000"+
"\u0000\u046a\u044c\u0001\u0000\u0000\u0000\u046a\u044d\u0001\u0000\u0000"+
"\u0000\u046a\u044e\u0001\u0000\u0000\u0000\u046a\u044f\u0001\u0000\u0000"+
"\u0000\u046a\u0450\u0001\u0000\u0000\u0000\u046a\u0451\u0001\u0000\u0000"+
"\u0000\u046a\u0452\u0001\u0000\u0000\u0000\u046a\u0453\u0001\u0000\u0000"+
"\u0000\u046a\u0454\u0001\u0000\u0000\u0000\u046a\u0455\u0001\u0000\u0000"+
"\u0000\u046a\u0456\u0001\u0000\u0000\u0000\u046a\u0457\u0001\u0000\u0000"+
"\u0000\u046a\u0459\u0001\u0000\u0000\u0000\u046a\u045a\u0001\u0000\u0000"+
"\u0000\u046a\u045b\u0001\u0000\u0000\u0000\u046a\u045c\u0001\u0000\u0000"+
"\u0000\u046a\u045d\u0001\u0000\u0000\u0000\u046a\u045e\u0001\u0000\u0000"+
"\u0000\u046a\u045f\u0001\u0000\u0000\u0000\u046a\u0460\u0001\u0000\u0000"+
"\u0000\u046a\u0461\u0001\u0000\u0000\u0000\u046a\u0462\u0001\u0000\u0000"+
"\u0000\u046a\u0463\u0001\u0000\u0000\u0000\u046a\u0464\u0001\u0000\u0000"+
"\u0000\u046a\u0465\u0001\u0000\u0000\u0000\u046bC\u0001\u0000\u0000\u0000"+
"\u046c\u046d\u0005\u00b6\u0000\u0000\u046d\u046f\u0007\u0007\u0000\u0000"+
"\u046e\u0470\u0007\b\u0000\u0000\u046f\u046e\u0001\u0000\u0000\u0000\u046f"+
"\u0470\u0001\u0000\u0000\u0000\u0470\u0473\u0001\u0000\u0000\u0000\u0471"+
"\u0472\u0005\u00b8\u0000\u0000\u0472\u0474\u0005\u02cf\u0000\u0000\u0473"+
"\u0471\u0001\u0000\u0000\u0000\u0473\u0474\u0001\u0000\u0000\u0000\u0474"+
"\u0475\u0001\u0000\u0000\u0000\u0475\u0476\u0005\u00b7\u0000\u0000\u0476"+
"E\u0001\u0000\u0000\u0000\u0477\u0479\u0005\u01e7\u0000\u0000\u0478\u0477"+
"\u0001\u0000\u0000\u0000\u0478\u0479\u0001\u0000\u0000\u0000\u0479\u047a"+
"\u0001\u0000\u0000\u0000\u047a\u0483\u0005\u01e8\u0000\u0000\u047b\u047c"+
"\u0005\u00fb\u0000\u0000\u047c\u047d\u0005\u0250\u0000\u0000\u047d\u0483"+
"\u0003\u00fa}\u0000\u047e\u0480\u0005\u01e7\u0000\u0000\u047f\u047e\u0001"+
"\u0000\u0000\u0000\u047f\u0480\u0001\u0000\u0000\u0000\u0480\u0481\u0001"+
"\u0000\u0000\u0000\u0481\u0483\u0007\t\u0000\u0000\u0482\u0478\u0001\u0000"+
"\u0000\u0000\u0482\u047b\u0001\u0000\u0000\u0000\u0482\u047f\u0001\u0000"+
"\u0000\u0000\u0483G\u0001\u0000\u0000\u0000\u0484\u0486\u0005\u02c3\u0000"+
"\u0000\u0485\u0484\u0001\u0000\u0000\u0000\u0485\u0486\u0001\u0000\u0000"+
"\u0000\u0486\u0487\u0001\u0000\u0000\u0000\u0487\u0488\u0005\u02b0\u0000"+
"\u0000\u0488\u0491\u0003\u00c2a\u0000\u0489\u048b\u0005\u02aa\u0000\u0000"+
"\u048a\u0489\u0001\u0000\u0000\u0000\u048a\u048b\u0001\u0000\u0000\u0000"+
"\u048b\u048c\u0001\u0000\u0000\u0000\u048c\u048e\u0005\u0132\u0000\u0000"+
"\u048d\u048f\u0003\u00c2a\u0000\u048e\u048d\u0001\u0000\u0000\u0000\u048e"+
"\u048f\u0001\u0000\u0000\u0000\u048f\u0491\u0001\u0000\u0000\u0000\u0490"+
"\u0485\u0001\u0000\u0000\u0000\u0490\u048a\u0001\u0000\u0000\u0000\u0491"+
"I\u0001\u0000\u0000\u0000\u0492\u049a\u0005\u00c9\u0000\u0000\u0493\u0496"+
"\u0005\u0119\u0000\u0000\u0494\u0495\u0005\u01f1\u0000\u0000\u0495\u0497"+
"\u0005\u022b\u0000\u0000\u0496\u0494\u0001\u0000\u0000\u0000\u0496\u0497"+
"\u0001\u0000\u0000\u0000\u0497\u049a\u0001\u0000\u0000\u0000\u0498\u049a"+
"\u0005\u022b\u0000\u0000\u0499\u0492\u0001\u0000\u0000\u0000\u0499\u0493"+
"\u0001\u0000\u0000\u0000\u0499\u0498\u0001\u0000\u0000\u0000\u049a\u049b"+
"\u0001\u0000\u0000\u0000\u049b\u049c\u0005\u0176\u0000\u0000\u049c\u049e"+
"\u0003\u0250\u0128\u0000\u049d\u049f\u0003d2\u0000\u049e\u049d\u0001\u0000"+
"\u0000\u0000\u049e\u049f\u0001\u0000\u0000\u0000\u049f\u04a0\u0001\u0000"+
"\u0000\u0000\u04a0\u04a2\u0003L&\u0000\u04a1\u04a3\u0007\n\u0000\u0000"+
"\u04a2\u04a1\u0001\u0000\u0000\u0000\u04a2\u04a3\u0001\u0000\u0000\u0000"+
"\u04a3\u04a5\u0001\u0000\u0000\u0000\u04a4\u04a6\u00032\u0019\u0000\u04a5"+
"\u04a4\u0001\u0000\u0000\u0000\u04a5\u04a6\u0001\u0000\u0000\u0000\u04a6"+
"\u04a7\u0001\u0000\u0000\u0000\u04a7\u04a8\u0003\u0006\u0003\u0000\u04a8"+
"K\u0001\u0000\u0000\u0000\u04a9\u04aa\u0007\u000b\u0000\u0000\u04aa\u04ac"+
"\u0003B!\u0000\u04ab\u04ad\u0003D\"\u0000\u04ac\u04ab\u0001\u0000\u0000"+
"\u0000\u04ac\u04ad\u0001\u0000\u0000\u0000\u04adM\u0001\u0000\u0000\u0000"+
"\u04ae\u04b6\u0005\u00c9\u0000\u0000\u04af\u04b2\u0005\u0119\u0000\u0000"+
"\u04b0\u04b1\u0005\u01f1\u0000\u0000\u04b1\u04b3\u0005\u022b\u0000\u0000"+
"\u04b2\u04b0\u0001\u0000\u0000\u0000\u04b2\u04b3\u0001\u0000\u0000\u0000"+
"\u04b3\u04b6\u0001\u0000\u0000\u0000\u04b4\u04b6\u0005\u022b\u0000\u0000"+
"\u04b5\u04ae\u0001\u0000\u0000\u0000\u04b5\u04af\u0001\u0000\u0000\u0000"+
"\u04b5\u04b4\u0001\u0000\u0000\u0000\u04b6\u04b7\u0001\u0000\u0000\u0000"+
"\u04b7\u04b8\u0005d\u0000\u0000\u04b8\u04b9\u0003\u0250\u0128\u0000\u04b9"+
"\u04ba\u0007\n\u0000\u0000\u04ba\u04bb\u0003P(\u0000\u04bb\u04bf\u0005"+
"\u014f\u0000\u0000\u04bc\u04bd\u0003\u00fa}\u0000\u04bd\u04be\u0005\u00b5"+
"\u0000\u0000\u04be\u04c0\u0001\u0000\u0000\u0000\u04bf\u04bc\u0001\u0000"+
"\u0000\u0000\u04bf\u04c0\u0001\u0000\u0000\u0000\u04c0O\u0001\u0000\u0000"+
"\u0000\u04c1\u04c2\u0003R)\u0000\u04c2\u04c8\u0005\u00b5\u0000\u0000\u04c3"+
"\u04c4\u0003R)\u0000\u04c4\u04c5\u0005\u00b5\u0000\u0000\u04c5\u04c7\u0001"+
"\u0000\u0000\u0000\u04c6\u04c3\u0001\u0000\u0000\u0000\u04c7\u04ca\u0001"+
"\u0000\u0000\u0000\u04c8\u04c6\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001"+
"\u0000\u0000\u0000\u04c9Q\u0001\u0000\u0000\u0000\u04ca\u04c8\u0001\u0000"+
"\u0000\u0000\u04cb\u04d9\u00034\u001a\u0000\u04cc\u04cd\u0005\u0176\u0000"+
"\u0000\u04cd\u04cf\u0003\u00fa}\u0000\u04ce\u04d0\u0003d2\u0000\u04cf"+
"\u04ce\u0001\u0000\u0000\u0000\u04cf\u04d0\u0001\u0000\u0000\u0000\u04d0"+
"\u04d1\u0001\u0000\u0000\u0000\u04d1\u04d2\u0003L&\u0000\u04d2\u04d9\u0001"+
"\u0000\u0000\u0000\u04d3\u04d4\u0007\f\u0000\u0000\u04d4\u04d6\u0003\u00fa"+
"}\u0000\u04d5\u04d7\u0003d2\u0000\u04d6\u04d5\u0001\u0000\u0000\u0000"+
"\u04d6\u04d7\u0001\u0000\u0000\u0000\u04d7\u04d9\u0001\u0000\u0000\u0000"+
"\u04d8\u04cb\u0001\u0000\u0000\u0000\u04d8\u04cc\u0001\u0000\u0000\u0000"+
"\u04d8\u04d3\u0001\u0000\u0000\u0000\u04d9S\u0001\u0000\u0000\u0000\u04da"+
"\u04e2\u0005\u00c9\u0000\u0000\u04db\u04de\u0005\u0119\u0000\u0000\u04dc"+
"\u04dd\u0005\u01f1\u0000\u0000\u04dd\u04df\u0005\u022b\u0000\u0000\u04de"+
"\u04dc\u0001\u0000\u0000\u0000\u04de\u04df\u0001\u0000\u0000\u0000\u04df"+
"\u04e2\u0001\u0000\u0000\u0000\u04e0\u04e2\u0005\u022b\u0000\u0000\u04e1"+
"\u04da\u0001\u0000\u0000\u0000\u04e1\u04db\u0001\u0000\u0000\u0000\u04e1"+
"\u04e0\u0001\u0000\u0000\u0000\u04e2\u04e3\u0001\u0000\u0000\u0000\u04e3"+
"\u04e4\u0005d\u0000\u0000\u04e4\u04e5\u0005\f\u0000\u0000\u04e5\u04e6"+
"\u0003\u0250\u0128\u0000\u04e6\u04e7\u0007\n\u0000\u0000\u04e7\u04e8\u0003"+
"V+\u0000\u04e8\u04ec\u0005\u014f\u0000\u0000\u04e9\u04ea\u0003\u00fa}"+
"\u0000\u04ea\u04eb\u0005\u00b5\u0000\u0000\u04eb\u04ed\u0001\u0000\u0000"+
"\u0000\u04ec\u04e9\u0001\u0000\u0000\u0000\u04ec\u04ed\u0001\u0000\u0000"+
"\u0000\u04edU\u0001\u0000\u0000\u0000\u04ee\u04ef\u0003X,\u0000\u04ef"+
"\u04f5\u0005\u00b5\u0000\u0000\u04f0\u04f1\u0003X,\u0000\u04f1\u04f2\u0005"+
"\u00b5\u0000\u0000\u04f2\u04f4\u0001\u0000\u0000\u0000\u04f3\u04f0\u0001"+
"\u0000\u0000\u0000\u04f4\u04f7\u0001\u0000\u0000\u0000\u04f5\u04f3\u0001"+
"\u0000\u0000\u0000\u04f5\u04f6\u0001\u0000\u0000\u0000\u04f6W\u0001\u0000"+
"\u0000\u0000\u04f7\u04f5\u0001\u0000\u0000\u0000\u04f8\u04fc\u00034\u001a"+
"\u0000\u04f9\u04fc\u0003J%\u0000\u04fa\u04fc\u0003Z-\u0000\u04fb\u04f8"+
"\u0001\u0000\u0000\u0000\u04fb\u04f9\u0001\u0000\u0000\u0000\u04fb\u04fa"+
"\u0001\u0000\u0000\u0000\u04fcY\u0001\u0000\u0000\u0000\u04fd\u0505\u0005"+
"\u00c9\u0000\u0000\u04fe\u0501\u0005\u0119\u0000\u0000\u04ff\u0500\u0005"+
"\u01f1\u0000\u0000\u0500\u0502\u0005\u022b\u0000\u0000\u0501\u04ff\u0001"+
"\u0000\u0000\u0000\u0501\u0502\u0001\u0000\u0000\u0000\u0502\u0505\u0001"+
"\u0000\u0000\u0000\u0503\u0505\u0005\u022b\u0000\u0000\u0504\u04fd\u0001"+
"\u0000\u0000\u0000\u0504\u04fe\u0001\u0000\u0000\u0000\u0504\u0503\u0001"+
"\u0000\u0000\u0000\u0505\u0506\u0001\u0000\u0000\u0000\u0506\u0507\u0007"+
"\f\u0000\u0000\u0507\u0509\u0003\u0250\u0128\u0000\u0508\u050a\u0003d"+
"2\u0000\u0509\u0508\u0001\u0000\u0000\u0000\u0509\u050a\u0001\u0000\u0000"+
"\u0000\u050a\u050c\u0001\u0000\u0000\u0000\u050b\u050d\u0003h4\u0000\u050c"+
"\u050b\u0001\u0000\u0000\u0000\u050c\u050d\u0001\u0000\u0000\u0000\u050d"+
"\u050f\u0001\u0000\u0000\u0000\u050e\u0510\u0007\n\u0000\u0000\u050f\u050e"+
"\u0001\u0000\u0000\u0000\u050f\u0510\u0001\u0000\u0000\u0000\u0510\u0512"+
"\u0001\u0000\u0000\u0000\u0511\u0513\u00032\u0019\u0000\u0512\u0511\u0001"+
"\u0000\u0000\u0000\u0512\u0513\u0001\u0000\u0000\u0000\u0513\u0515\u0001"+
"\u0000\u0000\u0000\u0514\u0516\u0003\u00b2Y\u0000\u0515\u0514\u0001\u0000"+
"\u0000\u0000\u0515\u0516\u0001\u0000\u0000\u0000\u0516\u0517\u0001\u0000"+
"\u0000\u0000\u0517\u051b\u0003\n\u0005\u0000\u0518\u0519\u0003\u00fa}"+
"\u0000\u0519\u051a\u0005\u00b5\u0000\u0000\u051a\u051c\u0001\u0000\u0000"+
"\u0000\u051b\u0518\u0001\u0000\u0000\u0000\u051b\u051c\u0001\u0000\u0000"+
"\u0000\u051c[\u0001\u0000\u0000\u0000\u051d\u051e\u0005\u0144\u0000\u0000"+
"\u051e\u0521\u0007\f\u0000\u0000\u051f\u0520\u0005\u018e\u0000\u0000\u0520"+
"\u0522\u0005\u015b\u0000\u0000\u0521\u051f\u0001\u0000\u0000\u0000\u0521"+
"\u0522\u0001\u0000\u0000\u0000\u0522\u0523\u0001\u0000\u0000\u0000\u0523"+
"\u0524\u0003\u0250\u0128\u0000\u0524]\u0001\u0000\u0000\u0000\u0525\u0526"+
"\u0005\u0254\u0000\u0000\u0526\u0527\u0005\u0213\u0000\u0000\u0527\u052b"+
"\u0005\u0262\u0000\u0000\u0528\u0529\u0005\u01b8\u0000\u0000\u0529\u052c"+
"\u0003\u0288\u0144\u0000\u052a\u052c\u0003\u0204\u0102\u0000\u052b\u0528"+
"\u0001\u0000\u0000\u0000\u052b\u052a\u0001\u0000\u0000\u0000\u052b\u052c"+
"\u0001\u0000\u0000\u0000\u052c_\u0001\u0000\u0000\u0000\u052d\u052e\u0005"+
"\u0254\u0000\u0000\u052e\u052f\u0005\u0119\u0000\u0000\u052f\u0530\u0005"+
"\u0213\u0000\u0000\u0530\u0531\u0003\u0250\u0128\u0000\u0531a\u0001\u0000"+
"\u0000\u0000\u0532\u0533\u0005\u0254\u0000\u0000\u0533\u0534\u0007\r\u0000"+
"\u0000\u0534\u0537\u0005\u010f\u0000\u0000\u0535\u0536\u0005\u01b8\u0000"+
"\u0000\u0536\u0538\u0003\u0288\u0144\u0000\u0537\u0535\u0001\u0000\u0000"+
"\u0000\u0537\u0538\u0001\u0000\u0000\u0000\u0538\u053b\u0001\u0000\u0000"+
"\u0000\u0539\u053a\u0005\u0172\u0000\u0000\u053a\u053c\u0005\u02cf\u0000"+
"\u0000\u053b\u0539\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000\u0000"+
"\u0000\u053cc\u0001\u0000\u0000\u0000\u053d\u053e\u0005\u00b6\u0000\u0000"+
"\u053e\u0554\u0005\u00b7\u0000\u0000\u053f\u0540\u0005\u00b6\u0000\u0000"+
"\u0540\u0545\u0003f3\u0000\u0541\u0542\u0005\u00b8\u0000\u0000\u0542\u0544"+
"\u0003f3\u0000\u0543\u0541\u0001\u0000\u0000\u0000\u0544\u0547\u0001\u0000"+
"\u0000\u0000\u0545\u0543\u0001\u0000\u0000\u0000\u0545\u0546\u0001\u0000"+
"\u0000\u0000\u0546\u0548\u0001\u0000\u0000\u0000\u0547\u0545\u0001\u0000"+
"\u0000\u0000\u0548\u0549\u0005\u00b7\u0000\u0000\u0549\u0554\u0001\u0000"+
"\u0000\u0000\u054a\u054b\u00042\u0002\u0000\u054b\u0550\u0003f3\u0000"+
"\u054c\u054d\u0005\u00b8\u0000\u0000\u054d\u054f\u0003f3\u0000\u054e\u054c"+
"\u0001\u0000\u0000\u0000\u054f\u0552\u0001\u0000\u0000\u0000\u0550\u054e"+
"\u0001\u0000\u0000\u0000\u0550\u0551\u0001\u0000\u0000\u0000\u0551\u0554"+
"\u0001\u0000\u0000\u0000\u0552\u0550\u0001\u0000\u0000\u0000\u0553\u053d"+
"\u0001\u0000\u0000\u0000\u0553\u053f\u0001\u0000\u0000\u0000\u0553\u054a"+
"\u0001\u0000\u0000\u0000\u0554e\u0001\u0000\u0000\u0000\u0555\u055b\u0005"+
"\u0191\u0000\u0000\u0556\u055b\u0005b\u0000\u0000\u0557\u055b\u0005?\u0000"+
"\u0000\u0558\u0559\u0005\u0191\u0000\u0000\u0559\u055b\u0005b\u0000\u0000"+
"\u055a\u0555\u0001\u0000\u0000\u0000\u055a\u0556\u0001\u0000\u0000\u0000"+
"\u055a\u0557\u0001\u0000\u0000\u0000\u055a\u0558\u0001\u0000\u0000\u0000"+
"\u055a\u055b\u0001\u0000\u0000\u0000\u055b\u055c\u0001\u0000\u0000\u0000"+
"\u055c\u055d\u0003\u00fa}\u0000\u055d\u055f\u0003B!\u0000\u055e\u0560"+
"\u0003D\"\u0000\u055f\u055e\u0001\u0000\u0000\u0000\u055f\u0560\u0001"+
"\u0000\u0000\u0000\u0560\u0564\u0001\u0000\u0000\u0000\u0561\u0563\u0003"+
"F#\u0000\u0562\u0561\u0001\u0000\u0000\u0000\u0563\u0566\u0001\u0000\u0000"+
"\u0000\u0564\u0562\u0001\u0000\u0000\u0000\u0564\u0565\u0001\u0000\u0000"+
"\u0000\u0565\u0568\u0001\u0000\u0000\u0000\u0566\u0564\u0001\u0000\u0000"+
"\u0000\u0567\u0569\u0003H$\u0000\u0568\u0567\u0001\u0000\u0000\u0000\u0568"+
"\u0569\u0001\u0000\u0000\u0000\u0569\u0580\u0001\u0000\u0000\u0000\u056a"+
"\u0570\u0003\u00fa}\u0000\u056b\u0571\u0005\u0191\u0000\u0000\u056c\u0571"+
"\u0005b\u0000\u0000\u056d\u0571\u0005?\u0000\u0000\u056e\u056f\u0005\u0191"+
"\u0000\u0000\u056f\u0571\u0005b\u0000\u0000\u0570\u056b\u0001\u0000\u0000"+
"\u0000\u0570\u056c\u0001\u0000\u0000\u0000\u0570\u056d\u0001\u0000\u0000"+
"\u0000\u0570\u056e\u0001\u0000\u0000\u0000\u0570\u0571\u0001\u0000\u0000"+
"\u0000\u0571\u0572\u0001\u0000\u0000\u0000\u0572\u0574\u0003B!\u0000\u0573"+
"\u0575\u0003D\"\u0000\u0574\u0573\u0001\u0000\u0000\u0000\u0574\u0575"+
"\u0001\u0000\u0000\u0000\u0575\u0579\u0001\u0000\u0000\u0000\u0576\u0578"+
"\u0003F#\u0000\u0577\u0576\u0001\u0000\u0000\u0000\u0578\u057b\u0001\u0000"+
"\u0000\u0000\u0579\u0577\u0001\u0000\u0000\u0000\u0579\u057a\u0001\u0000"+
"\u0000\u0000\u057a\u057d\u0001\u0000\u0000\u0000\u057b\u0579\u0001\u0000"+
"\u0000\u0000\u057c\u057e\u0003H$\u0000\u057d\u057c\u0001\u0000\u0000\u0000"+
"\u057d\u057e\u0001\u0000\u0000\u0000\u057e\u0580\u0001\u0000\u0000\u0000"+
"\u057f\u055a\u0001\u0000\u0000\u0000\u057f\u056a\u0001\u0000\u0000\u0000"+
"\u0580g\u0001\u0000\u0000\u0000\u0581\u0583\u0003j5\u0000\u0582\u0581"+
"\u0001\u0000\u0000\u0000\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0582"+
"\u0001\u0000\u0000\u0000\u0584\u0585\u0001\u0000\u0000\u0000\u0585i\u0001"+
"\u0000\u0000\u0000\u0586\u0587\u0005G\u0000\u0000\u0587\u0592\u0005\u0086"+
"\u0000\u0000\u0588\u0589\u0005\u0086\u0000\u0000\u0589\u058a\u0005|\u0000"+
"\u0000\u058a\u0592\u0007\u000e\u0000\u0000\u058b\u058d\u0005\u0149\u0000"+
"\u0000\u058c\u058b\u0001\u0000\u0000\u0000\u058c\u058d\u0001\u0000\u0000"+
"\u0000\u058d\u058e\u0001\u0000\u0000\u0000\u058e\u058f\u0005r\u0000\u0000"+
"\u058f\u0590\u0005\u0251\u0000\u0000\u0590\u0592\u0005\u02cf\u0000\u0000"+
"\u0591\u0586\u0001\u0000\u0000\u0000\u0591\u0588\u0001\u0000\u0000\u0000"+
"\u0591\u058c\u0001\u0000\u0000\u0000\u0592k\u0001\u0000\u0000\u0000\u0593"+
"\u0595\u0007\u000f\u0000\u0000\u0594\u0596\u0005\u0190\u0000\u0000\u0595"+
"\u0594\u0001\u0000\u0000\u0000\u0595\u0596\u0001\u0000\u0000\u0000\u0596"+
"\u0597\u0001\u0000\u0000\u0000\u0597\u059d\u0003\u00c2a\u0000\u0598\u0599"+
"\u0005\u00b6\u0000\u0000\u0599\u059a\u0003\u00eau\u0000\u059a\u059b\u0005"+
"\u00b7\u0000\u0000\u059b\u059e\u0001\u0000\u0000\u0000\u059c\u059e\u0003"+
"\u00eau\u0000\u059d\u0598\u0001\u0000\u0000\u0000\u059d\u059c\u0001\u0000"+
"\u0000\u0000\u059d\u059e\u0001\u0000\u0000\u0000\u059e\u05a8\u0001\u0000"+
"\u0000\u0000\u059f\u05a0\u0005\u019e\u0000\u0000\u05a0\u05a5\u0005\u02d3"+
"\u0000\u0000\u05a1\u05a2\u0005\u00b8\u0000\u0000\u05a2\u05a4\u0005\u02d3"+
"\u0000\u0000\u05a3\u05a1\u0001\u0000\u0000\u0000\u05a4\u05a7\u0001\u0000"+
"\u0000\u0000\u05a5\u05a3\u0001\u0000\u0000\u0000\u05a5\u05a6\u0001\u0000"+
"\u0000\u0000\u05a6\u05a9\u0001\u0000\u0000\u0000\u05a7\u05a5\u0001\u0000"+
"\u0000\u0000\u05a8\u059f\u0001\u0000\u0000\u0000\u05a8\u05a9\u0001\u0000"+
"\u0000\u0000\u05a9\u05ab\u0001\u0000\u0000\u0000\u05aa\u05ac\u0003\u00b4"+
"Z\u0000\u05ab\u05aa\u0001\u0000\u0000\u0000\u05ab\u05ac\u0001\u0000\u0000"+
"\u0000\u05acm\u0001\u0000\u0000\u0000\u05ad\u05b1\u0003p8\u0000\u05ae"+
"\u05b1\u0003r9\u0000\u05af\u05b1\u0003t:\u0000\u05b0\u05ad\u0001\u0000"+
"\u0000\u0000\u05b0\u05ae\u0001\u0000\u0000\u0000\u05b0\u05af\u0001\u0000"+
"\u0000\u0000\u05b1o\u0001\u0000\u0000\u0000\u05b2\u05b3\u0005\u018e\u0000"+
"\u0000\u05b3\u05b4\u0003\u00b6[\u0000\u05b4\u05b5\u0005\u027a\u0000\u0000"+
"\u05b5\u05b9\u0003\u0002\u0001\u0000\u05b6\u05b8\u0003v;\u0000\u05b7\u05b6"+
"\u0001\u0000\u0000\u0000\u05b8\u05bb\u0001\u0000\u0000\u0000\u05b9\u05b7"+
"\u0001\u0000\u0000\u0000\u05b9\u05ba\u0001\u0000\u0000\u0000\u05ba\u05bd"+
"\u0001\u0000\u0000\u0000\u05bb\u05b9\u0001\u0000\u0000\u0000\u05bc\u05be"+
"\u0003x<\u0000\u05bd\u05bc\u0001\u0000\u0000\u0000\u05bd\u05be\u0001\u0000"+
"\u0000\u0000\u05be\u05bf\u0001\u0000\u0000\u0000\u05bf\u05c0\u0005\u014f"+
"\u0000\u0000\u05c0\u05c1\u0005\u018e\u0000\u0000\u05c1q\u0001\u0000\u0000"+
"\u0000\u05c2\u05c3\u0005\u018e\u0000\u0000\u05c3\u05c4\u0003\u00b6[\u0000"+
"\u05c4\u05c7\u0003\u0006\u0003\u0000\u05c5\u05c6\u0005\u014b\u0000\u0000"+
"\u05c6\u05c8\u0003\u0006\u0003\u0000\u05c7\u05c5\u0001\u0000\u0000\u0000"+
"\u05c7\u05c8\u0001\u0000\u0000\u0000\u05c8s\u0001\u0000\u0000\u0000\u05c9"+
"\u05ca\u0005\u00b9\u0000\u0000\u05ca\u05cb\u0005\u018e\u0000\u0000\u05cb"+
"\u05cc\u0003\u00b6[\u0000\u05cc\u05cd\u0005\u027a\u0000\u0000\u05cd\u05ce"+
"\u0003\u0006\u0003\u0000\u05ceu\u0001\u0000\u0000\u0000\u05cf\u05d0\u0007"+
"\u0010\u0000\u0000\u05d0\u05d1\u0003\u00b6[\u0000\u05d1\u05d2\u0005\u027a"+
"\u0000\u0000\u05d2\u05d3\u0003\u0002\u0001\u0000\u05d3w\u0001\u0000\u0000"+
"\u0000\u05d4\u05d5\u0005\u014b\u0000\u0000\u05d5\u05d6\u0003\u0002\u0001"+
"\u0000\u05d6y\u0001\u0000\u0000\u0000\u05d7\u05da\u0005=\u0000\u0000\u05d8"+
"\u05db\u0003\u00f4z\u0000\u05d9\u05db\u0003\u00c2a\u0000\u05da\u05d8\u0001"+
"\u0000\u0000\u0000\u05da\u05d9\u0001\u0000\u0000\u0000\u05db{\u0001\u0000"+
"\u0000\u0000\u05dc\u05de\u00053\u0000\u0000\u05dd\u05df\u0005\u02d3\u0000"+
"\u0000\u05de\u05dd\u0001\u0000\u0000\u0000\u05de\u05df\u0001\u0000\u0000"+
"\u0000\u05df\u05e2\u0001\u0000\u0000\u0000\u05e0\u05e1\u0005\u02a7\u0000"+
"\u0000\u05e1\u05e3\u0003\u00b6[\u0000\u05e2\u05e0\u0001\u0000\u0000\u0000"+
"\u05e2\u05e3\u0001\u0000\u0000\u0000\u05e3}\u0001\u0000\u0000\u0000\u05e4"+
"\u05e5\u00058\u0000\u0000\u05e5\u05e6\u0005)\u0000\u0000\u05e6\u05e7\u0003"+
"\u0080@\u0000\u05e7\u007f\u0001\u0000\u0000\u0000\u05e8\u05eb\u0003\u0082"+
"A\u0000\u05e9\u05eb\u0003\u0084B\u0000\u05ea\u05e8\u0001\u0000\u0000\u0000"+
"\u05ea\u05e9\u0001\u0000\u0000\u0000\u05eb\u0081\u0001\u0000\u0000\u0000"+
"\u05ec\u05ed\u00051\u0000\u0000\u05ed\u05ee\u0005\u02cf\u0000\u0000\u05ee"+
"\u05ef\u0003\u00fc~\u0000\u05ef\u05f0\u0005\u02b0\u0000\u0000\u05f0\u05f1"+
"\u0005R\u0000\u0000\u05f1\u0083\u0001\u0000\u0000\u0000\u05f2\u05f3\u0003"+
"\u00fc~\u0000\u05f3\u05f4\u0005\u02b0\u0000\u0000\u05f4\u05f5\u0005w\u0000"+
"\u0000\u05f5\u0085\u0001\u0000\u0000\u0000\u05f6\u05f8\u0005H\u0000\u0000"+
"\u05f7\u05f9\u0005\u02d3\u0000\u0000\u05f8\u05f7\u0001\u0000\u0000\u0000"+
"\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u0087\u0001\u0000\u0000\u0000"+
"\u05fa\u05fb\u0005\u01c6\u0000\u0000\u05fb\u05fc\u0005`\u0000\u0000\u05fc"+
"\u05ff\u0003\u00fa}\u0000\u05fd\u05fe\u0005\u027e\u0000\u0000\u05fe\u0600"+
"\u0003\u00fa}\u0000\u05ff\u05fd\u0001\u0000\u0000\u0000\u05ff\u0600\u0001"+
"\u0000\u0000\u0000\u0600\u0603\u0001\u0000\u0000\u0000\u0601\u0602\u0005"+
"\u00d3\u0000\u0000\u0602\u0604\u0003\u00fa}\u0000\u0603\u0601\u0001\u0000"+
"\u0000\u0000\u0603\u0604\u0001\u0000\u0000\u0000\u0604\u0089\u0001\u0000"+
"\u0000\u0000\u0605\u0606\u0005\u01ef\u0000\u0000\u0606\u060c\u0003\u00fa"+
"}\u0000\u0607\u060a\u0005\u016d\u0000\u0000\u0608\u060b\u0003\u01f0\u00f8"+
"\u0000\u0609\u060b\u0003\u00c2a\u0000\u060a\u0608\u0001\u0000\u0000\u0000"+
"\u060a\u0609\u0001\u0000\u0000\u0000\u060b\u060d\u0001\u0000\u0000\u0000"+
"\u060c\u0607\u0001\u0000\u0000\u0000\u060c\u060d\u0001\u0000\u0000\u0000"+
"\u060d\u008b\u0001\u0000\u0000\u0000\u060e\u0610\u00055\u0000\u0000\u060f"+
"\u0611\u0005\u0172\u0000\u0000\u0610\u060f\u0001\u0000\u0000\u0000\u0610"+
"\u0611\u0001\u0000\u0000\u0000\u0611\u0612\u0001\u0000\u0000\u0000\u0612"+
"\u0614\u0003\u00fa}\u0000\u0613\u0615\u0003\u020a\u0105\u0000\u0614\u0613"+
"\u0001\u0000\u0000\u0000\u0614\u0615\u0001\u0000\u0000\u0000\u0615\u0616"+
"\u0001\u0000\u0000\u0000\u0616\u0617\u0005\u019e\u0000\u0000\u0617\u061c"+
"\u0003\u00fa}\u0000\u0618\u0619\u0005\u00b8\u0000\u0000\u0619\u061b\u0003"+
"\u00fa}\u0000\u061a\u0618\u0001\u0000\u0000\u0000\u061b\u061e\u0001\u0000"+
"\u0000\u0000\u061c\u061a\u0001\u0000\u0000\u0000\u061c\u061d\u0001\u0000"+
"\u0000\u0000\u061d\u0620\u0001\u0000\u0000\u0000\u061e\u061c\u0001\u0000"+
"\u0000\u0000\u061f\u0621\u0003\u008eG\u0000\u0620\u061f\u0001\u0000\u0000"+
"\u0000\u0620\u0621\u0001\u0000\u0000\u0000\u0621\u008d\u0001\u0000\u0000"+
"\u0000\u0622\u0623\u0005\u01b9\u0000\u0000\u0623\u0624\u0003\u00c2a\u0000"+
"\u0624\u008f\u0001\u0000\u0000\u0000\u0625\u0626\u0005\u0013\u0000\u0000"+
"\u0626\u0627\u0005\u02d3\u0000\u0000\u0627\u0091\u0001\u0000\u0000\u0000"+
"\u0628\u0629\u0005j\u0000\u0000\u0629\u0630\u0003\u00c2a\u0000\u062a\u062b"+
"\u0005j\u0000\u0000\u062b\u062c\u0005\u00b6\u0000\u0000\u062c\u062d\u0003"+
"\u00c2a\u0000\u062d\u062e\u0005\u00b7\u0000\u0000\u062e\u0630\u0001\u0000"+
"\u0000\u0000\u062f\u0628\u0001\u0000\u0000\u0000\u062f\u062a\u0001\u0000"+
"\u0000\u0000\u0630\u0093\u0001\u0000\u0000\u0000\u0631\u0633\u0005\u00b9"+
"\u0000\u0000\u0632\u0631\u0001\u0000\u0000\u0000\u0632\u0633\u0001\u0000"+
"\u0000\u0000\u0633\u0634\u0001\u0000\u0000\u0000\u0634\u0636\u0005m\u0000"+
"\u0000\u0635\u0637\u0003\u00c2a\u0000\u0636\u0635\u0001\u0000\u0000\u0000"+
"\u0636\u0637\u0001\u0000\u0000\u0000\u0637\u0095\u0001\u0000\u0000\u0000"+
"\u0638\u0639\u0005o\u0000\u0000\u0639\u0097\u0001\u0000\u0000\u0000\u063a"+
"\u0646\u0005p\u0000\u0000\u063b\u063d\u0005\u0089\u0000\u0000\u063c\u063e"+
"\u0005\u0298\u0000\u0000\u063d\u063c\u0001\u0000\u0000\u0000\u063d\u063e"+
"\u0001\u0000\u0000\u0000\u063e\u063f\u0001\u0000\u0000\u0000\u063f\u0644"+
"\u0003\u00c2a\u0000\u0640\u0641\u0005\u0250\u0000\u0000\u0641\u0642\u0005"+
"R\u0000\u0000\u0642\u0643\u0005\u02b0\u0000\u0000\u0643\u0645\u0003\u00c2"+
"a\u0000\u0644\u0640\u0001\u0000\u0000\u0000\u0644\u0645\u0001\u0000\u0000"+
"\u0000\u0645\u0647\u0001\u0000\u0000\u0000\u0646\u063b\u0001\u0000\u0000"+
"\u0000\u0646\u0647\u0001\u0000\u0000\u0000\u0647\u0099\u0001\u0000\u0000"+
"\u0000\u0648\u064a\u0005t\u0000\u0000\u0649\u064b\u0003\u00c2a\u0000\u064a"+
"\u0649\u0001\u0000\u0000\u0000\u064a\u064b\u0001\u0000\u0000\u0000\u064b"+
"\u009b\u0001\u0000\u0000\u0000\u064c\u0651\u0003\u009eO\u0000\u064d\u0651"+
"\u0003\u00a0P\u0000\u064e\u0651\u0003\u00a2Q\u0000\u064f\u0651\u0003\u00a4"+
"R\u0000\u0650\u064c\u0001\u0000\u0000\u0000\u0650\u064d\u0001\u0000\u0000"+
"\u0000\u0650\u064e\u0001\u0000\u0000\u0000\u0650\u064f\u0001\u0000\u0000"+
"\u0000\u0651\u009d\u0001\u0000\u0000\u0000\u0652\u0654\u0007\u0011\u0000"+
"\u0000\u0653\u0652\u0001\u0000\u0000\u0000\u0653\u0654\u0001\u0000\u0000"+
"\u0000\u0654\u0655\u0001\u0000\u0000\u0000\u0655\u0656\u0003\u00fa}\u0000"+
"\u0656\u0657\u0005\u02b0\u0000\u0000\u0657\u0658\u0003\u00fa}\u0000\u0658"+
"\u009f\u0001\u0000\u0000\u0000\u0659\u065b\u0005\u011e\u0000\u0000\u065a"+
"\u0659\u0001\u0000\u0000\u0000\u065a\u065b\u0001\u0000\u0000\u0000\u065b"+
"\u065c\u0001\u0000\u0000\u0000\u065c\u065f\u0005\u0248\u0000\u0000\u065d"+
"\u065f\u0005\u001f\u0000\u0000\u065e\u065a\u0001\u0000\u0000\u0000\u065e"+
"\u065d\u0001\u0000\u0000\u0000\u065f\u0661\u0001\u0000\u0000\u0000\u0660"+
"\u0662\u0005\u02b0\u0000\u0000\u0661\u0660\u0001\u0000\u0000\u0000\u0661"+
"\u0662\u0001\u0000\u0000\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663"+
"\u0664\u0003\u00c2a\u0000\u0664\u00a1\u0001\u0000\u0000\u0000\u0665\u0666"+
"\u0007\u0012\u0000\u0000\u0666\u0667\u0007\u0013\u0000\u0000\u0667\u00a3"+
"\u0001\u0000\u0000\u0000\u0668\u0669\u0005l\u0000\u0000\u0669\u066c\u0005"+
"\u02b0\u0000\u0000\u066a\u066d\u0003\u00c2a\u0000\u066b\u066d\u0005\\"+
"\u0000\u0000\u066c\u066a\u0001\u0000\u0000\u0000\u066c\u066b\u0001\u0000"+
"\u0000\u0000\u066d\u066f\u0001\u0000\u0000\u0000\u066e\u0670\u0005\u0294"+
"\u0000\u0000\u066f\u066e\u0001\u0000\u0000\u0000\u066f\u0670\u0001\u0000"+
"\u0000\u0000\u0670\u0671\u0001\u0000\u0000\u0000\u0671\u0672\u0005\u016d"+
"\u0000\u0000\u0672\u0673\u0007\u0014\u0000\u0000\u0673\u00a5\u0001\u0000"+
"\u0000\u0000\u0674\u0675\u0005\u0081\u0000\u0000\u0675\u0676\u0003\u00fa"+
"}\u0000\u0676\u00a7\u0001\u0000\u0000\u0000\u0677\u0679\u0005\u0299\u0000"+
"\u0000\u0678\u067a\u0005\u00b6\u0000\u0000\u0679\u0678\u0001\u0000\u0000"+
"\u0000\u0679\u067a\u0001\u0000\u0000\u0000\u067a\u067b\u0001\u0000\u0000"+
"\u0000\u067b\u0680\u0003\u00c2a\u0000\u067c\u067d\u0005\u00b8\u0000\u0000"+
"\u067d\u067f\u0003\u00c2a\u0000\u067e\u067c\u0001\u0000\u0000\u0000\u067f"+
"\u0682\u0001\u0000\u0000\u0000\u0680\u067e\u0001\u0000\u0000\u0000\u0680"+
"\u0681\u0001\u0000\u0000\u0000\u0681\u0684\u0001\u0000\u0000\u0000\u0682"+
"\u0680\u0001\u0000\u0000\u0000\u0683\u0685\u0005\u00b7\u0000\u0000\u0684"+
"\u0683\u0001\u0000\u0000\u0000\u0684\u0685\u0001\u0000\u0000\u0000\u0685"+
"\u0686\u0001\u0000\u0000\u0000\u0686\u0688\u0005\u019e\u0000\u0000\u0687"+
"\u0689\u0005\u00b6\u0000\u0000\u0688\u0687\u0001\u0000\u0000\u0000\u0688"+
"\u0689\u0001\u0000\u0000\u0000\u0689\u068a\u0001\u0000\u0000\u0000\u068a"+
"\u068f\u0003\u00fa}\u0000\u068b\u068c\u0005\u00b8\u0000\u0000\u068c\u068e"+
"\u0003\u00fa}\u0000\u068d\u068b\u0001\u0000\u0000\u0000\u068e\u0691\u0001"+
"\u0000\u0000\u0000\u068f\u068d\u0001\u0000\u0000\u0000\u068f\u0690\u0001"+
"\u0000\u0000\u0000\u0690\u0693\u0001\u0000\u0000\u0000\u0691\u068f\u0001"+
"\u0000\u0000\u0000\u0692\u0694\u0005\u00b7\u0000\u0000\u0693\u0692\u0001"+
"\u0000\u0000\u0000\u0693\u0694\u0001\u0000\u0000\u0000\u0694\u00a9\u0001"+
"\u0000\u0000\u0000\u0695\u0696\u0005\u009b\u0000\u0000\u0696\u0697\u0003"+
"\u00b6[\u0000\u0697\u0698\u0007\u0015\u0000\u0000\u0698\u0699\u0003\u0002"+
"\u0001\u0000\u0699\u069b\u0005\u014f\u0000\u0000\u069a\u069c\u0007\u0016"+
"\u0000\u0000\u069b\u069a\u0001\u0000\u0000\u0000\u069b\u069c\u0001\u0000"+
"\u0000\u0000\u069c\u00ab\u0001\u0000\u0000\u0000\u069d\u069e\u0005O\u0000"+
"\u0000\u069e\u069f\u0003\u0002\u0001\u0000\u069f\u06a0\u0005\u014f\u0000"+
"\u0000\u06a0\u06a1\u0005O\u0000\u0000\u06a1\u00ad\u0001\u0000\u0000\u0000"+
"\u06a2\u06a3\u0005\u016d\u0000\u0000\u06a3\u06a4\u0005\u02d3\u0000\u0000"+
"\u06a4\u06a6\u0005\u0191\u0000\u0000\u06a5\u06a7\u0005\u00b6\u0000\u0000"+
"\u06a6\u06a5\u0001\u0000\u0000\u0000\u06a6\u06a7\u0001\u0000\u0000\u0000"+
"\u06a7\u06a8\u0001\u0000\u0000\u0000\u06a8\u06aa\u0003\u01f0\u00f8\u0000"+
"\u06a9\u06ab\u0005\u00b7\u0000\u0000\u06aa\u06a9\u0001\u0000\u0000\u0000"+
"\u06aa\u06ab\u0001\u0000\u0000\u0000\u06ab\u06ac\u0001\u0000\u0000\u0000"+
"\u06ac\u06ad\u0005O\u0000\u0000\u06ad\u06ae\u0003\u0002\u0001\u0000\u06ae"+
"\u06af\u0005\u014f\u0000\u0000\u06af\u06b0\u0005O\u0000\u0000\u06b0\u00af"+
"\u0001\u0000\u0000\u0000\u06b1\u06b2\u0005\u016d\u0000\u0000\u06b2\u06b3"+
"\u0005\u02d3\u0000\u0000\u06b3\u06b5\u0005\u0191\u0000\u0000\u06b4\u06b6"+
"\u0005u\u0000\u0000\u06b5\u06b4\u0001\u0000\u0000\u0000\u06b5\u06b6\u0001"+
"\u0000\u0000\u0000\u06b6\u06b7\u0001\u0000\u0000\u0000\u06b7\u06b8\u0003"+
"\u00c2a\u0000\u06b8\u06b9\u0005\u00b4\u0000\u0000\u06b9\u06bc\u0003\u00c2"+
"a\u0000\u06ba\u06bb\u0007\u0017\u0000\u0000\u06bb\u06bd\u0003\u00c2a\u0000"+
"\u06bc\u06ba\u0001\u0000\u0000\u0000\u06bc\u06bd\u0001\u0000\u0000\u0000"+
"\u06bd\u06be\u0001\u0000\u0000\u0000\u06be\u06bf\u0005O\u0000\u0000\u06bf"+
"\u06c0\u0003\u0002\u0001\u0000\u06c0\u06c1\u0005\u014f\u0000\u0000\u06c1"+
"\u06c2\u0005O\u0000\u0000\u06c2\u00b1\u0001\u0000\u0000\u0000\u06c3\u06c4"+
"\u0005\u02d3\u0000\u0000\u06c4\u06cb\u0005\u02c3\u0000\u0000\u06c5\u06c6"+
"\u0005\u02b3\u0000\u0000\u06c6\u06c7\u0005\u02b3\u0000\u0000\u06c7\u06c8"+
"\u0005\u02d3\u0000\u0000\u06c8\u06c9\u0005\u02b5\u0000\u0000\u06c9\u06cb"+
"\u0005\u02b5\u0000\u0000\u06ca\u06c3\u0001\u0000\u0000\u0000\u06ca\u06c5"+
"\u0001\u0000\u0000\u0000\u06cb\u00b3\u0001\u0000\u0000\u0000\u06cc\u06cd"+
"\u0005\u0297\u0000\u0000\u06cd\u06d2\u0003\u00c2a\u0000\u06ce\u06cf\u0005"+
"\u00b8\u0000\u0000\u06cf\u06d1\u0003\u00c2a\u0000\u06d0\u06ce\u0001\u0000"+
"\u0000\u0000\u06d1\u06d4\u0001\u0000\u0000\u0000\u06d2\u06d0\u0001\u0000"+
"\u0000\u0000\u06d2\u06d3\u0001\u0000\u0000\u0000\u06d3\u00b5\u0001\u0000"+
"\u0000\u0000\u06d4\u06d2\u0001\u0000\u0000\u0000\u06d5\u06d7\u0006[\uffff"+
"\uffff\u0000\u06d6\u06d8\u0005\u01e7\u0000\u0000\u06d7\u06d6\u0001\u0000"+
"\u0000\u0000\u06d7\u06d8\u0001\u0000\u0000\u0000\u06d8\u06d9\u0001\u0000"+
"\u0000\u0000\u06d9\u06da\u0005\u00b6\u0000\u0000\u06da\u06db\u0003\u00b6"+
"[\u0000\u06db\u06dc\u0005\u00b7\u0000\u0000\u06dc\u06df\u0001\u0000\u0000"+
"\u0000\u06dd\u06df\u0003\u00b8\\\u0000\u06de\u06d5\u0001\u0000\u0000\u0000"+
"\u06de\u06dd\u0001\u0000\u0000\u0000\u06df\u06e6\u0001\u0000\u0000\u0000"+
"\u06e0\u06e1\n\u0002\u0000\u0000\u06e1\u06e2\u0003\u00be_\u0000\u06e2"+
"\u06e3\u0003\u00b6[\u0003\u06e3\u06e5\u0001\u0000\u0000\u0000\u06e4\u06e0"+
"\u0001\u0000\u0000\u0000\u06e5\u06e8\u0001\u0000\u0000\u0000\u06e6\u06e4"+
"\u0001\u0000\u0000\u0000\u06e6\u06e7\u0001\u0000\u0000\u0000\u06e7\u00b7"+
"\u0001\u0000\u0000\u0000\u06e8\u06e6\u0001\u0000\u0000\u0000\u06e9\u06ed"+
"\u0003\u00ba]\u0000\u06ea\u06ed\u0003\u00bc^\u0000\u06eb\u06ed\u0003\u00c2"+
"a\u0000\u06ec\u06e9\u0001\u0000\u0000\u0000\u06ec\u06ea\u0001\u0000\u0000"+
"\u0000\u06ec\u06eb\u0001\u0000\u0000\u0000\u06ed\u00b9\u0001\u0000\u0000"+
"\u0000\u06ee\u06ef\u0003\u00c2a\u0000\u06ef\u06f1\u0005\u01a2\u0000\u0000"+
"\u06f0\u06f2\u0005\u01e7\u0000\u0000\u06f1\u06f0\u0001\u0000\u0000\u0000"+
"\u06f1\u06f2\u0001\u0000\u0000\u0000\u06f2\u06f3\u0001\u0000\u0000\u0000"+
"\u06f3\u06f4\u0005\u01e8\u0000\u0000\u06f4\u06fc\u0001\u0000\u0000\u0000"+
"\u06f5\u06f6\u0003\u00c2a\u0000\u06f6\u06f7\u0005\u00dd\u0000\u0000\u06f7"+
"\u06f8\u0003\u00c2a\u0000\u06f8\u06f9\u0005\u00cd\u0000\u0000\u06f9\u06fa"+
"\u0003\u00c2a\u0000\u06fa\u06fc\u0001\u0000\u0000\u0000\u06fb\u06ee\u0001"+
"\u0000\u0000\u0000\u06fb\u06f5\u0001\u0000\u0000\u0000\u06fc\u00bb\u0001"+
"\u0000\u0000\u0000\u06fd\u06fe\u0003\u00c2a\u0000\u06fe\u06ff\u0003\u00c0"+
"`\u0000\u06ff\u0700\u0003\u00c2a\u0000\u0700\u00bd\u0001\u0000\u0000\u0000"+
"\u0701\u0702\u0007\u0018\u0000\u0000\u0702\u00bf\u0001\u0000\u0000\u0000"+
"\u0703\u070e\u0005\u02b0\u0000\u0000\u0704\u070e\u0005\u02b2\u0000\u0000"+
"\u0705\u070e\u0005\u02b3\u0000\u0000\u0706\u070e\u0005\u02b4\u0000\u0000"+
"\u0707\u070e\u0005\u02b5\u0000\u0000\u0708\u070e\u0005\u02b6\u0000\u0000"+
"\u0709\u070b\u0005\u01e7\u0000\u0000\u070a\u0709\u0001\u0000\u0000\u0000"+
"\u070a\u070b\u0001\u0000\u0000\u0000\u070b\u070c\u0001\u0000\u0000\u0000"+
"\u070c\u070e\u0007\u0019\u0000\u0000\u070d\u0703\u0001\u0000\u0000\u0000"+
"\u070d\u0704\u0001\u0000\u0000\u0000\u070d\u0705\u0001\u0000\u0000\u0000"+
"\u070d\u0706\u0001\u0000\u0000\u0000\u070d\u0707\u0001\u0000\u0000\u0000"+
"\u070d\u0708\u0001\u0000\u0000\u0000\u070d\u070a\u0001\u0000\u0000\u0000"+
"\u070e\u00c1\u0001\u0000\u0000\u0000\u070f\u0710\u0006a\uffff\uffff\u0000"+
"\u0710\u0711\u0005\u00b6\u0000\u0000\u0711\u0712\u0003\u01f0\u00f8\u0000"+
"\u0712\u0713\u0005\u00b7\u0000\u0000\u0713\u0722\u0001\u0000\u0000\u0000"+
"\u0714\u0715\u0005\u00b6\u0000\u0000\u0715\u0716\u0003\u00c2a\u0000\u0716"+
"\u0717\u0005\u00b7\u0000\u0000\u0717\u0722\u0001\u0000\u0000\u0000\u0718"+
"\u0722\u0003\u00c6c\u0000\u0719\u0722\u0003\u00cae\u0000\u071a\u0722\u0003"+
"\u00e4r\u0000\u071b\u0722\u0003\u00ceg\u0000\u071c\u0722\u0003\u00d4j"+
"\u0000\u071d\u0722\u0003\u00d6k\u0000\u071e\u0722\u0003\u00e0p\u0000\u071f"+
"\u0722\u0003\u00e2q\u0000\u0720\u0722\u0003\u00c4b\u0000\u0721\u070f\u0001"+
"\u0000\u0000\u0000\u0721\u0714\u0001\u0000\u0000\u0000\u0721\u0718\u0001"+
"\u0000\u0000\u0000\u0721\u0719\u0001\u0000\u0000\u0000\u0721\u071a\u0001"+
"\u0000\u0000\u0000\u0721\u071b\u0001\u0000\u0000\u0000\u0721\u071c\u0001"+
"\u0000\u0000\u0000\u0721\u071d\u0001\u0000\u0000\u0000\u0721\u071e\u0001"+
"\u0000\u0000\u0000\u0721\u071f\u0001\u0000\u0000\u0000\u0721\u0720\u0001"+
"\u0000\u0000\u0000\u0722\u072d\u0001\u0000\u0000\u0000\u0723\u0724\n\r"+
"\u0000\u0000\u0724\u0725\u0007\u001a\u0000\u0000\u0725\u072c\u0003\u00c2"+
"a\u000e\u0726\u0727\n\f\u0000\u0000\u0727\u0728\u0007\u001b\u0000\u0000"+
"\u0728\u072c\u0003\u00c2a\r\u0729\u072a\n\u000e\u0000\u0000\u072a\u072c"+
"\u0003\u00c8d\u0000\u072b\u0723\u0001\u0000\u0000\u0000\u072b\u0726\u0001"+
"\u0000\u0000\u0000\u072b\u0729\u0001\u0000\u0000\u0000\u072c\u072f\u0001"+
"\u0000\u0000\u0000\u072d\u072b\u0001\u0000\u0000\u0000\u072d\u072e\u0001"+
"\u0000\u0000\u0000\u072e\u00c3\u0001\u0000\u0000\u0000\u072f\u072d\u0001"+
"\u0000\u0000\u0000\u0730\u0739\u0003\u00f6{\u0000\u0731\u0739\u0003\u00f8"+
"|\u0000\u0732\u0739\u0003\u0104\u0082\u0000\u0733\u0739\u0003\u00fc~\u0000"+
"\u0734\u0739\u0003\u00fe\u007f\u0000\u0735\u0739\u0003\u0102\u0081\u0000"+
"\u0736\u0739\u0003\u0100\u0080\u0000\u0737\u0739\u0003\u0106\u0083\u0000"+
"\u0738\u0730\u0001\u0000\u0000\u0000\u0738\u0731\u0001\u0000\u0000\u0000"+
"\u0738\u0732\u0001\u0000\u0000\u0000\u0738\u0733\u0001\u0000\u0000\u0000"+
"\u0738\u0734\u0001\u0000\u0000\u0000\u0738\u0735\u0001\u0000\u0000\u0000"+
"\u0738\u0736\u0001\u0000\u0000\u0000\u0738\u0737\u0001\u0000\u0000\u0000"+
"\u0739\u00c5\u0001\u0000\u0000\u0000\u073a\u073b\u0005\u019d\u0000\u0000"+
"\u073b\u073c\u0003\u00c2a\u0000\u073c\u073d\u0003\u00c8d\u0000\u073d\u00c7"+
"\u0001\u0000\u0000\u0000\u073e\u073f\u0007\u001c\u0000\u0000\u073f\u00c9"+
"\u0001\u0000\u0000\u0000\u0740\u0741\u0003\u00ccf\u0000\u0741\u0742\u0007"+
"\u001d\u0000\u0000\u0742\u0747\u0003\u00ccf\u0000\u0743\u0744\u0007\u001d"+
"\u0000\u0000\u0744\u0746\u0003\u00ccf\u0000\u0745\u0743\u0001\u0000\u0000"+
"\u0000\u0746\u0749\u0001\u0000\u0000\u0000\u0747\u0745\u0001\u0000\u0000"+
"\u0000\u0747\u0748\u0001\u0000\u0000\u0000\u0748\u00cb\u0001\u0000\u0000"+
"\u0000\u0749\u0747\u0001\u0000\u0000\u0000\u074a\u074b\u0005\u00b6\u0000"+
"\u0000\u074b\u074c\u0003\u00c2a\u0000\u074c\u074d\u0005\u00b7\u0000\u0000"+
"\u074d\u0755\u0001\u0000\u0000\u0000\u074e\u0755\u0003\u00ceg\u0000\u074f"+
"\u0755\u0003\u00d6k\u0000\u0750\u0755\u0003\u00e0p\u0000\u0751\u0755\u0003"+
"\u00e4r\u0000\u0752\u0755\u0003\u00e2q\u0000\u0753\u0755\u0003\u00c4b"+
"\u0000\u0754\u074a\u0001\u0000\u0000\u0000\u0754\u074e\u0001\u0000\u0000"+
"\u0000\u0754\u074f\u0001\u0000\u0000\u0000\u0754\u0750\u0001\u0000\u0000"+
"\u0000\u0754\u0751\u0001\u0000\u0000\u0000\u0754\u0752\u0001\u0000\u0000"+
"\u0000\u0754\u0753\u0001\u0000\u0000\u0000\u0755\u00cd\u0001\u0000\u0000"+
"\u0000\u0756\u0759\u0003\u00d0h\u0000\u0757\u0759\u0003\u00d2i\u0000\u0758"+
"\u0756\u0001\u0000\u0000\u0000\u0758\u0757\u0001\u0000\u0000\u0000\u0759"+
"\u00cf\u0001\u0000\u0000\u0000\u075a\u075b\u0005\u00f6\u0000\u0000\u075b"+
"\u0761\u0003\u00c2a\u0000\u075c\u075d\u0005\u02a7\u0000\u0000\u075d\u075e"+
"\u0003\u00c2a\u0000\u075e\u075f\u0005\u027a\u0000\u0000\u075f\u0760\u0003"+
"\u00c2a\u0000\u0760\u0762\u0001\u0000\u0000\u0000\u0761\u075c\u0001\u0000"+
"\u0000\u0000\u0762\u0763\u0001\u0000\u0000\u0000\u0763\u0761\u0001\u0000"+
"\u0000\u0000\u0763\u0764\u0001\u0000\u0000\u0000\u0764\u0767\u0001\u0000"+
"\u0000\u0000\u0765\u0766\u0005\u014b\u0000\u0000\u0766\u0768\u0003\u00c2"+
"a\u0000\u0767\u0765\u0001\u0000\u0000\u0000\u0767\u0768\u0001\u0000\u0000"+
"\u0000\u0768\u0769\u0001\u0000\u0000\u0000\u0769\u076a\u0005\u014f\u0000"+
"\u0000\u076a\u00d1\u0001\u0000\u0000\u0000\u076b\u0771\u0005\u00f6\u0000"+
"\u0000\u076c\u076d\u0005\u02a7\u0000\u0000\u076d\u076e\u0003\u00b6[\u0000"+
"\u076e\u076f\u0005\u027a\u0000\u0000\u076f\u0770\u0003\u00c2a\u0000\u0770"+
"\u0772\u0001\u0000\u0000\u0000\u0771\u076c\u0001\u0000\u0000\u0000\u0772"+
"\u0773\u0001\u0000\u0000\u0000\u0773\u0771\u0001\u0000\u0000\u0000\u0773"+
"\u0774\u0001\u0000\u0000\u0000\u0774\u0777\u0001\u0000\u0000\u0000\u0775"+
"\u0776\u0005\u014b\u0000\u0000\u0776\u0778\u0003\u00c2a\u0000\u0777\u0775"+
"\u0001\u0000\u0000\u0000\u0777\u0778\u0001\u0000\u0000\u0000\u0778\u0779"+
"\u0001\u0000\u0000\u0000\u0779\u077a\u0005\u014f\u0000\u0000\u077a\u00d3"+
"\u0001\u0000\u0000\u0000\u077b\u077c\u0003\u00fa}\u0000\u077c\u077d\u0005"+
"\u02bb\u0000\u0000\u077d\u077e\u0007\u001e\u0000\u0000\u077e\u00d5\u0001"+
"\u0000\u0000\u0000\u077f\u0780\u0005\u0006\u0000\u0000\u0780\u0782\u0005"+
"\u00b6\u0000\u0000\u0781\u0783\u0003\u00d8l\u0000\u0782\u0781\u0001\u0000"+
"\u0000\u0000\u0782\u0783\u0001\u0000\u0000\u0000\u0783\u0784\u0001\u0000"+
"\u0000\u0000\u0784\u0785\u0003\u00c2a\u0000\u0785\u0787\u0005\u00b7\u0000"+
"\u0000\u0786\u0788\u0003\u00dcn\u0000\u0787\u0786\u0001\u0000\u0000\u0000"+
"\u0787\u0788\u0001\u0000\u0000\u0000\u0788\u0818\u0001\u0000\u0000\u0000"+
"\u0789\u078a\u0005\u0118\u0000\u0000\u078a\u0790\u0005\u00b6\u0000\u0000"+
"\u078b\u078d\u0003\u00d8l\u0000\u078c\u078b\u0001\u0000\u0000\u0000\u078c"+
"\u078d\u0001\u0000\u0000\u0000\u078d\u078e\u0001\u0000\u0000\u0000\u078e"+
"\u0791\u0003\u00c2a\u0000\u078f\u0791\u0005\u02b9\u0000\u0000\u0790\u078c"+
"\u0001\u0000\u0000\u0000\u0790\u078f\u0001\u0000\u0000\u0000\u0791\u0792"+
"\u0001\u0000\u0000\u0000\u0792\u0794\u0005\u00b7\u0000\u0000\u0793\u0795"+
"\u0003\u00dcn\u0000\u0794\u0793\u0001\u0000\u0000\u0000\u0794\u0795\u0001"+
"\u0000\u0000\u0000\u0795\u0818\u0001\u0000\u0000\u0000\u0796\u0797\u0005"+
"\u001c\u0000\u0000\u0797\u079d\u0005\u00b6\u0000\u0000\u0798\u079a\u0003"+
"\u00d8l\u0000\u0799\u0798\u0001\u0000\u0000\u0000\u0799\u079a\u0001\u0000"+
"\u0000\u0000\u079a\u079b\u0001\u0000\u0000\u0000\u079b\u079e\u0003\u00c2"+
"a\u0000\u079c\u079e\u0005\u02b9\u0000\u0000\u079d\u0799\u0001\u0000\u0000"+
"\u0000\u079d\u079c\u0001\u0000\u0000\u0000\u079e\u079f\u0001\u0000\u0000"+
"\u0000\u079f\u07a1\u0005\u00b7\u0000\u0000\u07a0\u07a2\u0003\u00dcn\u0000"+
"\u07a1\u07a0\u0001\u0000\u0000\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000"+
"\u07a2\u0818\u0001\u0000\u0000\u0000\u07a3\u07a4\u0005\u00a1\u0000\u0000"+
"\u07a4\u07a5\u0005\u00b6\u0000\u0000\u07a5\u07a6\u0005\u00b7\u0000\u0000"+
"\u07a6\u0818\u0003\u00dcn\u0000\u07a7\u07a8\u0005\u00a2\u0000\u0000\u07a8"+
"\u07a9\u0005\u00b6\u0000\u0000\u07a9\u07aa\u0005\u00b7\u0000\u0000\u07aa"+
"\u0818\u0003\u00dcn\u0000\u07ab\u07ac\u0005\u00a3\u0000\u0000\u07ac\u07ad"+
"\u0005\u00b6\u0000\u0000\u07ad\u07ae\u0003\u00c2a\u0000\u07ae\u07af\u0005"+
"\u00b7\u0000\u0000\u07af\u07b0\u0003\u00dcn\u0000\u07b0\u0818\u0001\u0000"+
"\u0000\u0000\u07b1\u07b2\u0005\u00a4\u0000\u0000\u07b2\u07b3\u0005\u00b6"+
"\u0000\u0000\u07b3\u07ba\u0003\u00c2a\u0000\u07b4\u07b5\u0005\u00b8\u0000"+
"\u0000\u07b5\u07b8\u0003\u00c2a\u0000\u07b6\u07b7\u0005\u00b8\u0000\u0000"+
"\u07b7\u07b9\u0003\u00c2a\u0000\u07b8\u07b6\u0001\u0000\u0000\u0000\u07b8"+
"\u07b9\u0001\u0000\u0000\u0000\u07b9\u07bb\u0001\u0000\u0000\u0000\u07ba"+
"\u07b4\u0001\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000\u07bb"+
"\u07bc\u0001\u0000\u0000\u0000\u07bc\u07bd\u0005\u00b7\u0000\u0000\u07bd"+
"\u07be\u0003\u00dcn\u0000\u07be\u0818\u0001\u0000\u0000\u0000\u07bf\u07c0"+
"\u0005\u00a5\u0000\u0000\u07c0\u07c1\u0005\u00b6\u0000\u0000\u07c1\u07c2"+
"\u0003\u00c2a\u0000\u07c2\u07c3\u0005\u00b7\u0000\u0000\u07c3\u07c4\u0003"+
"\u00dcn\u0000\u07c4\u0818\u0001\u0000\u0000\u0000\u07c5\u07c6\u0005\u00a6"+
"\u0000\u0000\u07c6\u07c7\u0005\u00b6\u0000\u0000\u07c7\u07ce\u0003\u00c2"+
"a\u0000\u07c8\u07c9\u0005\u00b8\u0000\u0000\u07c9\u07cc\u0003\u00c2a\u0000"+
"\u07ca\u07cb\u0005\u00b8\u0000\u0000\u07cb\u07cd\u0003\u00c2a\u0000\u07cc"+
"\u07ca\u0001\u0000\u0000\u0000\u07cc\u07cd\u0001\u0000\u0000\u0000\u07cd"+
"\u07cf\u0001\u0000\u0000\u0000\u07ce\u07c8\u0001\u0000\u0000\u0000\u07ce"+
"\u07cf\u0001\u0000\u0000\u0000\u07cf\u07d0\u0001\u0000\u0000\u0000\u07d0"+
"\u07d1\u0005\u00b7\u0000\u0000\u07d1\u07d2\u0003\u00dcn\u0000\u07d2\u0818"+
"\u0001\u0000\u0000\u0000\u07d3\u07d4\u0005\u01d1\u0000\u0000\u07d4\u07d6"+
"\u0005\u00b6\u0000\u0000\u07d5\u07d7\u0003\u00d8l\u0000\u07d6\u07d5\u0001"+
"\u0000\u0000\u0000\u07d6\u07d7\u0001\u0000\u0000\u0000\u07d7\u07d8\u0001"+
"\u0000\u0000\u0000\u07d8\u07d9\u0003\u00c2a\u0000\u07d9\u07db\u0005\u00b7"+
"\u0000\u0000\u07da\u07dc\u0003\u00dcn\u0000\u07db\u07da\u0001\u0000\u0000"+
"\u0000\u07db\u07dc\u0001\u0000\u0000\u0000\u07dc\u0818\u0001\u0000\u0000"+
"\u0000\u07dd\u07de\u0005\u01d7\u0000\u0000\u07de\u07e0\u0005\u00b6\u0000"+
"\u0000\u07df\u07e1\u0003\u00d8l\u0000\u07e0\u07df\u0001\u0000\u0000\u0000"+
"\u07e0\u07e1\u0001\u0000\u0000\u0000\u07e1\u07e2\u0001\u0000\u0000\u0000"+
"\u07e2\u07e3\u0003\u00c2a\u0000\u07e3\u07e5\u0005\u00b7\u0000\u0000\u07e4"+
"\u07e6\u0003\u00dcn\u0000\u07e5\u07e4\u0001\u0000\u0000\u0000\u07e5\u07e6"+
"\u0001\u0000\u0000\u0000\u07e6\u0818\u0001\u0000\u0000\u0000\u07e7\u07e8"+
"\u0005\u00af\u0000\u0000\u07e8\u07e9\u0005\u00b6\u0000\u0000\u07e9\u07ea"+
"\u0005\u00b7\u0000\u0000\u07ea\u0818\u0003\u00dcn\u0000\u07eb\u07ec\u0005"+
"\u00b0\u0000\u0000\u07ec\u07ed\u0005\u00b6\u0000\u0000\u07ed\u07ee\u0005"+
"\u00b7\u0000\u0000\u07ee\u0818\u0003\u00dcn\u0000\u07ef\u07f0\u0005\u00b1"+
"\u0000\u0000\u07f0\u07f2\u0005\u00b6\u0000\u0000\u07f1\u07f3\u0003\u00d8"+
"l\u0000\u07f2\u07f1\u0001\u0000\u0000\u0000\u07f2\u07f3\u0001\u0000\u0000"+
"\u0000\u07f3\u07f4\u0001\u0000\u0000\u0000\u07f4\u07f5\u0003\u00c2a\u0000"+
"\u07f5\u07f7\u0005\u00b7\u0000\u0000\u07f6\u07f8\u0003\u00dcn\u0000\u07f7"+
"\u07f6\u0001\u0000\u0000\u0000\u07f7\u07f8\u0001\u0000\u0000\u0000\u07f8"+
"\u0818\u0001\u0000\u0000\u0000\u07f9\u07fa\u0005\u0269\u0000\u0000\u07fa"+
"\u07fc\u0005\u00b6\u0000\u0000\u07fb\u07fd\u0003\u00d8l\u0000\u07fc\u07fb"+
"\u0001\u0000\u0000\u0000\u07fc\u07fd\u0001\u0000\u0000\u0000\u07fd\u07fe"+
"\u0001\u0000\u0000\u0000\u07fe\u07ff\u0003\u00c2a\u0000\u07ff\u0801\u0005"+
"\u00b7\u0000\u0000\u0800\u0802\u0003\u00dcn\u0000\u0801\u0800\u0001\u0000"+
"\u0000\u0000\u0801\u0802\u0001\u0000\u0000\u0000\u0802\u0818\u0001\u0000"+
"\u0000\u0000\u0803\u0804\u0005\u0097\u0000\u0000\u0804\u0806\u0005\u00b6"+
"\u0000\u0000\u0805\u0807\u0003\u00d8l\u0000\u0806\u0805\u0001\u0000\u0000"+
"\u0000\u0806\u0807\u0001\u0000\u0000\u0000\u0807\u0808\u0001\u0000\u0000"+
"\u0000\u0808\u0809\u0003\u00c2a\u0000\u0809\u080b\u0005\u00b7\u0000\u0000"+
"\u080a\u080c\u0003\u00dcn\u0000\u080b\u080a\u0001\u0000\u0000\u0000\u080b"+
"\u080c\u0001\u0000\u0000\u0000\u080c\u0818\u0001\u0000\u0000\u0000\u080d"+
"\u080e\u0005\u00b3\u0000\u0000\u080e\u0810\u0005\u00b6\u0000\u0000\u080f"+
"\u0811\u0003\u00d8l\u0000\u0810\u080f\u0001\u0000\u0000\u0000\u0810\u0811"+
"\u0001\u0000\u0000\u0000\u0811\u0812\u0001\u0000\u0000\u0000\u0812\u0813"+
"\u0003\u00c2a\u0000\u0813\u0815\u0005\u00b7\u0000\u0000\u0814\u0816\u0003"+
"\u00dcn\u0000\u0815\u0814\u0001\u0000\u0000\u0000\u0815\u0816\u0001\u0000"+
"\u0000\u0000\u0816\u0818\u0001\u0000\u0000\u0000\u0817\u077f\u0001\u0000"+
"\u0000\u0000\u0817\u0789\u0001\u0000\u0000\u0000\u0817\u0796\u0001\u0000"+
"\u0000\u0000\u0817\u07a3\u0001\u0000\u0000\u0000\u0817\u07a7\u0001\u0000"+
"\u0000\u0000\u0817\u07ab\u0001\u0000\u0000\u0000\u0817\u07b1\u0001\u0000"+
"\u0000\u0000\u0817\u07bf\u0001\u0000\u0000\u0000\u0817\u07c5\u0001\u0000"+
"\u0000\u0000\u0817\u07d3\u0001\u0000\u0000\u0000\u0817\u07dd\u0001\u0000"+
"\u0000\u0000\u0817\u07e7\u0001\u0000\u0000\u0000\u0817\u07eb\u0001\u0000"+
"\u0000\u0000\u0817\u07ef\u0001\u0000\u0000\u0000\u0817\u07f9\u0001\u0000"+
"\u0000\u0000\u0817\u0803\u0001\u0000\u0000\u0000\u0817\u080d\u0001\u0000"+
"\u0000\u0000\u0818\u00d7\u0001\u0000\u0000\u0000\u0819\u081a\u0007\u001f"+
"\u0000\u0000\u081a\u00d9\u0001\u0000\u0000\u0000\u081b\u081c\u0005\u01f2"+
"\u0000\u0000\u081c\u081d\u0005\u00f1\u0000\u0000\u081d\u081f\u0003\u00c2"+
"a\u0000\u081e\u0820\u0007 \u0000\u0000\u081f\u081e\u0001\u0000\u0000\u0000"+
"\u081f\u0820\u0001\u0000\u0000\u0000\u0820\u0828\u0001\u0000\u0000\u0000"+
"\u0821\u0822\u0005\u00b8\u0000\u0000\u0822\u0824\u0003\u00c2a\u0000\u0823"+
"\u0825\u0007 \u0000\u0000\u0824\u0823\u0001\u0000\u0000\u0000\u0824\u0825"+
"\u0001\u0000\u0000\u0000\u0825\u0827\u0001\u0000\u0000\u0000\u0826\u0821"+
"\u0001\u0000\u0000\u0000\u0827\u082a\u0001\u0000\u0000\u0000\u0828\u0826"+
"\u0001\u0000\u0000\u0000\u0828\u0829\u0001\u0000\u0000\u0000\u0829\u00db"+
"\u0001\u0000\u0000\u0000\u082a\u0828\u0001\u0000\u0000\u0000\u082b\u082c"+
"\u0005\u01f5\u0000\u0000\u082c\u082e\u0005\u00b6\u0000\u0000\u082d\u082f"+
"\u0003\u00deo\u0000\u082e\u082d\u0001\u0000\u0000\u0000\u082e\u082f\u0001"+
"\u0000\u0000\u0000\u082f\u0831\u0001\u0000\u0000\u0000\u0830\u0832\u0003"+
"\u00dam\u0000\u0831\u0830\u0001\u0000\u0000\u0000\u0831\u0832\u0001\u0000"+
"\u0000\u0000\u0832\u0833\u0001\u0000\u0000\u0000\u0833\u0834\u0005\u00b7"+
"\u0000\u0000\u0834\u00dd\u0001\u0000\u0000\u0000\u0835\u0836\u0005\u01f9"+
"\u0000\u0000\u0836\u0837\u0005\u00f1\u0000\u0000\u0837\u083c\u0003\u00c2"+
"a\u0000\u0838\u0839\u0005\u00b8\u0000\u0000\u0839\u083b\u0003\u00c2a\u0000"+
"\u083a\u0838\u0001\u0000\u0000\u0000\u083b\u083e\u0001\u0000\u0000\u0000"+
"\u083c\u083a\u0001\u0000\u0000\u0000\u083c\u083d\u0001\u0000\u0000\u0000"+
"\u083d\u00df\u0001\u0000\u0000\u0000\u083e\u083c\u0001\u0000\u0000\u0000"+
"\u083f\u0908\u0005\u00a0\u0000\u0000\u0840\u0841\u0005\u00f7\u0000\u0000"+
"\u0841\u0842\u0005\u00b6\u0000\u0000\u0842\u0843\u0003\u00c2a\u0000\u0843"+
"\u0844\u0005\u00d1\u0000\u0000\u0844\u0846\u0003B!\u0000\u0845\u0847\u0003"+
"D\"\u0000\u0846\u0845\u0001\u0000\u0000\u0000\u0846\u0847\u0001\u0000"+
"\u0000\u0000\u0847\u0848\u0001\u0000\u0000\u0000\u0848\u0849\u0005\u00b7"+
"\u0000\u0000\u0849\u0908\u0001\u0000\u0000\u0000\u084a\u084b\u0005\u0118"+
"\u0000\u0000\u084b\u084e\u0005\u00b6\u0000\u0000\u084c\u084f\u0003\u00c2"+
"a\u0000\u084d\u084f\u0005\u02b9\u0000\u0000\u084e\u084c\u0001\u0000\u0000"+
"\u0000\u084e\u084d\u0001\u0000\u0000\u0000\u084f\u0850\u0001\u0000\u0000"+
"\u0000\u0850\u0908\u0005\u00b7\u0000\u0000\u0851\u0908\u0005\u0120\u0000"+
"\u0000\u0852\u0853\u0005\u011e\u0000\u0000\u0853\u0908\u0005\u0127\u0000"+
"\u0000\u0854\u0858\u0005\u0122\u0000\u0000\u0855\u0856\u0005\u011e\u0000"+
"\u0000\u0856\u0858\u0005\u027c\u0000\u0000\u0857\u0854\u0001\u0000\u0000"+
"\u0000\u0857\u0855\u0001\u0000\u0000\u0000\u0858\u085d\u0001\u0000\u0000"+
"\u0000\u0859\u085a\u0005\u00b6\u0000\u0000\u085a\u085b\u0003\u00c2a\u0000"+
"\u085b\u085c\u0005\u00b7\u0000\u0000\u085c\u085e\u0001\u0000\u0000\u0000"+
"\u085d\u0859\u0001\u0000\u0000\u0000\u085d\u085e\u0001\u0000\u0000\u0000"+
"\u085e\u0908\u0001\u0000\u0000\u0000\u085f\u0908\u0005\u0123\u0000\u0000"+
"\u0860\u0861\u0005\u011e\u0000\u0000\u0861\u0908\u0005\u0296\u0000\u0000"+
"\u0862\u0863\u0005\u00a7\u0000\u0000\u0863\u0864\u0005\u00b6\u0000\u0000"+
"\u0864\u0871\u0003\u00c2a\u0000\u0865\u0866\u0005\u00b8\u0000\u0000\u0866"+
"\u086e\u0003\u00c2a\u0000\u0867\u0868\u0005\u00b8\u0000\u0000\u0868\u0869"+
"\u0003\u00c2a\u0000\u0869\u086a\u0005\u02b0\u0000\u0000\u086a\u086b\u0003"+
"\u00c2a\u0000\u086b\u086d\u0001\u0000\u0000\u0000\u086c\u0867\u0001\u0000"+
"\u0000\u0000\u086d\u0870\u0001\u0000\u0000\u0000\u086e\u086c\u0001\u0000"+
"\u0000\u0000\u086e\u086f\u0001\u0000\u0000\u0000\u086f\u0872\u0001\u0000"+
"\u0000\u0000\u0870\u086e\u0001\u0000\u0000\u0000\u0871\u0865\u0001\u0000"+
"\u0000\u0000\u0871\u0872\u0001\u0000\u0000\u0000\u0872\u0873\u0001\u0000"+
"\u0000\u0000\u0873\u0874\u0005\u00b7\u0000\u0000\u0874\u0908\u0001\u0000"+
"\u0000\u0000\u0875\u0876\u0005\u00a8\u0000\u0000\u0876\u0877\u0005\u00b6"+
"\u0000\u0000\u0877\u0884\u0003\u00c2a\u0000\u0878\u0879\u0005\u00b8\u0000"+
"\u0000\u0879\u0881\u0003\u00c2a\u0000\u087a\u087b\u0005\u00b8\u0000\u0000"+
"\u087b\u087c\u0003\u00c2a\u0000\u087c\u087d\u0005\u02b0\u0000\u0000\u087d"+
"\u087e\u0003\u00c2a\u0000\u087e\u0880\u0001\u0000\u0000\u0000\u087f\u087a"+
"\u0001\u0000\u0000\u0000\u0880\u0883\u0001\u0000\u0000\u0000\u0881\u087f"+
"\u0001\u0000\u0000\u0000\u0881\u0882\u0001\u0000\u0000\u0000\u0882\u0885"+
"\u0001\u0000\u0000\u0000\u0883\u0881\u0001\u0000\u0000\u0000\u0884\u0878"+
"\u0001\u0000\u0000\u0000\u0884\u0885\u0001\u0000\u0000\u0000\u0885\u0886"+
"\u0001\u0000\u0000\u0000\u0886\u0887\u0005\u00b7\u0000\u0000\u0887\u0908"+
"\u0001\u0000\u0000\u0000\u0888\u0889\u0005\u00a9\u0000\u0000\u0889\u088a"+
"\u0005\u00b6\u0000\u0000\u088a\u0897\u0003\u00c2a\u0000\u088b\u088c\u0005"+
"\u00b8\u0000\u0000\u088c\u0894\u0003\u00c2a\u0000\u088d\u088e\u0005\u00b8"+
"\u0000\u0000\u088e\u088f\u0003\u00c2a\u0000\u088f\u0890\u0005\u02b0\u0000"+
"\u0000\u0890\u0891\u0003\u00c2a\u0000\u0891\u0893\u0001\u0000\u0000\u0000"+
"\u0892\u088d\u0001\u0000\u0000\u0000\u0893\u0896\u0001\u0000\u0000\u0000"+
"\u0894\u0892\u0001\u0000\u0000\u0000\u0894\u0895\u0001\u0000\u0000\u0000"+
"\u0895\u0898\u0001\u0000\u0000\u0000\u0896\u0894\u0001\u0000\u0000\u0000"+
"\u0897\u088b\u0001\u0000\u0000\u0000\u0897\u0898\u0001\u0000\u0000\u0000"+
"\u0898\u0899\u0001\u0000\u0000\u0000\u0899\u089a\u0005\u00b7\u0000\u0000"+
"\u089a\u0908\u0001\u0000\u0000\u0000\u089b\u089c\u0005\u00aa\u0000\u0000"+
"\u089c\u089d\u0005\u00b6\u0000\u0000\u089d\u08aa\u0003\u00c2a\u0000\u089e"+
"\u089f\u0005\u00b8\u0000\u0000\u089f\u08a7\u0003\u00c2a\u0000\u08a0\u08a1"+
"\u0005\u00b8\u0000\u0000\u08a1\u08a2\u0003\u00c2a\u0000\u08a2\u08a3\u0005"+
"\u02b0\u0000\u0000\u08a3\u08a4\u0003\u00c2a\u0000\u08a4\u08a6\u0001\u0000"+
"\u0000\u0000\u08a5\u08a0\u0001\u0000\u0000\u0000\u08a6\u08a9\u0001\u0000"+
"\u0000\u0000\u08a7\u08a5\u0001\u0000\u0000\u0000\u08a7\u08a8\u0001\u0000"+
"\u0000\u0000\u08a8\u08ab\u0001\u0000\u0000\u0000\u08a9\u08a7\u0001\u0000"+
"\u0000\u0000\u08aa\u089e\u0001\u0000\u0000\u0000\u08aa\u08ab\u0001\u0000"+
"\u0000\u0000\u08ab\u08ac\u0001\u0000\u0000\u0000\u08ac\u08ad\u0005\u00b7"+
"\u0000\u0000\u08ad\u0908\u0001\u0000\u0000\u0000\u08ae\u08af\u0005\u00ab"+
"\u0000\u0000\u08af\u08b0\u0005\u00b6\u0000\u0000\u08b0\u08bd\u0003\u00c2"+
"a\u0000\u08b1\u08b2\u0005\u00b8\u0000\u0000\u08b2\u08ba\u0003\u00c2a\u0000"+
"\u08b3\u08b4\u0005\u00b8\u0000\u0000\u08b4\u08b5\u0003\u00c2a\u0000\u08b5"+
"\u08b6\u0005\u02b0\u0000\u0000\u08b6\u08b7\u0003\u00c2a\u0000\u08b7\u08b9"+
"\u0001\u0000\u0000\u0000\u08b8\u08b3\u0001\u0000\u0000\u0000\u08b9\u08bc"+
"\u0001\u0000\u0000\u0000\u08ba\u08b8\u0001\u0000\u0000\u0000\u08ba\u08bb"+
"\u0001\u0000\u0000\u0000\u08bb\u08be\u0001\u0000\u0000\u0000\u08bc\u08ba"+
"\u0001\u0000\u0000\u0000\u08bd\u08b1\u0001\u0000\u0000\u0000\u08bd\u08be"+
"\u0001\u0000\u0000\u0000\u08be\u08bf\u0001\u0000\u0000\u0000\u08bf\u08c0"+
"\u0005\u00b7\u0000\u0000\u08c0\u0908\u0001\u0000\u0000\u0000\u08c1\u08c2"+
"\u0005\u00ac\u0000\u0000\u08c2\u08c3\u0005\u00b6\u0000\u0000\u08c3\u08d0"+
"\u0003\u00c2a\u0000\u08c4\u08c5\u0005\u00b8\u0000\u0000\u08c5\u08cd\u0003"+
"\u00c2a\u0000\u08c6\u08c7\u0005\u00b8\u0000\u0000\u08c7\u08c8\u0003\u00c2"+
"a\u0000\u08c8\u08c9\u0005\u02b0\u0000\u0000\u08c9\u08ca\u0003\u00c2a\u0000"+
"\u08ca\u08cc\u0001\u0000\u0000\u0000\u08cb\u08c6\u0001\u0000\u0000\u0000"+
"\u08cc\u08cf\u0001\u0000\u0000\u0000\u08cd\u08cb\u0001\u0000\u0000\u0000"+
"\u08cd\u08ce\u0001\u0000\u0000\u0000\u08ce\u08d1\u0001\u0000\u0000\u0000"+
"\u08cf\u08cd\u0001\u0000\u0000\u0000\u08d0\u08c4\u0001\u0000\u0000\u0000"+
"\u08d0\u08d1\u0001\u0000\u0000\u0000\u08d1\u08d2\u0001\u0000\u0000\u0000"+
"\u08d2\u08d3\u0005\u00b7\u0000\u0000\u08d3\u0908\u0001\u0000\u0000\u0000"+
"\u08d4\u08d5\u0005\u00ad\u0000\u0000\u08d5\u08d6\u0005\u00b6\u0000\u0000"+
"\u08d6\u08de\u0003\u00c2a\u0000\u08d7\u08d8\u0005\u00b8\u0000\u0000\u08d8"+
"\u08d9\u0003\u00c2a\u0000\u08d9\u08da\u0005\u02b0\u0000\u0000\u08da\u08db"+
"\u0003\u00c2a\u0000\u08db\u08dd\u0001\u0000\u0000\u0000\u08dc\u08d7\u0001"+
"\u0000\u0000\u0000\u08dd\u08e0\u0001\u0000\u0000\u0000\u08de\u08dc\u0001"+
"\u0000\u0000\u0000\u08de\u08df\u0001\u0000\u0000\u0000\u08df\u08e1\u0001"+
"\u0000\u0000\u0000\u08e0\u08de\u0001\u0000\u0000\u0000\u08e1\u08e2\u0005"+
"\u00b7\u0000\u0000\u08e2\u0908\u0001\u0000\u0000\u0000\u08e3\u08e4\u0005"+
"\u00ae\u0000\u0000\u08e4\u08e5\u0005\u00b6\u0000\u0000\u08e5\u08eb\u0003"+
"\u00c2a\u0000\u08e6\u08e7\u0005\u00b8\u0000\u0000\u08e7\u08e8\u0003\u00c2"+
"a\u0000\u08e8\u08e9\u0005\u02b0\u0000\u0000\u08e9\u08ea\u0003\u00c2a\u0000"+
"\u08ea\u08ec\u0001\u0000\u0000\u0000\u08eb\u08e6\u0001\u0000\u0000\u0000"+
"\u08ec\u08ed\u0001\u0000\u0000\u0000\u08ed\u08eb\u0001\u0000\u0000\u0000"+
"\u08ed\u08ee\u0001\u0000\u0000\u0000\u08ee\u08f1\u0001\u0000\u0000\u0000"+
"\u08ef\u08f0\u0005\u00b8\u0000\u0000\u08f0\u08f2\u0003\u00c2a\u0000\u08f1"+
"\u08ef\u0001\u0000\u0000\u0000\u08f1\u08f2\u0001\u0000\u0000\u0000\u08f2"+
"\u08f3\u0001\u0000\u0000\u0000\u08f3\u08f4\u0005\u00b7\u0000\u0000\u08f4"+
"\u0908\u0001\u0000\u0000\u0000\u08f5\u08f6\u0005\u0285\u0000\u0000\u08f6"+
"\u08f7\u0005\u00b6\u0000\u0000\u08f7\u08f8\u0003\u00c2a\u0000\u08f8\u08f9"+
"\u0005\u00b7\u0000\u0000\u08f9\u0908\u0001\u0000\u0000\u0000\u08fa\u08fb"+
"\u0005\u008f\u0000\u0000\u08fb\u08fc\u0005\u00b6\u0000\u0000\u08fc\u08fd"+
"\u0003\u00c2a\u0000\u08fd\u08fe\u0005\u0172\u0000\u0000\u08fe\u0901\u0003"+
"\u00c2a\u0000\u08ff\u0900\u0005\u016d\u0000\u0000\u0900\u0902\u0003\u00c2"+
"a\u0000\u0901\u08ff\u0001\u0000\u0000\u0000\u0901\u0902\u0001\u0000\u0000"+
"\u0000\u0902\u0903\u0001\u0000\u0000\u0000\u0903\u0904\u0005\u00b7\u0000"+
"\u0000\u0904\u0908\u0001\u0000\u0000\u0000\u0905\u0908\u0005\u00b2\u0000"+
"\u0000\u0906\u0908\u0005\u0296\u0000\u0000\u0907\u083f\u0001\u0000\u0000"+
"\u0000\u0907\u0840\u0001\u0000\u0000\u0000\u0907\u084a\u0001\u0000\u0000"+
"\u0000\u0907\u0851\u0001\u0000\u0000\u0000\u0907\u0852\u0001\u0000\u0000"+
"\u0000\u0907\u0857\u0001\u0000\u0000\u0000\u0907\u085f\u0001\u0000\u0000"+
"\u0000\u0907\u0860\u0001\u0000\u0000\u0000\u0907\u0862\u0001\u0000\u0000"+
"\u0000\u0907\u0875\u0001\u0000\u0000\u0000\u0907\u0888\u0001\u0000\u0000"+
"\u0000\u0907\u089b\u0001\u0000\u0000\u0000\u0907\u08ae\u0001\u0000\u0000"+
"\u0000\u0907\u08c1\u0001\u0000\u0000\u0000\u0907\u08d4\u0001\u0000\u0000"+
"\u0000\u0907\u08e3\u0001\u0000\u0000\u0000\u0907\u08f5\u0001\u0000\u0000"+
"\u0000\u0907\u08fa\u0001\u0000\u0000\u0000\u0907\u0905\u0001\u0000\u0000"+
"\u0000\u0907\u0906\u0001\u0000\u0000\u0000\u0908\u00e1\u0001\u0000\u0000"+
"\u0000\u0909\u090a\u0003\u0250\u0128\u0000\u090a\u090c\u0005\u00b6\u0000"+
"\u0000\u090b\u090d\u0003\u00eau\u0000\u090c\u090b\u0001\u0000\u0000\u0000"+
"\u090c\u090d\u0001\u0000\u0000\u0000\u090d\u090e\u0001\u0000\u0000\u0000"+
"\u090e\u090f\u0005\u00b7\u0000\u0000\u090f\u00e3\u0001\u0000\u0000\u0000"+
"\u0910\u0913\u0003\u00e6s\u0000\u0911\u0913\u0003\u00e8t\u0000\u0912\u0910"+
"\u0001\u0000\u0000\u0000\u0912\u0911\u0001\u0000\u0000\u0000\u0913\u00e5"+
"\u0001\u0000\u0000\u0000\u0914\u0917\u0003\u00fa}\u0000\u0915\u0917\u0003"+
"\u00e2q\u0000\u0916\u0914\u0001\u0000\u0000\u0000\u0916\u0915\u0001\u0000"+
"\u0000\u0000\u0917\u0918\u0001\u0000\u0000\u0000\u0918\u0919\u0005\u00b9"+
"\u0000\u0000\u0919\u091a\u0003\u00e2q\u0000\u091a\u00e7\u0001\u0000\u0000"+
"\u0000\u091b\u091e\u0003\u00fa}\u0000\u091c\u091e\u0003\u00e2q\u0000\u091d"+
"\u091b\u0001\u0000\u0000\u0000\u091d\u091c\u0001\u0000\u0000\u0000\u091e"+
"\u091f\u0001\u0000\u0000\u0000\u091f\u0920\u0005\u00b9\u0000\u0000\u0920"+
"\u0921\u0003\u00fa}\u0000\u0921\u00e9\u0001\u0000\u0000\u0000\u0922\u0927"+
"\u0003\u00ecv\u0000\u0923\u0924\u0005\u00b8\u0000\u0000\u0924\u0926\u0003"+
"\u00ecv\u0000\u0925\u0923\u0001\u0000\u0000\u0000\u0926\u0929\u0001\u0000"+
"\u0000\u0000\u0927\u0925\u0001\u0000\u0000\u0000\u0927\u0928\u0001\u0000"+
"\u0000\u0000\u0928\u00eb\u0001\u0000\u0000\u0000\u0929\u0927\u0001\u0000"+
"\u0000\u0000\u092a\u0930\u0004v\u0007\u0000\u092b\u092c\u0003\u00fa}\u0000"+
"\u092c\u092e\u0005\u02b0\u0000\u0000\u092d\u092f\u0005\u02b5\u0000\u0000"+
"\u092e\u092d\u0001\u0000\u0000\u0000\u092e\u092f\u0001\u0000\u0000\u0000"+
"\u092f\u0931\u0001\u0000\u0000\u0000\u0930\u092b\u0001\u0000\u0000\u0000"+
"\u0930\u0931\u0001\u0000\u0000\u0000\u0931\u0932\u0001\u0000\u0000\u0000"+
"\u0932\u0933\u0003\u00c2a\u0000\u0933\u00ed\u0001\u0000\u0000\u0000\u0934"+
"\u0935\u0005\u02bf\u0000\u0000\u0935\u0936\u0003\u00f0x\u0000\u0936\u0937"+
"\u0005\u00b5\u0000\u0000\u0937\u093a\u0001\u0000\u0000\u0000\u0938\u093a"+
"\u0003\u00f2y\u0000\u0939\u0934\u0001\u0000\u0000\u0000\u0939\u0938\u0001"+
"\u0000\u0000\u0000\u093a\u00ef\u0001\u0000\u0000\u0000\u093b\u093d\t\u0000"+
"\u0000\u0000\u093c\u093b\u0001\u0000\u0000\u0000\u093d\u0940\u0001\u0000"+
"\u0000\u0000\u093e\u093f\u0001\u0000\u0000\u0000\u093e\u093c\u0001\u0000"+
"\u0000\u0000\u093f\u00f1\u0001\u0000\u0000\u0000\u0940\u093e\u0001\u0000"+
"\u0000\u0000\u0941\u0942\u0005;\u0000\u0000\u0942\u0943\u0003\u00c2a\u0000"+
"\u0943\u00f3\u0001\u0000\u0000\u0000\u0944\u0953\u0005\u02ca\u0000\u0000"+
"\u0945\u0949\u0005\u02ba\u0000\u0000\u0946\u0947\u0005\u00b9\u0000\u0000"+
"\u0947\u0949\u0005\u02ba\u0000\u0000\u0948\u0945\u0001\u0000\u0000\u0000"+
"\u0948\u0946\u0001\u0000\u0000\u0000\u0948\u0949\u0001\u0000\u0000\u0000"+
"\u0949\u094a\u0001\u0000\u0000\u0000\u094a\u094f\u0003\u00fc~\u0000\u094b"+
"\u094c\u0005\u02ba\u0000\u0000\u094c\u094e\u0003\u00fc~\u0000\u094d\u094b"+
"\u0001\u0000\u0000\u0000\u094e\u0951\u0001\u0000\u0000\u0000\u094f\u094d"+
"\u0001\u0000\u0000\u0000\u094f\u0950\u0001\u0000\u0000\u0000\u0950\u0953"+
"\u0001\u0000\u0000\u0000\u0951\u094f\u0001\u0000\u0000\u0000\u0952\u0944"+
"\u0001\u0000\u0000\u0000\u0952\u0948\u0001\u0000\u0000\u0000\u0953\u00f5"+
"\u0001\u0000\u0000\u0000\u0954\u0955\u0005\u0127\u0000\u0000\u0955\u0956"+
"\u0003\u00fe\u007f\u0000\u0956\u00f7\u0001\u0000\u0000\u0000\u0957\u0958"+
"\u0005\u027c\u0000\u0000\u0958\u0959\u0003\u00fe\u007f\u0000\u0959\u00f9"+
"\u0001\u0000\u0000\u0000\u095a\u095c\u0005\u02b8\u0000\u0000\u095b\u095a"+
"\u0001\u0000\u0000\u0000\u095b\u095c\u0001\u0000\u0000\u0000\u095c\u0960"+
"\u0001\u0000\u0000\u0000\u095d\u0961\u0005\u02d3\u0000\u0000\u095e\u0961"+
"\u0003\u0108\u0084\u0000\u095f\u0961\u0003\u02d2\u0169\u0000\u0960\u095d"+
"\u0001\u0000\u0000\u0000\u0960\u095e\u0001\u0000\u0000\u0000\u0960\u095f"+
"\u0001\u0000\u0000\u0000\u0961\u00fb\u0001\u0000\u0000\u0000\u0962\u0967"+
"\u0003\u00fa}\u0000\u0963\u0964\u0005\u00b9\u0000\u0000\u0964\u0966\u0003"+
"\u00fa}\u0000\u0965\u0963\u0001\u0000\u0000\u0000\u0966\u0969\u0001\u0000"+
"\u0000\u0000\u0967\u0965\u0001\u0000\u0000\u0000\u0967\u0968\u0001\u0000"+
"\u0000\u0000\u0968\u00fd\u0001\u0000\u0000\u0000\u0969\u0967\u0001\u0000"+
"\u0000\u0000\u096a\u096b\u0005\u02ca\u0000\u0000\u096b\u00ff\u0001\u0000"+
"\u0000\u0000\u096c\u096e\u0007\u001b\u0000\u0000\u096d\u096c\u0001\u0000"+
"\u0000\u0000\u096d\u096e\u0001\u0000\u0000\u0000\u096e\u096f\u0001\u0000"+
"\u0000\u0000\u096f\u0970\u0005\u02cf\u0000\u0000\u0970\u0101\u0001\u0000"+
"\u0000\u0000\u0971\u0973\u0007\u001b\u0000\u0000\u0972\u0971\u0001\u0000"+
"\u0000\u0000\u0972\u0973\u0001\u0000\u0000\u0000\u0973\u0974\u0001\u0000"+
"\u0000\u0000\u0974\u0975\u0005\u02d1\u0000\u0000\u0975\u0103\u0001\u0000"+
"\u0000\u0000\u0976\u0977\u0007!\u0000\u0000\u0977\u0105\u0001\u0000\u0000"+
"\u0000\u0978\u0979\u0005\u01e8\u0000\u0000\u0979\u0107\u0001\u0000\u0000"+
"\u0000\u097a\u097b\u0007\"\u0000\u0000\u097b\u0109\u0001\u0000\u0000\u0000"+
"\u097c\u097e\u0005\u00b5\u0000\u0000\u097d\u097c\u0001\u0000\u0000\u0000"+
"\u097e\u0981\u0001\u0000\u0000\u0000\u097f\u097d\u0001\u0000\u0000\u0000"+
"\u097f\u0980\u0001\u0000\u0000\u0000\u0980\u0983\u0001\u0000\u0000\u0000"+
"\u0981\u097f\u0001\u0000\u0000\u0000\u0982\u0984\u0003\u0110\u0088\u0000"+
"\u0983\u0982\u0001\u0000\u0000\u0000\u0983\u0984\u0001\u0000\u0000\u0000"+
"\u0984\u098d\u0001\u0000\u0000\u0000\u0985\u0987\u0005\u00b5\u0000\u0000"+
"\u0986\u0985\u0001\u0000\u0000\u0000\u0987\u0988\u0001\u0000\u0000\u0000"+
"\u0988\u0986\u0001\u0000\u0000\u0000\u0988\u0989\u0001\u0000\u0000\u0000"+
"\u0989\u098a\u0001\u0000\u0000\u0000\u098a\u098c\u0003\u0110\u0088\u0000"+
"\u098b\u0986\u0001\u0000\u0000\u0000\u098c\u098f\u0001\u0000\u0000\u0000"+
"\u098d\u098b\u0001\u0000\u0000\u0000\u098d\u098e\u0001\u0000\u0000\u0000"+
"\u098e\u0993\u0001\u0000\u0000\u0000\u098f\u098d\u0001\u0000\u0000\u0000"+
"\u0990\u0992\u0005\u00b5\u0000\u0000\u0991\u0990\u0001\u0000\u0000\u0000"+
"\u0992\u0995\u0001\u0000\u0000\u0000\u0993\u0991\u0001\u0000\u0000\u0000"+
"\u0993\u0994\u0001\u0000\u0000\u0000\u0994\u0996\u0001\u0000\u0000\u0000"+
"\u0995\u0993\u0001\u0000\u0000\u0000\u0996\u0997\u0005\u0000\u0000\u0001"+
"\u0997\u010b\u0001\u0000\u0000\u0000\u0998\u099a\u0005\u00b5\u0000\u0000"+
"\u0999\u0998\u0001\u0000\u0000\u0000\u099a\u099d\u0001\u0000\u0000\u0000"+
"\u099b\u0999\u0001\u0000\u0000\u0000\u099b\u099c\u0001\u0000\u0000\u0000"+
"\u099c\u099f\u0001\u0000\u0000\u0000\u099d\u099b\u0001\u0000\u0000\u0000"+
"\u099e\u09a0\u0003\u0110\u0088\u0000\u099f\u099e\u0001\u0000\u0000\u0000"+
"\u099f\u09a0\u0001\u0000\u0000\u0000\u09a0\u09a4\u0001\u0000\u0000\u0000"+
"\u09a1\u09a3\u0005\u00b5\u0000\u0000\u09a2\u09a1\u0001\u0000\u0000\u0000"+
"\u09a3\u09a6\u0001\u0000\u0000\u0000\u09a4\u09a2\u0001\u0000\u0000\u0000"+
"\u09a4\u09a5\u0001\u0000\u0000\u0000\u09a5\u09a7\u0001\u0000\u0000\u0000"+
"\u09a6\u09a4\u0001\u0000\u0000\u0000\u09a7\u09a8\u0005\u0000\u0000\u0001"+
"\u09a8\u010d\u0001\u0000\u0000\u0000\u09a9\u09aa\u0003\u027c\u013e\u0000"+
"\u09aa\u09ab\u0005\u0000\u0000\u0001\u09ab\u010f\u0001\u0000\u0000\u0000"+
"\u09ac\u09f7\u0003\u0112\u0089\u0000\u09ad\u09ae\u0005\u00f4\u0000\u0000"+
"\u09ae\u09af\u0003\u0250\u0128\u0000\u09af\u09b8\u0005\u00b6\u0000\u0000"+
"\u09b0\u09b5\u0003\u027c\u013e\u0000\u09b1\u09b2\u0005\u00b8\u0000\u0000"+
"\u09b2\u09b4\u0003\u027c\u013e\u0000\u09b3\u09b1\u0001\u0000\u0000\u0000"+
"\u09b4\u09b7\u0001\u0000\u0000\u0000\u09b5\u09b3\u0001\u0000\u0000\u0000"+
"\u09b5\u09b6\u0001\u0000\u0000\u0000\u09b6\u09b9\u0001\u0000\u0000\u0000"+
"\u09b7\u09b5\u0001\u0000\u0000\u0000\u09b8\u09b0\u0001\u0000\u0000\u0000"+
"\u09b8\u09b9\u0001\u0000\u0000\u0000\u09b9\u09ba\u0001\u0000\u0000\u0000"+
"\u09ba\u09bb\u0005\u00b7\u0000\u0000\u09bb\u09f7\u0001\u0000\u0000\u0000"+
"\u09bc\u09c4\u0005\u00c9\u0000\u0000\u09bd\u09c0\u0005\u0119\u0000\u0000"+
"\u09be\u09bf\u0005\u01f1\u0000\u0000\u09bf\u09c1\u0005\u022b\u0000\u0000"+
"\u09c0\u09be\u0001\u0000\u0000\u0000\u09c0\u09c1\u0001\u0000\u0000\u0000"+
"\u09c1\u09c4\u0001\u0000\u0000\u0000\u09c2\u09c4\u0005\u022b\u0000\u0000"+
"\u09c3\u09bc\u0001\u0000\u0000\u0000\u09c3\u09bd\u0001\u0000\u0000\u0000"+
"\u09c3\u09c2\u0001\u0000\u0000\u0000\u09c4\u09c5\u0001\u0000\u0000\u0000"+
"\u09c5\u09c6\u0007\f\u0000\u0000\u09c6\u09c7\u0003\u0250\u0128\u0000\u09c7"+
"\u09cb\u0005\u00b6\u0000\u0000\u09c8\u09ca\t\u0000\u0000\u0000\u09c9\u09c8"+
"\u0001\u0000\u0000\u0000\u09ca\u09cd\u0001\u0000\u0000\u0000\u09cb\u09cc"+
"\u0001\u0000\u0000\u0000\u09cb\u09c9\u0001\u0000\u0000\u0000\u09cc\u09ce"+
"\u0001\u0000\u0000\u0000\u09cd\u09cb\u0001\u0000\u0000\u0000\u09ce\u09d2"+
"\u0005\u00b7\u0000\u0000\u09cf\u09d1\t\u0000\u0000\u0000\u09d0\u09cf\u0001"+
"\u0000\u0000\u0000\u09d1\u09d4\u0001\u0000\u0000\u0000\u09d2\u09d3\u0001"+
"\u0000\u0000\u0000\u09d2\u09d0\u0001\u0000\u0000\u0000\u09d3\u09f7\u0001"+
"\u0000\u0000\u0000\u09d4\u09d2\u0001\u0000\u0000\u0000\u09d5\u09d6\u0005"+
"\u0144\u0000\u0000\u09d6\u09d9\u0007\f\u0000\u0000\u09d7\u09d8\u0005\u018e"+
"\u0000\u0000\u09d8\u09da\u0005\u015b\u0000\u0000\u09d9\u09d7\u0001\u0000"+
"\u0000\u0000\u09d9\u09da\u0001\u0000\u0000\u0000\u09da\u09db\u0001\u0000"+
"\u0000\u0000\u09db\u09f7\u0003\u0250\u0128\u0000\u09dc\u09dd\u0005\u0254"+
"\u0000\u0000\u09dd\u09de\u0007#\u0000\u0000\u09de\u09e2\u0005\u0262\u0000"+
"\u0000\u09df\u09e0\u0005\u01b8\u0000\u0000\u09e0\u09e3\u0003\u0288\u0144"+
"\u0000\u09e1\u09e3\u0003\u0204\u0102\u0000\u09e2\u09df\u0001\u0000\u0000"+
"\u0000\u09e2\u09e1\u0001\u0000\u0000\u0000\u09e2\u09e3\u0001\u0000\u0000"+
"\u0000\u09e3\u09f7\u0001\u0000\u0000\u0000\u09e4\u09e5\u0005\u0254\u0000"+
"\u0000\u09e5\u09e6\u0005\u0119\u0000\u0000\u09e6\u09e7\u0005\u0213\u0000"+
"\u0000\u09e7\u09f7\u0003\u0250\u0128\u0000\u09e8\u09ea\u0005\u00c3\u0000"+
"\u0000\u09e9\u09e8\u0001\u0000\u0000\u0000\u09e9\u09ea\u0001\u0000\u0000"+
"\u0000\u09ea\u09eb\u0001\u0000\u0000\u0000\u09eb\u09ec\u0005\u0254\u0000"+
"\u0000\u09ec\u09ed\u0007\r\u0000\u0000\u09ed\u09f0\u0005\u010f\u0000\u0000"+
"\u09ee\u09ef\u0005\u01b8\u0000\u0000\u09ef\u09f1\u0003\u0288\u0144\u0000"+
"\u09f0\u09ee\u0001\u0000\u0000\u0000\u09f0\u09f1\u0001\u0000\u0000\u0000"+
"\u09f1\u09f4\u0001\u0000\u0000\u0000\u09f2\u09f3\u0005\u0172\u0000\u0000"+
"\u09f3\u09f5\u0005\u02cf\u0000\u0000\u09f4\u09f2\u0001\u0000\u0000\u0000"+
"\u09f4\u09f5\u0001\u0000\u0000\u0000\u09f5\u09f7\u0001\u0000\u0000\u0000"+
"\u09f6\u09ac\u0001\u0000\u0000\u0000\u09f6\u09ad\u0001\u0000\u0000\u0000"+
"\u09f6\u09c3\u0001\u0000\u0000\u0000\u09f6\u09d5\u0001\u0000\u0000\u0000"+
"\u09f6\u09dc\u0001\u0000\u0000\u0000\u09f6\u09e4\u0001\u0000\u0000\u0000"+
"\u09f6\u09e9\u0001\u0000\u0000\u0000\u09f7\u0111\u0001\u0000\u0000\u0000"+
"\u09f8\u09fa\u0003\u01ce\u00e7\u0000\u09f9\u09f8\u0001\u0000\u0000\u0000"+
"\u09f9\u09fa\u0001\u0000\u0000\u0000\u09fa\u09fb\u0001\u0000\u0000\u0000"+
"\u09fb\u09fd\u0003\u01f0\u00f8\u0000\u09fc\u09fe\u0003\u01ee\u00f7\u0000"+
"\u09fd\u09fc\u0001\u0000\u0000\u0000\u09fd\u09fe\u0001\u0000\u0000\u0000"+
"\u09fe\u0a0a\u0001\u0000\u0000\u0000\u09ff\u0a0a\u0003\u011e\u008f\u0000"+
"\u0a00\u0a0a\u0003\u0120\u0090\u0000\u0a01\u0a0a\u0003\u0122\u0091\u0000"+
"\u0a02\u0a0a\u0003\u0116\u008b\u0000\u0a03\u0a0a\u0003\u0118\u008c\u0000"+
"\u0a04\u0a0a\u0003\u011a\u008d\u0000\u0a05\u0a0a\u0003\u0124\u0092\u0000"+
"\u0a06\u0a0a\u0003\u0126\u0093\u0000\u0a07\u0a0a\u0003\u0128\u0094\u0000"+
"\u0a08\u0a0a\u0003\u0114\u008a\u0000\u0a09\u09f9\u0001\u0000\u0000\u0000"+
"\u0a09\u09ff\u0001\u0000\u0000\u0000\u0a09\u0a00\u0001\u0000\u0000\u0000"+
"\u0a09\u0a01\u0001\u0000\u0000\u0000\u0a09\u0a02\u0001\u0000\u0000\u0000"+
"\u0a09\u0a03\u0001\u0000\u0000\u0000\u0a09\u0a04\u0001\u0000\u0000\u0000"+
"\u0a09\u0a05\u0001\u0000\u0000\u0000\u0a09\u0a06\u0001\u0000\u0000\u0000"+
"\u0a09\u0a07\u0001\u0000\u0000\u0000\u0a09\u0a08\u0001\u0000\u0000\u0000"+
"\u0a0a\u0113\u0001\u0000\u0000\u0000\u0a0b\u0a20\u0003\u0196\u00cb\u0000"+
"\u0a0c\u0a20\u0003\u01a2\u00d1\u0000\u0a0d\u0a20\u0003\u01a4\u00d2\u0000"+
"\u0a0e\u0a20\u0003\u01a6\u00d3\u0000\u0a0f\u0a20\u0003\u01aa\u00d5\u0000"+
"\u0a10\u0a20\u0003\u0184\u00c2\u0000\u0a11\u0a20\u0003\u017e\u00bf\u0000"+
"\u0a12\u0a20\u0003\u0180\u00c0\u0000\u0a13\u0a20\u0003\u015a\u00ad\u0000"+
"\u0a14\u0a20\u0003\u0154\u00aa\u0000\u0a15\u0a20\u0003\u014c\u00a6\u0000"+
"\u0a16\u0a20\u0003\u0152\u00a9\u0000\u0a17\u0a20\u0003\u014a\u00a5\u0000"+
"\u0a18\u0a20\u0003\u0148\u00a4\u0000\u0a19\u0a20\u0003\u0146\u00a3\u0000"+
"\u0a1a\u0a20\u0003\u0144\u00a2\u0000\u0a1b\u0a20\u0003\u0142\u00a1\u0000"+
"\u0a1c\u0a20\u0003\u0132\u0099\u0000\u0a1d\u0a20\u0003\u0130\u0098\u0000"+
"\u0a1e\u0a20\u0003\u012a\u0095\u0000\u0a1f\u0a0b\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a0c\u0001\u0000\u0000\u0000\u0a1f\u0a0d\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a0e\u0001\u0000\u0000\u0000\u0a1f\u0a0f\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a10\u0001\u0000\u0000\u0000\u0a1f\u0a11\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a12\u0001\u0000\u0000\u0000\u0a1f\u0a13\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a14\u0001\u0000\u0000\u0000\u0a1f\u0a15\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a16\u0001\u0000\u0000\u0000\u0a1f\u0a17\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a18\u0001\u0000\u0000\u0000\u0a1f\u0a19\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a1a\u0001\u0000\u0000\u0000\u0a1f\u0a1b\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a1c\u0001\u0000\u0000\u0000\u0a1f\u0a1d\u0001\u0000\u0000\u0000"+
"\u0a1f\u0a1e\u0001\u0000\u0000\u0000\u0a20\u0115\u0001\u0000\u0000\u0000"+
"\u0a21\u0a22\u0005\u0119\u0000\u0000\u0a22\u0a23\u0005\u01d0\u0000\u0000"+
"\u0a23\u0a27\u0005\u02a2\u0000\u0000\u0a24\u0a25\u0005\u018e\u0000\u0000"+
"\u0a25\u0a26\u0005\u01e7\u0000\u0000\u0a26\u0a28\u0005\u015b\u0000\u0000"+
"\u0a27\u0a24\u0001\u0000\u0000\u0000\u0a27\u0a28\u0001\u0000\u0000\u0000"+
"\u0a28\u0a29\u0001\u0000\u0000\u0000\u0a29\u0a2e\u0003\u0250\u0128\u0000"+
"\u0a2a\u0a2b\u0005\u00b6\u0000\u0000\u0a2b\u0a2c\u0003\u0252\u0129\u0000"+
"\u0a2c\u0a2d\u0005\u00b7\u0000\u0000\u0a2d\u0a2f\u0001\u0000\u0000\u0000"+
"\u0a2e\u0a2a\u0001\u0000\u0000\u0000\u0a2e\u0a2f\u0001\u0000\u0000\u0000"+
"\u0a2f\u0a31\u0001\u0000\u0000\u0000\u0a30\u0a32\u0003\u01b8\u00dc\u0000"+
"\u0a31\u0a30\u0001\u0000\u0000\u0000\u0a31\u0a32\u0001\u0000\u0000\u0000"+
"\u0a32\u0a3a\u0001\u0000\u0000\u0000\u0a33\u0a35\u0005\u0224\u0000\u0000"+
"\u0a34\u0a36\u0003\u01be\u00df\u0000\u0a35\u0a34\u0001\u0000\u0000\u0000"+
"\u0a35\u0a36\u0001\u0000\u0000\u0000\u0a36\u0a38\u0001\u0000\u0000\u0000"+
"\u0a37\u0a39\u0003\u01ba\u00dd\u0000\u0a38\u0a37\u0001\u0000\u0000\u0000"+
"\u0a38\u0a39\u0001\u0000\u0000\u0000\u0a39\u0a3b\u0001\u0000\u0000\u0000"+
"\u0a3a\u0a33\u0001\u0000\u0000\u0000\u0a3a\u0a3b\u0001\u0000\u0000\u0000"+
"\u0a3b\u0a41\u0001\u0000\u0000\u0000\u0a3c\u0a3e\u0005\u0148\u0000\u0000"+
"\u0a3d\u0a3c\u0001\u0000\u0000\u0000\u0a3d\u0a3e\u0001\u0000\u0000\u0000"+
"\u0a3e\u0a3f\u0001\u0000\u0000\u0000\u0a3f\u0a40\u0005\u01ac\u0000\u0000"+
"\u0a40\u0a42\u0003\u023a\u011d\u0000\u0a41\u0a3d\u0001\u0000\u0000\u0000"+
"\u0a41\u0a42\u0001\u0000\u0000\u0000\u0a42\u0a45\u0001\u0000\u0000\u0000"+
"\u0a43\u0a44\u0005\u0107\u0000\u0000\u0a44\u0a46\u0005\u02ca\u0000\u0000"+
"\u0a45\u0a43\u0001\u0000\u0000\u0000\u0a45\u0a46\u0001\u0000\u0000\u0000"+
"\u0a46\u0a4d\u0001\u0000\u0000\u0000\u0a47\u0a48\u0005\u01f9\u0000\u0000"+
"\u0a48\u0a49\u0005\u00f1\u0000\u0000\u0a49\u0a4a\u0005\u00b6\u0000\u0000"+
"\u0a4a\u0a4b\u0003\u01c0\u00e0\u0000\u0a4b\u0a4c\u0005\u00b7\u0000\u0000"+
"\u0a4c\u0a4e\u0001\u0000\u0000\u0000\u0a4d\u0a47\u0001\u0000\u0000\u0000"+
"\u0a4d\u0a4e\u0001\u0000\u0000\u0000\u0a4e\u0a5a\u0001\u0000\u0000\u0000"+
"\u0a4f\u0a50\u0005\u013e\u0000\u0000\u0a50\u0a54\u0005\u00f1\u0000\u0000"+
"\u0a51\u0a52\u0005\u0181\u0000\u0000\u0a52\u0a55\u0003\u023a\u011d\u0000"+
"\u0a53\u0a55\u0005\u021c\u0000\u0000\u0a54\u0a51\u0001\u0000\u0000\u0000"+
"\u0a54\u0a53\u0001\u0000\u0000\u0000\u0a55\u0a58\u0001\u0000\u0000\u0000"+
"\u0a56\u0a57\u0005\u00ed\u0000\u0000\u0a57\u0a59\u0007$\u0000\u0000\u0a58"+
"\u0a56\u0001\u0000\u0000\u0000\u0a58\u0a59\u0001\u0000\u0000\u0000\u0a59"+
"\u0a5b\u0001\u0000\u0000\u0000\u0a5a\u0a4f\u0001\u0000\u0000\u0000\u0a5a"+
"\u0a5b\u0001\u0000\u0000\u0000\u0a5b\u0a5d\u0001\u0000\u0000\u0000\u0a5c"+
"\u0a5e\u0003\u0244\u0122\u0000\u0a5d\u0a5c\u0001\u0000\u0000\u0000\u0a5d"+
"\u0a5e\u0001\u0000\u0000\u0000\u0a5e\u0a5f\u0001\u0000\u0000\u0000\u0a5f"+
"\u0a60\u0005\u00d1\u0000\u0000\u0a60\u0a61\u0003\u01f0\u00f8\u0000\u0a61"+
"\u0aad\u0001\u0000\u0000\u0000\u0a62\u0a63\u0005\u0224\u0000\u0000\u0a63"+
"\u0a64\u0005\u01d0\u0000\u0000\u0a64\u0a65\u0005\u02a2\u0000\u0000\u0a65"+
"\u0a69\u0003\u0250\u0128\u0000\u0a66\u0a6a\u0003\u01ae\u00d7\u0000\u0a67"+
"\u0a6a\u0005\u010b\u0000\u0000\u0a68\u0a6a\u0005\u00d5\u0000\u0000\u0a69"+
"\u0a66\u0001\u0000\u0000\u0000\u0a69\u0a67\u0001\u0000\u0000\u0000\u0a69"+
"\u0a68\u0001\u0000\u0000\u0000\u0a6a\u0aad\u0001\u0000\u0000\u0000\u0a6b"+
"\u0a6c\u0005\u00c9\u0000\u0000\u0a6c\u0a6d\u0005\u01d0\u0000\u0000\u0a6d"+
"\u0a6e\u0005\u02a2\u0000\u0000\u0a6e\u0a86\u0003\u0250\u0128\u0000\u0a6f"+
"\u0a70\u0005\u0228\u0000\u0000\u0a70\u0a87\u0003\u02ca\u0165\u0000\u0a71"+
"\u0a77\u0005\u0224\u0000\u0000\u0a72\u0a78\u0003\u01be\u00df\u0000\u0a73"+
"\u0a78\u0003\u01ba\u00dd\u0000\u0a74\u0a75\u0003\u01be\u00df\u0000\u0a75"+
"\u0a76\u0003\u01ba\u00dd\u0000\u0a76\u0a78\u0001\u0000\u0000\u0000\u0a77"+
"\u0a72\u0001\u0000\u0000\u0000\u0a77\u0a73\u0001\u0000\u0000\u0000\u0a77"+
"\u0a74\u0001\u0000\u0000\u0000\u0a78\u0a87\u0001\u0000\u0000\u0000\u0a79"+
"\u0a7a\u0005\u022b\u0000\u0000\u0a7a\u0a7b\u0005\u02aa\u0000\u0000\u0a7b"+
"\u0a7c\u0005\u01d0\u0000\u0000\u0a7c\u0a7d\u0005\u02a2\u0000\u0000\u0a7d"+
"\u0a7f\u0003\u02ca\u0165\u0000\u0a7e\u0a80\u0003\u0244\u0122\u0000\u0a7f"+
"\u0a7e\u0001\u0000\u0000\u0000\u0a7f\u0a80\u0001\u0000\u0000\u0000\u0a80"+
"\u0a87\u0001\u0000\u0000\u0000\u0a81\u0a82\u0005\u0250\u0000\u0000\u0a82"+
"\u0a83\u0005\u00b6\u0000\u0000\u0a83\u0a84\u0003\u0246\u0123\u0000\u0a84"+
"\u0a85\u0005\u00b7\u0000\u0000\u0a85\u0a87\u0001\u0000\u0000\u0000\u0a86"+
"\u0a6f\u0001\u0000\u0000\u0000\u0a86\u0a71\u0001\u0000\u0000\u0000\u0a86"+
"\u0a79\u0001\u0000\u0000\u0000\u0a86\u0a81\u0001\u0000\u0000\u0000\u0a87"+
"\u0aad\u0001\u0000\u0000\u0000\u0a88\u0a89\u0005\u0144\u0000\u0000\u0a89"+
"\u0a8a\u0005\u01d0\u0000\u0000\u0a8a\u0a8d\u0005\u02a2\u0000\u0000\u0a8b"+
"\u0a8c\u0005\u018e\u0000\u0000\u0a8c\u0a8e\u0005\u015b\u0000\u0000\u0a8d"+
"\u0a8b\u0001\u0000\u0000\u0000\u0a8d\u0a8e\u0001\u0000\u0000\u0000\u0a8e"+
"\u0a8f\u0001\u0000\u0000\u0000\u0a8f\u0a92\u0003\u0250\u0128\u0000\u0a90"+
"\u0a91\u0005\u01ed\u0000\u0000\u0a91\u0a93\u0003\u0250\u0128\u0000\u0a92"+
"\u0a90\u0001\u0000\u0000\u0000\u0a92\u0a93\u0001\u0000\u0000\u0000\u0a93"+
"\u0aad\u0001\u0000\u0000\u0000\u0a94\u0a95\u0005\u0201\u0000\u0000\u0a95"+
"\u0a96\u0005\u01d0\u0000\u0000\u0a96\u0a97\u0005\u02a2\u0000\u0000\u0a97"+
"\u0a98\u0005\u01a7\u0000\u0000\u0a98\u0a99\u0005\u01ed\u0000\u0000\u0a99"+
"\u0aad\u0003\u0250\u0128\u0000\u0a9a\u0a9b\u0005\u0235\u0000\u0000\u0a9b"+
"\u0a9c\u0005\u01d0\u0000\u0000\u0a9c\u0a9d\u0005\u02a2\u0000\u0000\u0a9d"+
"\u0a9e\u0005\u01a7\u0000\u0000\u0a9e\u0a9f\u0005\u01ed\u0000\u0000\u0a9f"+
"\u0aad\u0003\u0250\u0128\u0000\u0aa0\u0aa1\u0005\u00f5\u0000\u0000\u0aa1"+
"\u0aa2\u0005\u01d0\u0000\u0000\u0aa2\u0aa3\u0005\u02a2\u0000\u0000\u0aa3"+
"\u0aa4\u0005\u0274\u0000\u0000\u0aa4\u0aa5\u0005\u02cf\u0000\u0000\u0aa5"+
"\u0aa6\u0005\u01ed\u0000\u0000\u0aa6\u0aad\u0003\u0250\u0128\u0000\u0aa7"+
"\u0aa8\u0005\u0254\u0000\u0000\u0aa8\u0aa9\u0005\u0119\u0000\u0000\u0aa9"+
"\u0aaa\u0005\u01d0\u0000\u0000\u0aaa\u0aab\u0005\u02a2\u0000\u0000\u0aab"+
"\u0aad\u0003\u0250\u0128\u0000\u0aac\u0a21\u0001\u0000\u0000\u0000\u0aac"+
"\u0a62\u0001\u0000\u0000\u0000\u0aac\u0a6b\u0001\u0000\u0000\u0000\u0aac"+
"\u0a88\u0001\u0000\u0000\u0000\u0aac\u0a94\u0001\u0000\u0000\u0000\u0aac"+
"\u0a9a\u0001\u0000\u0000\u0000\u0aac\u0aa0\u0001\u0000\u0000\u0000\u0aac"+
"\u0aa7\u0001\u0000\u0000\u0000\u0aad\u0117\u0001\u0000\u0000\u0000\u0aae"+
"\u0aaf\u0005\u0119\u0000\u0000\u0aaf\u0ab0\u0005\u01a7\u0000\u0000\u0ab0"+
"\u0ab1\u0003\u0250\u0128\u0000\u0ab1\u0ab2\u0005\u01ed\u0000\u0000\u0ab2"+
"\u0ac6\u0005\u0246\u0000\u0000\u0ab3\u0ab4\u0005\u0157\u0000\u0000\u0ab4"+
"\u0ab5\u0005\u02cf\u0000\u0000\u0ab5\u0abb\u0003\u02ca\u0165\u0000\u0ab6"+
"\u0ab9\u0005\u0260\u0000\u0000\u0ab7\u0aba\u0005\u02ca\u0000\u0000\u0ab8"+
"\u0aba\u0005\u0122\u0000\u0000\u0ab9\u0ab7\u0001\u0000\u0000\u0000\u0ab9"+
"\u0ab8\u0001\u0000\u0000\u0000\u0aba\u0abc\u0001\u0000\u0000\u0000\u0abb"+
"\u0ab6\u0001\u0000\u0000\u0000\u0abb\u0abc\u0001\u0000\u0000\u0000\u0abc"+
"\u0abf\u0001\u0000\u0000\u0000\u0abd\u0abe\u0005\u0150\u0000\u0000\u0abe"+
"\u0ac0\u0005\u02ca\u0000\u0000\u0abf\u0abd\u0001\u0000\u0000\u0000\u0abf"+
"\u0ac0\u0001\u0000\u0000\u0000\u0ac0\u0ac7\u0001\u0000\u0000\u0000\u0ac1"+
"\u0ac4\u0005\u00d3\u0000\u0000\u0ac2\u0ac5\u0005\u02ca\u0000\u0000\u0ac3"+
"\u0ac5\u0005\u0122\u0000\u0000\u0ac4\u0ac2\u0001\u0000\u0000\u0000\u0ac4"+
"\u0ac3\u0001\u0000\u0000\u0000\u0ac5\u0ac7\u0001\u0000\u0000\u0000\u0ac6"+
"\u0ab3\u0001\u0000\u0000\u0000\u0ac6\u0ac1\u0001\u0000\u0000\u0000\u0ac7"+
"\u0ac9\u0001\u0000\u0000\u0000\u0ac8\u0aca\u0003\u02be\u015f\u0000\u0ac9"+
"\u0ac8\u0001\u0000\u0000\u0000\u0ac9\u0aca\u0001\u0000\u0000\u0000\u0aca"+
"\u0acb\u0001\u0000\u0000\u0000\u0acb\u0acc\u0005\u0141\u0000\u0000\u0acc"+
"\u0acd\u0003\u011e\u008f\u0000\u0acd\u0119\u0001\u0000\u0000\u0000\u0ace"+
"\u0acf\u0005\u00c9\u0000\u0000\u0acf\u0ad0\u0005\u026e\u0000\u0000\u0ad0"+
"\u0ad1\u0003\u0250\u0128\u0000\u0ad1\u0ad2\u0005\u00c2\u0000\u0000\u0ad2"+
"\u0ad3\u0005\u0113\u0000\u0000\u0ad3\u0ad4\u0003\u02c6\u0163\u0000\u0ad4"+
"\u0ad5\u0003\u01ac\u00d6\u0000\u0ad5\u0ae2\u0001\u0000\u0000\u0000\u0ad6"+
"\u0ad7\u0005\u00c9\u0000\u0000\u0ad7\u0ad8\u0005\u026e\u0000\u0000\u0ad8"+
"\u0ad9\u0003\u0250\u0128\u0000\u0ad9\u0ada\u0005\u0144\u0000\u0000\u0ada"+
"\u0adb\u0005\u0113\u0000\u0000\u0adb\u0adc\u0003\u02c6\u0163\u0000\u0adc"+
"\u0ae2\u0001\u0000\u0000\u0000\u0add\u0ade\u0005\u0254\u0000\u0000\u0ade"+
"\u0adf\u0005\u0114\u0000\u0000\u0adf\u0ae0\u0005\u0172\u0000\u0000\u0ae0"+
"\u0ae2\u0003\u0250\u0128\u0000\u0ae1\u0ace\u0001\u0000\u0000\u0000\u0ae1"+
"\u0ad6\u0001\u0000\u0000\u0000\u0ae1\u0add\u0001\u0000\u0000\u0000\u0ae2"+
"\u011b\u0001\u0000\u0000\u0000\u0ae3\u0ae4\u0005\u02c8\u0000\u0000\u0ae4"+
"\u0ae5\u0005\u00ea\u0000\u0000\u0ae5\u0ae6\u0005\u00b6\u0000\u0000\u0ae6"+
"\u0ae7\u0003\u02ca\u0165\u0000\u0ae7\u0ae8\u0005\u00b7\u0000\u0000\u0ae8"+
"\u011d\u0001\u0000\u0000\u0000\u0ae9\u0aeb\u0003\u01ce\u00e7\u0000\u0aea"+
"\u0ae9\u0001\u0000\u0000\u0000\u0aea\u0aeb\u0001\u0000\u0000\u0000\u0aeb"+
"\u0aed\u0001\u0000\u0000\u0000\u0aec\u0aee\u0003\u01fa\u00fd\u0000\u0aed"+
"\u0aec\u0001\u0000\u0000\u0000\u0aed\u0aee\u0001\u0000\u0000\u0000\u0aee"+
"\u0aef\u0001\u0000\u0000\u0000\u0aef\u0af3\u0005\u0197\u0000\u0000\u0af0"+
"\u0af4\u0005\u019e\u0000\u0000\u0af1\u0af2\u0005\u01f6\u0000\u0000\u0af2"+
"\u0af4\u0005\u026e\u0000\u0000\u0af3\u0af0\u0001\u0000\u0000\u0000\u0af3"+
"\u0af1\u0001\u0000\u0000\u0000\u0af4\u0afd\u0001\u0000\u0000\u0000\u0af5"+
"\u0af7\u0003\u0250\u0128\u0000\u0af6\u0af8\u0003\u011c\u008e\u0000\u0af7"+
"\u0af6\u0001\u0000\u0000\u0000\u0af7\u0af8\u0001\u0000\u0000\u0000\u0af8"+
"\u0afe\u0001\u0000\u0000\u0000\u0af9\u0afa\u0005\u0142\u0000\u0000\u0afa"+
"\u0afb\u0005\u00b6\u0000\u0000\u0afb\u0afc\u0005\u02cf\u0000\u0000\u0afc"+
"\u0afe\u0005\u00b7\u0000\u0000\u0afd\u0af5\u0001\u0000\u0000\u0000\u0afd"+
"\u0af9\u0001\u0000\u0000\u0000\u0afe\u0b00\u0001\u0000\u0000\u0000\u0aff"+
"\u0b01\u0003\u01ae\u00d7\u0000\u0b00\u0aff\u0001\u0000\u0000\u0000\u0b00"+
"\u0b01\u0001\u0000\u0000\u0000\u0b01\u0b05\u0001\u0000\u0000\u0000\u0b02"+
"\u0b03\u0005\u02aa\u0000\u0000\u0b03\u0b04\u0005\u01af\u0000\u0000\u0b04"+
"\u0b06\u0003\u02ca\u0165\u0000\u0b05\u0b02\u0001\u0000\u0000\u0000\u0b05"+
"\u0b06\u0001\u0000\u0000\u0000\u0b06\u0b08\u0001\u0000\u0000\u0000\u0b07"+
"\u0b09\u0003\u023a\u011d\u0000\u0b08\u0b07\u0001\u0000\u0000\u0000\u0b08"+
"\u0b09\u0001\u0000\u0000\u0000\u0b09\u0b0e\u0001\u0000\u0000\u0000\u0b0a"+
"\u0b0b\u0005\u00bb\u0000\u0000\u0b0b\u0b0c\u0003\u023c\u011e\u0000\u0b0c"+
"\u0b0d\u0005\u00bc\u0000\u0000\u0b0d\u0b0f\u0001\u0000\u0000\u0000\u0b0e"+
"\u0b0a\u0001\u0000\u0000\u0000\u0b0e\u0b0f\u0001\u0000\u0000\u0000\u0b0f"+
"\u0b10\u0001\u0000\u0000\u0000\u0b10\u0b60\u0003\u01f0\u00f8\u0000\u0b11"+
"\u0b13\u0003\u01ce\u00e7\u0000\u0b12\u0b11\u0001\u0000\u0000\u0000\u0b12"+
"\u0b13\u0001\u0000\u0000\u0000\u0b13\u0b15\u0001\u0000\u0000\u0000\u0b14"+
"\u0b16\u0003\u01fa\u00fd\u0000\u0b15\u0b14\u0001\u0000\u0000\u0000\u0b15"+
"\u0b16\u0001\u0000\u0000\u0000\u0b16\u0b17\u0001\u0000\u0000\u0000\u0b17"+
"\u0b18\u0005\u0294\u0000\u0000\u0b18\u0b19\u0003\u0250\u0128\u0000\u0b19"+
"\u0b1a\u0003\u024e\u0127\u0000\u0b1a\u0b1b\u0005\u0250\u0000\u0000\u0b1b"+
"\u0b1d\u0003\u0228\u0114\u0000\u0b1c\u0b1e\u0003\u0206\u0103\u0000\u0b1d"+
"\u0b1c\u0001\u0000\u0000\u0000\u0b1d\u0b1e\u0001\u0000\u0000\u0000\u0b1e"+
"\u0b20\u0001\u0000\u0000\u0000\u0b1f\u0b21\u0003\u0204\u0102\u0000\u0b20"+
"\u0b1f\u0001\u0000\u0000\u0000\u0b20\u0b21\u0001\u0000\u0000\u0000\u0b21"+
"\u0b60\u0001\u0000\u0000\u0000\u0b22\u0b24\u0003\u01ce\u00e7\u0000\u0b23"+
"\u0b22\u0001\u0000\u0000\u0000\u0b23\u0b24\u0001\u0000\u0000\u0000\u0b24"+
"\u0b26\u0001\u0000\u0000\u0000\u0b25\u0b27\u0003\u01fa\u00fd\u0000\u0b26"+
"\u0b25\u0001\u0000\u0000\u0000\u0b26\u0b27\u0001\u0000\u0000\u0000\u0b27"+
"\u0b28\u0001\u0000\u0000\u0000\u0b28\u0b29\u0005\u0134\u0000\u0000\u0b29"+
"\u0b2a\u0005\u0172\u0000\u0000\u0b2a\u0b2c\u0003\u0250\u0128\u0000\u0b2b"+
"\u0b2d\u0003\u01ae\u00d7\u0000\u0b2c\u0b2b\u0001\u0000\u0000\u0000\u0b2c"+
"\u0b2d\u0001\u0000\u0000\u0000\u0b2d\u0b2e\u0001\u0000\u0000\u0000\u0b2e"+
"\u0b31\u0003\u024e\u0127\u0000\u0b2f\u0b30\u0005\u0297\u0000\u0000\u0b30"+
"\u0b32\u0003\u020e\u0107\u0000\u0b31\u0b2f\u0001\u0000\u0000\u0000\u0b31"+
"\u0b32\u0001\u0000\u0000\u0000\u0b32\u0b34\u0001\u0000\u0000\u0000\u0b33"+
"\u0b35\u0003\u0204\u0102\u0000\u0b34\u0b33\u0001\u0000\u0000\u0000\u0b34"+
"\u0b35\u0001\u0000\u0000\u0000\u0b35\u0b60\u0001\u0000\u0000\u0000\u0b36"+
"\u0b37\u0005\u01bd\u0000\u0000\u0b37\u0b38\u0005\u01af\u0000\u0000\u0b38"+
"\u0b39\u0003\u0250\u0128\u0000\u0b39\u0b3a\u0005\u00b6\u0000\u0000\u0b3a"+
"\u0b3f\u0003\u01b6\u00db\u0000\u0b3b\u0b3c\u0005\u00b8\u0000\u0000\u0b3c"+
"\u0b3e\u0003\u01b6\u00db\u0000\u0b3d\u0b3b\u0001\u0000\u0000\u0000\u0b3e"+
"\u0b41\u0001\u0000\u0000\u0000\u0b3f\u0b3d\u0001\u0000\u0000\u0000\u0b3f"+
"\u0b40\u0001\u0000\u0000\u0000\u0b40\u0b42\u0001\u0000\u0000\u0000\u0b41"+
"\u0b3f\u0001\u0000\u0000\u0000\u0b42\u0b44\u0005\u00b7\u0000\u0000\u0b43"+
"\u0b45\u0003\u01e6\u00f3\u0000\u0b44\u0b43\u0001\u0000\u0000\u0000\u0b44"+
"\u0b45\u0001\u0000\u0000\u0000\u0b45\u0b47\u0001\u0000\u0000\u0000\u0b46"+
"\u0b48\u0003\u0244\u0122\u0000\u0b47\u0b46\u0001\u0000\u0000\u0000\u0b47"+
"\u0b48\u0001\u0000\u0000\u0000\u0b48\u0b4a\u0001\u0000\u0000\u0000\u0b49"+
"\u0b4b\u0003\u02be\u015f\u0000\u0b4a\u0b49\u0001\u0000\u0000\u0000\u0b4a"+
"\u0b4b\u0001\u0000\u0000\u0000\u0b4b\u0b60\u0001\u0000\u0000\u0000\u0b4c"+
"\u0b4d\u0005\u015e\u0000\u0000\u0b4d\u0b4e\u0005\u026e\u0000\u0000\u0b4e"+
"\u0b51\u0003\u0250\u0128\u0000\u0b4f\u0b50\u0005\u01f9\u0000\u0000\u0b50"+
"\u0b52\u0003\u023a\u011d\u0000\u0b51\u0b4f\u0001\u0000\u0000\u0000\u0b51"+
"\u0b52\u0001\u0000\u0000\u0000\u0b52\u0b54\u0001\u0000\u0000\u0000\u0b53"+
"\u0b55\u0003\u0204\u0102\u0000\u0b54\u0b53\u0001\u0000\u0000\u0000\u0b54"+
"\u0b55\u0001\u0000\u0000\u0000\u0b55\u0b56\u0001\u0000\u0000\u0000\u0b56"+
"\u0b57\u0005\u027e\u0000\u0000\u0b57\u0b59\u0005\u02ca\u0000\u0000\u0b58"+
"\u0b5a\u0003\u0244\u0122\u0000\u0b59\u0b58\u0001\u0000\u0000\u0000\u0b59"+
"\u0b5a\u0001\u0000\u0000\u0000\u0b5a\u0b5c\u0001\u0000\u0000\u0000\u0b5b"+
"\u0b5d\u0003\u01e6\u00f3\u0000\u0b5c\u0b5b\u0001\u0000\u0000\u0000\u0b5c"+
"\u0b5d\u0001\u0000\u0000\u0000\u0b5d\u0b60\u0001\u0000\u0000\u0000\u0b5e"+
"\u0b60\u0003\u01d4\u00ea\u0000\u0b5f\u0aea\u0001\u0000\u0000\u0000\u0b5f"+
"\u0b12\u0001\u0000\u0000\u0000\u0b5f\u0b23\u0001\u0000\u0000\u0000\u0b5f"+
"\u0b36\u0001\u0000\u0000\u0000\u0b5f\u0b4c\u0001\u0000\u0000\u0000\u0b5f"+
"\u0b5e\u0001\u0000\u0000\u0000\u0b60\u011f\u0001\u0000\u0000\u0000\u0b61"+
"\u0b63\u0005\u0119\u0000\u0000\u0b62\u0b64\u0007%\u0000\u0000\u0b63\u0b62"+
"\u0001\u0000\u0000\u0000\u0b63\u0b64\u0001\u0000\u0000\u0000\u0b64\u0b65"+
"\u0001\u0000\u0000\u0000\u0b65\u0b69\u0005\u026e\u0000\u0000\u0b66\u0b67"+
"\u0005\u018e\u0000\u0000\u0b67\u0b68\u0005\u01e7\u0000\u0000\u0b68\u0b6a"+
"\u0005\u015b\u0000\u0000\u0b69\u0b66\u0001\u0000\u0000\u0000\u0b69\u0b6a"+
"\u0001\u0000\u0000\u0000\u0b6a\u0b6b\u0001\u0000\u0000\u0000\u0b6b\u0b7a"+
"\u0003\u0250\u0128\u0000\u0b6c\u0b6e\u0003\u023a\u011d\u0000\u0b6d\u0b6c"+
"\u0001\u0000\u0000\u0000\u0b6d\u0b6e\u0001\u0000\u0000\u0000\u0b6e\u0b7b"+
"\u0001\u0000\u0000\u0000\u0b6f\u0b70\u0005\u00b6\u0000\u0000\u0b70\u0b73"+
"\u0003\u0256\u012b\u0000\u0b71\u0b72\u0005\u00b8\u0000\u0000\u0b72\u0b74"+
"\u0003\u025a\u012d\u0000\u0b73\u0b71\u0001\u0000\u0000\u0000\u0b73\u0b74"+
"\u0001\u0000\u0000\u0000\u0b74\u0b76\u0001\u0000\u0000\u0000\u0b75\u0b77"+
"\u0005\u00b8\u0000\u0000\u0b76\u0b75\u0001\u0000\u0000\u0000\u0b76\u0b77"+
"\u0001\u0000\u0000\u0000\u0b77\u0b78\u0001\u0000\u0000\u0000\u0b78\u0b79"+
"\u0005\u00b7\u0000\u0000\u0b79\u0b7b\u0001\u0000\u0000\u0000\u0b7a\u0b6d"+
"\u0001\u0000\u0000\u0000\u0b7a\u0b6f\u0001\u0000\u0000\u0000\u0b7b\u0b7f"+
"\u0001\u0000\u0000\u0000\u0b7c\u0b7d\u0005\u0151\u0000\u0000\u0b7d\u0b7e"+
"\u0005\u02b0\u0000\u0000\u0b7e\u0b80\u0003\u02ca\u0165\u0000\u0b7f\u0b7c"+
"\u0001\u0000\u0000\u0000\u0b7f\u0b80\u0001\u0000\u0000\u0000\u0b80\u0b89"+
"\u0001\u0000\u0000\u0000\u0b81\u0b82\u0007&\u0000\u0000\u0b82\u0b83\u0005"+
"\u01ac\u0000\u0000\u0b83\u0b87\u0003\u023a\u011d\u0000\u0b84\u0b85\u0005"+
"\u00ff\u0000\u0000\u0b85\u0b86\u0005\u00f1\u0000\u0000\u0b86\u0b88\u0003"+
"\u023a\u011d\u0000\u0b87\u0b84\u0001\u0000\u0000\u0000\u0b87\u0b88\u0001"+
"\u0000\u0000\u0000\u0b88\u0b8a\u0001\u0000\u0000\u0000\u0b89\u0b81\u0001"+
"\u0000\u0000\u0000\u0b89\u0b8a\u0001\u0000\u0000\u0000\u0b8a\u0b8d\u0001"+
"\u0000\u0000\u0000\u0b8b\u0b8c\u0005\u0107\u0000\u0000\u0b8c\u0b8e\u0005"+
"\u02ca\u0000\u0000\u0b8d\u0b8b\u0001\u0000\u0000\u0000\u0b8d\u0b8e\u0001"+
"\u0000\u0000\u0000\u0b8e\u0b90\u0001\u0000\u0000\u0000\u0b8f\u0b91\u0003"+
"\u01b0\u00d8\u0000\u0b90\u0b8f\u0001\u0000\u0000\u0000\u0b90\u0b91\u0001"+
"\u0000\u0000\u0000\u0b91\u0ba0\u0001\u0000\u0000\u0000\u0b92\u0b93\u0005"+
"\u013e\u0000\u0000\u0b93\u0b97\u0005\u00f1\u0000\u0000\u0b94\u0b95\u0005"+
"\u0181\u0000\u0000\u0b95\u0b98\u0003\u023a\u011d\u0000\u0b96\u0b98\u0005"+
"\u021c\u0000\u0000\u0b97\u0b94\u0001\u0000\u0000\u0000\u0b97\u0b96\u0001"+
"\u0000\u0000\u0000\u0b98\u0b9e\u0001\u0000\u0000\u0000\u0b99\u0b9c\u0005"+
"\u00ed\u0000\u0000\u0b9a\u0b9d\u0005\u02cf\u0000\u0000\u0b9b\u0b9d\u0005"+
"\u00d5\u0000\u0000\u0b9c\u0b9a\u0001\u0000\u0000\u0000\u0b9c\u0b9b\u0001"+
"\u0000\u0000\u0000\u0b9d\u0b9f\u0001\u0000\u0000\u0000\u0b9e\u0b99\u0001"+
"\u0000\u0000\u0000\u0b9e\u0b9f\u0001\u0000\u0000\u0000\u0b9f\u0ba1\u0001"+
"\u0000\u0000\u0000\u0ba0\u0b92\u0001\u0000\u0000\u0000\u0ba0\u0ba1\u0001"+
"\u0000\u0000\u0000\u0ba1\u0ba7\u0001\u0000\u0000\u0000\u0ba2\u0ba3\u0005"+
"\u0240\u0000\u0000\u0ba3\u0ba4\u0005\u00b6\u0000\u0000\u0ba4\u0ba5\u0003"+
"\u026e\u0137\u0000\u0ba5\u0ba6\u0005\u00b7\u0000\u0000\u0ba6\u0ba8\u0001"+
"\u0000\u0000\u0000\u0ba7\u0ba2\u0001\u0000\u0000\u0000\u0ba7\u0ba8\u0001"+
"\u0000\u0000\u0000\u0ba8\u0baa\u0001\u0000\u0000\u0000\u0ba9\u0bab\u0003"+
"\u0244\u0122\u0000\u0baa\u0ba9\u0001\u0000\u0000\u0000\u0baa\u0bab\u0001"+
"\u0000\u0000\u0000\u0bab\u0bae\u0001\u0000\u0000\u0000\u0bac\u0bad\u0005"+
"\u00ec\u0000\u0000\u0bad\u0baf\u0003\u0244\u0122\u0000\u0bae\u0bac\u0001"+
"\u0000\u0000\u0000\u0bae\u0baf\u0001\u0000\u0000\u0000\u0baf\u0bb2\u0001"+
"\u0000\u0000\u0000\u0bb0\u0bb1\u0005\u00d1\u0000\u0000\u0bb1\u0bb3\u0003"+
"\u01f0\u00f8\u0000\u0bb2\u0bb0\u0001\u0000\u0000\u0000\u0bb2\u0bb3\u0001"+
"\u0000\u0000\u0000\u0bb3\u0c21\u0001\u0000\u0000\u0000\u0bb4\u0bb7\u0005"+
"\u0119\u0000\u0000\u0bb5\u0bb6\u0005\u01f1\u0000\u0000\u0bb6\u0bb8\u0005"+
"\u022b\u0000\u0000\u0bb7\u0bb5\u0001\u0000\u0000\u0000\u0bb7\u0bb8\u0001"+
"\u0000\u0000\u0000\u0bb8\u0bb9\u0001\u0000\u0000\u0000\u0bb9\u0bbd\u0005"+
"\u02a2\u0000\u0000\u0bba\u0bbb\u0005\u018e\u0000\u0000\u0bbb\u0bbc\u0005"+
"\u01e7\u0000\u0000\u0bbc\u0bbe\u0005\u015b\u0000\u0000\u0bbd\u0bba\u0001"+
"\u0000\u0000\u0000\u0bbd\u0bbe\u0001\u0000\u0000\u0000\u0bbe\u0bbf\u0001"+
"\u0000\u0000\u0000\u0bbf\u0bc4\u0003\u0250\u0128\u0000\u0bc0\u0bc1\u0005"+
"\u00b6\u0000\u0000\u0bc1\u0bc2\u0003\u0252\u0129\u0000\u0bc2\u0bc3\u0005"+
"\u00b7\u0000\u0000\u0bc3\u0bc5\u0001\u0000\u0000\u0000\u0bc4\u0bc0\u0001"+
"\u0000\u0000\u0000\u0bc4\u0bc5\u0001\u0000\u0000\u0000\u0bc5\u0bc8\u0001"+
"\u0000\u0000\u0000\u0bc6\u0bc7\u0005\u0107\u0000\u0000\u0bc7\u0bc9\u0005"+
"\u02ca\u0000\u0000\u0bc8\u0bc6\u0001\u0000\u0000\u0000\u0bc8\u0bc9\u0001"+
"\u0000\u0000\u0000\u0bc9\u0bca\u0001\u0000\u0000\u0000\u0bca\u0bcb\u0005"+
"\u00d1\u0000\u0000\u0bcb\u0bcc\u0003\u01f0\u00f8\u0000\u0bcc\u0c21\u0001"+
"\u0000\u0000\u0000\u0bcd\u0bcf\u0005\u0119\u0000\u0000\u0bce\u0bd0\u0007"+
"%\u0000\u0000\u0bcf\u0bce\u0001\u0000\u0000\u0000\u0bcf\u0bd0\u0001\u0000"+
"\u0000\u0000\u0bd0\u0bd1\u0001\u0000\u0000\u0000\u0bd1\u0bd5\u0005\u026e"+
"\u0000\u0000\u0bd2\u0bd3\u0005\u018e\u0000\u0000\u0bd3\u0bd4\u0005\u01e7"+
"\u0000\u0000\u0bd4\u0bd6\u0005\u015b\u0000\u0000\u0bd5\u0bd2\u0001\u0000"+
"\u0000\u0000\u0bd5\u0bd6\u0001\u0000\u0000\u0000\u0bd6\u0bd7\u0001\u0000"+
"\u0000\u0000\u0bd7\u0bd8\u0003\u0250\u0128\u0000\u0bd8\u0bd9\u0005\u01b8"+
"\u0000\u0000\u0bd9\u0bdf\u0003\u0250\u0128\u0000\u0bda\u0bdb\u0005\u02aa"+
"\u0000\u0000\u0bdb\u0bdd\u0005\u0240\u0000\u0000\u0bdc\u0bde\u0003\u023a"+
"\u011d\u0000\u0bdd\u0bdc\u0001\u0000\u0000\u0000\u0bdd\u0bde\u0001\u0000"+
"\u0000\u0000\u0bde\u0be0\u0001\u0000\u0000\u0000\u0bdf\u0bda\u0001\u0000"+
"\u0000\u0000\u0bdf\u0be0\u0001\u0000\u0000\u0000\u0be0\u0c21\u0001\u0000"+
"\u0000\u0000\u0be1\u0be2\u0005\u0119\u0000\u0000\u0be2\u0be3\u0005\u0242"+
"\u0000\u0000\u0be3\u0be7\u0005\u020e\u0000\u0000\u0be4\u0be5\u0005\u018e"+
"\u0000\u0000\u0be5\u0be6\u0005\u01e7\u0000\u0000\u0be6\u0be8\u0005\u015b"+
"\u0000\u0000\u0be7\u0be4\u0001\u0000\u0000\u0000\u0be7\u0be8\u0001\u0000"+
"\u0000\u0000\u0be8\u0be9\u0001\u0000\u0000\u0000\u0be9\u0bea\u0003\u02ca"+
"\u0165\u0000\u0bea\u0beb\u0005\u01ed\u0000\u0000\u0beb\u0bec\u0003\u0250"+
"\u0128\u0000\u0bec\u0bed\u0005\u00d1\u0000\u0000\u0bed\u0bee\u0007\'\u0000"+
"\u0000\u0bee\u0bf2\u0005\u027e\u0000\u0000\u0bef\u0bf3\u0003\u01ca\u00e5"+
"\u0000\u0bf0\u0bf1\u0005\u023d\u0000\u0000\u0bf1\u0bf3\u0003\u02ca\u0165"+
"\u0000\u0bf2\u0bef\u0001\u0000\u0000\u0000\u0bf2\u0bf0\u0001\u0000\u0000"+
"\u0000\u0bf3\u0bf4\u0001\u0000\u0000\u0000\u0bf4\u0bf5\u0005\u0297\u0000"+
"\u0000\u0bf5\u0bf6\u0005\u00b6\u0000\u0000\u0bf6\u0bf7\u0003\u0280\u0140"+
"\u0000\u0bf7\u0bf8\u0005\u00b7\u0000\u0000\u0bf8\u0c21\u0001\u0000\u0000"+
"\u0000\u0bf9\u0bfa\u0005\u0119\u0000\u0000\u0bfa\u0bfb\u0005\u019f\u0000"+
"\u0000\u0bfb\u0bfc\u0005\u0193\u0000\u0000\u0bfc\u0c00\u0005\u00cc\u0000"+
"\u0000\u0bfd\u0bfe\u0005\u018e\u0000\u0000\u0bfe\u0bff\u0005\u01e7\u0000"+
"\u0000\u0bff\u0c01\u0005\u015b\u0000\u0000\u0c00\u0bfd\u0001\u0000\u0000"+
"\u0000\u0c00\u0c01\u0001\u0000\u0000\u0000\u0c01\u0c02\u0001\u0000\u0000"+
"\u0000\u0c02\u0c04\u0003\u02ca\u0165\u0000\u0c03\u0c05\u0003\u0244\u0122"+
"\u0000\u0c04\u0c03\u0001\u0000\u0000\u0000\u0c04\u0c05\u0001\u0000\u0000"+
"\u0000\u0c05\u0c21\u0001\u0000\u0000\u0000\u0c06\u0c07\u0005\u0119\u0000"+
"\u0000\u0c07\u0c08\u0005\u019f\u0000\u0000\u0c08\u0c09\u0005\u0193\u0000"+
"\u0000\u0c09\u0c0d\u0005\u027f\u0000\u0000\u0c0a\u0c0b\u0005\u018e\u0000"+
"\u0000\u0c0b\u0c0c\u0005\u01e7\u0000\u0000\u0c0c\u0c0e\u0005\u015b\u0000"+
"\u0000\u0c0d\u0c0a\u0001\u0000\u0000\u0000\u0c0d\u0c0e\u0001\u0000\u0000"+
"\u0000\u0c0e\u0c0f\u0001\u0000\u0000\u0000\u0c0f\u0c11\u0003\u02ca\u0165"+
"\u0000\u0c10\u0c12\u0003\u0244\u0122\u0000\u0c11\u0c10\u0001\u0000\u0000"+
"\u0000\u0c11\u0c12\u0001\u0000\u0000\u0000\u0c12\u0c21\u0001\u0000\u0000"+
"\u0000\u0c13\u0c14\u0005\u0119\u0000\u0000\u0c14\u0c15\u0005\u019f\u0000"+
"\u0000\u0c15\u0c16\u0005\u0193\u0000\u0000\u0c16\u0c1a\u0005\u0280\u0000"+
"\u0000\u0c17\u0c18\u0005\u018e\u0000\u0000\u0c18\u0c19\u0005\u01e7\u0000"+
"\u0000\u0c19\u0c1b\u0005\u015b\u0000\u0000\u0c1a\u0c17\u0001\u0000\u0000"+
"\u0000\u0c1a\u0c1b\u0001\u0000\u0000\u0000\u0c1b\u0c1c\u0001\u0000\u0000"+
"\u0000\u0c1c\u0c1e\u0003\u02ca\u0165\u0000\u0c1d\u0c1f\u0003\u0244\u0122"+
"\u0000\u0c1e\u0c1d\u0001\u0000\u0000\u0000\u0c1e\u0c1f\u0001\u0000\u0000"+
"\u0000\u0c1f\u0c21\u0001\u0000\u0000\u0000\u0c20\u0b61\u0001\u0000\u0000"+
"\u0000\u0c20\u0bb4\u0001\u0000\u0000\u0000\u0c20\u0bcd\u0001\u0000\u0000"+
"\u0000\u0c20\u0be1\u0001\u0000\u0000\u0000\u0c20\u0bf9\u0001\u0000\u0000"+
"\u0000\u0c20\u0c06\u0001\u0000\u0000\u0000\u0c20\u0c13\u0001\u0000\u0000"+
"\u0000\u0c21\u0121\u0001\u0000\u0000\u0000\u0c22\u0c23\u0005\u00c9\u0000"+
"\u0000\u0c23\u0c24\u0005\u02a2\u0000\u0000\u0c24\u0c32\u0003\u0250\u0128"+
"\u0000\u0c25\u0c26\u0005\u01db\u0000\u0000\u0c26\u0c33\u0003\u02be\u015f"+
"\u0000\u0c27\u0c28\u0005\u00b6\u0000\u0000\u0c28\u0c29\u0003\u0252\u0129"+
"\u0000\u0c29\u0c2a\u0005\u00b7\u0000\u0000\u0c2a\u0c2c\u0001\u0000\u0000"+
"\u0000\u0c2b\u0c27\u0001\u0000\u0000\u0000\u0c2b\u0c2c\u0001\u0000\u0000"+
"\u0000\u0c2c\u0c2e\u0001\u0000\u0000\u0000\u0c2d\u0c2f\u0003\u02be\u015f"+
"\u0000\u0c2e\u0c2d\u0001\u0000\u0000\u0000\u0c2e\u0c2f\u0001\u0000\u0000"+
"\u0000\u0c2f\u0c30\u0001\u0000\u0000\u0000\u0c30\u0c31\u0005\u00d1\u0000"+
"\u0000\u0c31\u0c33\u0003\u01f0\u00f8\u0000\u0c32\u0c25\u0001\u0000\u0000"+
"\u0000\u0c32\u0c2b\u0001\u0000\u0000\u0000\u0c33\u0c43\u0001\u0000\u0000"+
"\u0000\u0c34\u0c35\u0005\u00c9\u0000\u0000\u0c35\u0c36\u0005\u0264\u0000"+
"\u0000\u0c36\u0c37\u0005\u029e\u0000\u0000\u0c37\u0c38\u0003\u0250\u0128"+
"\u0000\u0c38\u0c39\u0003\u0244\u0122\u0000\u0c39\u0c43\u0001\u0000\u0000"+
"\u0000\u0c3a\u0c3b\u0005\u00c9\u0000\u0000\u0c3b\u0c3c\u0005\u026d\u0000"+
"\u0000\u0c3c\u0c3d\u0005\u0228\u0000\u0000\u0c3d\u0c3e\u0005\u010d\u0000"+
"\u0000\u0c3e\u0c3f\u0005\u017e\u0000\u0000\u0c3f\u0c40\u0003\u02ca\u0165"+
"\u0000\u0c40\u0c41\u0003\u02ca\u0165\u0000\u0c41\u0c43\u0001\u0000\u0000"+
"\u0000\u0c42\u0c22\u0001\u0000\u0000\u0000\u0c42\u0c34\u0001\u0000\u0000"+
"\u0000\u0c42\u0c3a\u0001\u0000\u0000\u0000\u0c43\u0123\u0001\u0000\u0000"+
"\u0000\u0c44\u0c45\u0005\u0144\u0000\u0000\u0c45\u0c46\u0005\u00f8\u0000"+
"\u0000\u0c46\u0c47\u0005\u0223\u0000\u0000\u0c47\u0c48\u0005\u00df\u0000"+
"\u0000\u0c48\u0c49\u0005\u02a8\u0000\u0000\u0c49\u0c4a\u0005\u02ca\u0000"+
"\u0000\u0c4a\u0c4b\u0005\u02b0\u0000\u0000\u0c4b\u0c6f\u0005\u02cf\u0000"+
"\u0000\u0c4c\u0c4d\u0005\u0144\u0000\u0000\u0c4d\u0c50\u0005\u023d\u0000"+
"\u0000\u0c4e\u0c4f\u0005\u018e\u0000\u0000\u0c4f\u0c51\u0005\u015b\u0000"+
"\u0000\u0c50\u0c4e\u0001\u0000\u0000\u0000\u0c50\u0c51\u0001\u0000\u0000"+
"\u0000\u0c51\u0c52\u0001\u0000\u0000\u0000\u0c52\u0c6f\u0003\u02ca\u0165"+
"\u0000\u0c53\u0c54\u0005\u0144\u0000\u0000\u0c54\u0c55\u0005\u019f\u0000"+
"\u0000\u0c55\u0c56\u0005\u0193\u0000\u0000\u0c56\u0c59\u0005\u00cc\u0000"+
"\u0000\u0c57\u0c58\u0005\u018e\u0000\u0000\u0c58\u0c5a\u0005\u015b\u0000"+
"\u0000\u0c59\u0c57\u0001\u0000\u0000\u0000\u0c59\u0c5a\u0001\u0000\u0000"+
"\u0000\u0c5a\u0c5b\u0001\u0000\u0000\u0000\u0c5b\u0c6f\u0003\u02ca\u0165"+
"\u0000\u0c5c\u0c5d\u0005\u0144\u0000\u0000\u0c5d\u0c5e\u0005\u019f\u0000"+
"\u0000\u0c5e\u0c5f\u0005\u0193\u0000\u0000\u0c5f\u0c62\u0005\u027f\u0000"+
"\u0000\u0c60\u0c61\u0005\u018e\u0000\u0000\u0c61\u0c63\u0005\u015b\u0000"+
"\u0000\u0c62\u0c60\u0001\u0000\u0000\u0000\u0c62\u0c63\u0001\u0000\u0000"+
"\u0000\u0c63\u0c64\u0001\u0000\u0000\u0000\u0c64\u0c6f\u0003\u02ca\u0165"+
"\u0000\u0c65\u0c66\u0005\u0144\u0000\u0000\u0c66\u0c67\u0005\u019f\u0000"+
"\u0000\u0c67\u0c68\u0005\u0193\u0000\u0000\u0c68\u0c6b\u0005\u0280\u0000"+
"\u0000\u0c69\u0c6a\u0005\u018e\u0000\u0000\u0c6a\u0c6c\u0005\u015b\u0000"+
"\u0000\u0c6b\u0c69\u0001\u0000\u0000\u0000\u0c6b\u0c6c\u0001\u0000\u0000"+
"\u0000\u0c6c\u0c6d\u0001\u0000\u0000\u0000\u0c6d\u0c6f\u0003\u02ca\u0165"+
"\u0000\u0c6e\u0c44\u0001\u0000\u0000\u0000\u0c6e\u0c4c\u0001\u0000\u0000"+
"\u0000\u0c6e\u0c53\u0001\u0000\u0000\u0000\u0c6e\u0c5c\u0001\u0000\u0000"+
"\u0000\u0c6e\u0c65\u0001\u0000\u0000\u0000\u0c6f\u0125\u0001\u0000\u0000"+
"\u0000\u0c70\u0c71\u0005\u0254\u0000\u0000\u0c71\u0c72\u0005\u02a2\u0000"+
"\u0000\u0c72\u0c73\u0007(\u0000\u0000\u0c73\u0c76\u0003\u0250\u0128\u0000"+
"\u0c74\u0c75\u0007(\u0000\u0000\u0c75\u0c77\u0003\u02ca\u0165\u0000\u0c76"+
"\u0c74\u0001\u0000\u0000\u0000\u0c76\u0c77\u0001\u0000\u0000\u0000\u0c77"+
"\u0c85\u0001\u0000\u0000\u0000\u0c78\u0c79\u0005\u0254\u0000\u0000\u0c79"+
"\u0c7a\u0005\u019f\u0000\u0000\u0c7a\u0c7b\u0005\u0193\u0000\u0000\u0c7b"+
"\u0c85\u0005\u00cc\u0000\u0000\u0c7c\u0c7d\u0005\u0254\u0000\u0000\u0c7d"+
"\u0c7e\u0005\u019f\u0000\u0000\u0c7e\u0c7f\u0005\u0193\u0000\u0000\u0c7f"+
"\u0c85\u0005\u027f\u0000\u0000\u0c80\u0c81\u0005\u0254\u0000\u0000\u0c81"+
"\u0c82\u0005\u019f\u0000\u0000\u0c82\u0c83\u0005\u0193\u0000\u0000\u0c83"+
"\u0c85\u0005\u0280\u0000\u0000\u0c84\u0c70\u0001\u0000\u0000\u0000\u0c84"+
"\u0c78\u0001\u0000\u0000\u0000\u0c84\u0c7c\u0001\u0000\u0000\u0000\u0c84"+
"\u0c80\u0001\u0000\u0000\u0000\u0c85\u0127\u0001\u0000\u0000\u0000\u0c86"+
"\u0c88\u0005\u01ae\u0000\u0000\u0c87\u0c89\u0005\u0110\u0000\u0000\u0c88"+
"\u0c87\u0001\u0000\u0000\u0000\u0c88\u0c89\u0001\u0000\u0000\u0000\u0c89"+
"\u0c8a\u0001\u0000\u0000\u0000\u0c8a\u0c8f\u0005\u02cf\u0000\u0000\u0c8b"+
"\u0c8c\u0005\u01ae\u0000\u0000\u0c8c\u0c8d\u0005\u021a\u0000\u0000\u0c8d"+
"\u0c8f\u0007)\u0000\u0000\u0c8e\u0c86\u0001\u0000\u0000\u0000\u0c8e\u0c8b"+
"\u0001\u0000\u0000\u0000\u0c8f\u0129\u0001\u0000\u0000\u0000\u0c90\u0c91"+
"\u0005\u0184\u0000\u0000\u0c91\u0cfd\u0003\u01c2\u00e1\u0000\u0c92\u0c93"+
"\u0005\u0198\u0000\u0000\u0c93\u0c94\u0005\u020c\u0000\u0000\u0c94\u0c95"+
"\u0005\u0172\u0000\u0000\u0c95\u0c97\u0003\u01c2\u00e1\u0000\u0c96\u0c98"+
"\u0003\u0244\u0122\u0000\u0c97\u0c96\u0001\u0000\u0000\u0000\u0c97\u0c98"+
"\u0001\u0000\u0000\u0000\u0c98\u0cfd\u0001\u0000\u0000\u0000\u0c99\u0c9a"+
"\u0005\u028d\u0000\u0000\u0c9a\u0c9b\u0005\u020c\u0000\u0000\u0c9b\u0cfd"+
"\u0003\u01c2\u00e1\u0000\u0c9c\u0c9d\u0005\u01c2\u0000\u0000\u0c9d\u0ca6"+
"\u0005\u026f\u0000\u0000\u0c9e\u0ca3\u0003\u012e\u0097\u0000\u0c9f\u0ca0"+
"\u0005\u00b8\u0000\u0000\u0ca0\u0ca2\u0003\u012e\u0097\u0000\u0ca1\u0c9f"+
"\u0001\u0000\u0000\u0000\u0ca2\u0ca5\u0001\u0000\u0000\u0000\u0ca3\u0ca1"+
"\u0001\u0000\u0000\u0000\u0ca3\u0ca4\u0001\u0000\u0000\u0000\u0ca4\u0ca7"+
"\u0001\u0000\u0000\u0000\u0ca5\u0ca3\u0001\u0000\u0000\u0000\u0ca6\u0c9e"+
"\u0001\u0000\u0000\u0000\u0ca6\u0ca7\u0001\u0000\u0000\u0000\u0ca7\u0cfd"+
"\u0001\u0000\u0000\u0000\u0ca8\u0ca9\u0005\u0290\u0000\u0000\u0ca9\u0cfd"+
"\u0005\u026f\u0000\u0000\u0caa\u0cab\u0005\u02a4\u0000\u0000\u0cab\u0caf"+
"\u0005\u0293\u0000\u0000\u0cac\u0cb0\u0005\u00ff\u0000\u0000\u0cad\u0cae"+
"\u0005\u010d\u0000\u0000\u0cae\u0cb0\u0005\u017e\u0000\u0000\u0caf\u0cac"+
"\u0001\u0000\u0000\u0000\u0caf\u0cad\u0001\u0000\u0000\u0000\u0cb0\u0cb1"+
"\u0001\u0000\u0000\u0000\u0cb1\u0cb2\u0003\u02ca\u0165\u0000\u0cb2\u0cc1"+
"\u0005\u02aa\u0000\u0000\u0cb3\u0cb7\u0005\u00ff\u0000\u0000\u0cb4\u0cb5"+
"\u0005\u010d\u0000\u0000\u0cb5\u0cb7\u0005\u017e\u0000\u0000\u0cb6\u0cb3"+
"\u0001\u0000\u0000\u0000\u0cb6\u0cb4\u0001\u0000\u0000\u0000\u0cb7\u0cb8"+
"\u0001\u0000\u0000\u0000\u0cb8\u0cc2\u0003\u02ca\u0165\u0000\u0cb9\u0cbe"+
"\u0003\u012c\u0096\u0000\u0cba\u0cbb\u0005\u00cd\u0000\u0000\u0cbb\u0cbd"+
"\u0003\u012c\u0096\u0000\u0cbc\u0cba\u0001\u0000\u0000\u0000\u0cbd\u0cc0"+
"\u0001\u0000\u0000\u0000\u0cbe\u0cbc\u0001\u0000\u0000\u0000\u0cbe\u0cbf"+
"\u0001\u0000\u0000\u0000\u0cbf\u0cc2\u0001\u0000\u0000\u0000\u0cc0\u0cbe"+
"\u0001\u0000\u0000\u0000\u0cc1\u0cb6\u0001\u0000\u0000\u0000\u0cc1\u0cb9"+
"\u0001\u0000\u0000\u0000\u0cc2\u0cc4\u0001\u0000\u0000\u0000\u0cc3\u0cc5"+
"\u0005\u016f\u0000\u0000\u0cc4\u0cc3\u0001\u0000\u0000\u0000\u0cc4\u0cc5"+
"\u0001\u0000\u0000\u0000\u0cc5\u0cc7\u0001\u0000\u0000\u0000\u0cc6\u0cc8"+
"\u0003\u0244\u0122\u0000\u0cc7\u0cc6\u0001\u0000\u0000\u0000\u0cc7\u0cc8"+
"\u0001\u0000\u0000\u0000\u0cc8\u0cfd\u0001\u0000\u0000\u0000\u0cc9\u0cca"+
"\u0005\u00da\u0000\u0000\u0cca\u0ccb\u0005\u0258\u0000\u0000\u0ccb\u0ccc"+
"\u0003\u0250\u0128\u0000\u0ccc\u0ccd\u0005\u027e\u0000\u0000\u0ccd\u0cda"+
"\u0003\u02ca\u0165\u0000\u0cce\u0ccf\u0007*\u0000\u0000\u0ccf\u0cd0\u0005"+
"\u00b6\u0000\u0000\u0cd0\u0cd5\u0003\u014e\u00a7\u0000\u0cd1\u0cd2\u0005"+
"\u00b8\u0000\u0000\u0cd2\u0cd4\u0003\u014e\u00a7\u0000\u0cd3\u0cd1\u0001"+
"\u0000\u0000\u0000\u0cd4\u0cd7\u0001\u0000\u0000\u0000\u0cd5\u0cd3\u0001"+
"\u0000\u0000\u0000\u0cd5\u0cd6\u0001\u0000\u0000\u0000\u0cd6\u0cd8\u0001"+
"\u0000\u0000\u0000\u0cd7\u0cd5\u0001\u0000\u0000\u0000\u0cd8\u0cd9\u0005"+
"\u00b7\u0000\u0000\u0cd9\u0cdb\u0001\u0000\u0000\u0000\u0cda\u0cce\u0001"+
"\u0000\u0000\u0000\u0cda\u0cdb\u0001\u0000\u0000\u0000\u0cdb\u0cdd\u0001"+
"\u0000\u0000\u0000\u0cdc\u0cde\u0003\u0244\u0122\u0000\u0cdd\u0cdc\u0001"+
"\u0000\u0000\u0000\u0cdd\u0cde\u0001\u0000\u0000\u0000\u0cde\u0cfd\u0001"+
"\u0000\u0000\u0000\u0cdf\u0ce0\u0005\u0233\u0000\u0000\u0ce0\u0ce1\u0005"+
"\u0258\u0000\u0000\u0ce1\u0ce2\u0003\u0250\u0128\u0000\u0ce2\u0ce3\u0005"+
"\u0172\u0000\u0000\u0ce3\u0cf0\u0003\u02ca\u0165\u0000\u0ce4\u0ce5\u0007"+
"*\u0000\u0000\u0ce5\u0ce6\u0005\u00b6\u0000\u0000\u0ce6\u0ceb\u0003\u014e"+
"\u00a7\u0000\u0ce7\u0ce8\u0005\u00b8\u0000\u0000\u0ce8\u0cea\u0003\u014e"+
"\u00a7\u0000\u0ce9\u0ce7\u0001\u0000\u0000\u0000\u0cea\u0ced\u0001\u0000"+
"\u0000\u0000\u0ceb\u0ce9\u0001\u0000\u0000\u0000\u0ceb\u0cec\u0001\u0000"+
"\u0000\u0000\u0cec\u0cee\u0001\u0000\u0000\u0000\u0ced\u0ceb\u0001\u0000"+
"\u0000\u0000\u0cee\u0cef\u0005\u00b7\u0000\u0000\u0cef\u0cf1\u0001\u0000"+
"\u0000\u0000\u0cf0\u0ce4\u0001\u0000\u0000\u0000\u0cf0\u0cf1\u0001\u0000"+
"\u0000\u0000\u0cf1\u0cf3\u0001\u0000\u0000\u0000\u0cf2\u0cf4\u0003\u0244"+
"\u0122\u0000\u0cf3\u0cf2\u0001\u0000\u0000\u0000\u0cf3\u0cf4\u0001\u0000"+
"\u0000\u0000\u0cf4\u0cfd\u0001\u0000\u0000\u0000\u0cf5\u0cf6\u0005\u025f"+
"\u0000\u0000\u0cf6\u0cfa\u0005\u0281\u0000\u0000\u0cf7\u0cf8\u0005\u02aa"+
"\u0000\u0000\u0cf8\u0cf9\u0005\u0112\u0000\u0000\u0cf9\u0cfb\u0005\u0258"+
"\u0000\u0000\u0cfa\u0cf7\u0001\u0000\u0000\u0000\u0cfa\u0cfb\u0001\u0000"+
"\u0000\u0000\u0cfb\u0cfd\u0001\u0000\u0000\u0000\u0cfc\u0c90\u0001\u0000"+
"\u0000\u0000\u0cfc\u0c92\u0001\u0000\u0000\u0000\u0cfc\u0c99\u0001\u0000"+
"\u0000\u0000\u0cfc\u0c9c\u0001\u0000\u0000\u0000\u0cfc\u0ca8\u0001\u0000"+
"\u0000\u0000\u0cfc\u0caa\u0001\u0000\u0000\u0000\u0cfc\u0cc9\u0001\u0000"+
"\u0000\u0000\u0cfc\u0cdf\u0001\u0000\u0000\u0000\u0cfc\u0cf5\u0001\u0000"+
"\u0000\u0000\u0cfd\u012b\u0001\u0000\u0000\u0000\u0cfe\u0cff\u0005\u026e"+
"\u0000\u0000\u0cff\u0d02\u0003\u0250\u0128\u0000\u0d00\u0d01\u0005\u01f9"+
"\u0000\u0000\u0d01\u0d03\u0003\u02ca\u0165\u0000\u0d02\u0d00\u0001\u0000"+
"\u0000\u0000\u0d02\u0d03\u0001\u0000\u0000\u0000\u0d03\u012d\u0001\u0000"+
"\u0000\u0000\u0d04\u0d07\u0003\u0250\u0128\u0000\u0d05\u0d06\u0005\u00d1"+
"\u0000\u0000\u0d06\u0d08\u0003\u01c2\u00e1\u0000\u0d07\u0d05\u0001\u0000"+
"\u0000\u0000\u0d07\u0d08\u0001\u0000\u0000\u0000\u0d08\u0d11\u0001\u0000"+
"\u0000\u0000\u0d09\u0d0b\u0005\u021e\u0000\u0000\u0d0a\u0d0c\u0005\u01be"+
"\u0000\u0000\u0d0b\u0d0a\u0001\u0000\u0000\u0000\u0d0b\u0d0c\u0001\u0000"+
"\u0000\u0000\u0d0c\u0d12\u0001\u0000\u0000\u0000\u0d0d\u0d0f\u0005\u01c4"+
"\u0000\u0000\u0d0e\u0d0d\u0001\u0000\u0000\u0000\u0d0e\u0d0f\u0001\u0000"+
"\u0000\u0000\u0d0f\u0d10\u0001\u0000\u0000\u0000\u0d10\u0d12\u0005\u02ad"+
"\u0000\u0000\u0d11\u0d09\u0001\u0000\u0000\u0000\u0d11\u0d0e\u0001\u0000"+
"\u0000\u0000\u0d12\u012f\u0001\u0000\u0000\u0000\u0d13\u0d14\u0005\u0254"+
"\u0000\u0000\u0d14\u0d17\u0005\u025c\u0000\u0000\u0d15\u0d16\u0005\u016d"+
"\u0000\u0000\u0d16\u0d18\u0003\u02ca\u0165\u0000\u0d17\u0d15\u0001\u0000"+
"\u0000\u0000\u0d17\u0d18\u0001\u0000\u0000\u0000\u0d18\u0fc4\u0001\u0000"+
"\u0000\u0000\u0d19\u0d1a\u0005\u0254\u0000\u0000\u0d1a\u0d1b\u0005\u0242"+
"\u0000\u0000\u0d1b\u0d22\u0005\u020e\u0000\u0000\u0d1c\u0d20\u0005\u016d"+
"\u0000\u0000\u0d1d\u0d21\u0003\u01ca\u00e5\u0000\u0d1e\u0d1f\u0005\u023d"+
"\u0000\u0000\u0d1f\u0d21\u0003\u02ca\u0165\u0000\u0d20\u0d1d\u0001\u0000"+
"\u0000\u0000\u0d20\u0d1e\u0001\u0000\u0000\u0000\u0d21\u0d23\u0001\u0000"+
"\u0000\u0000\u0d22\u0d1c\u0001\u0000\u0000\u0000\u0d22\u0d23\u0001\u0000"+
"\u0000\u0000\u0d23\u0fc4\u0001\u0000\u0000\u0000\u0d24\u0d25\u0005\u0254"+
"\u0000\u0000\u0d25\u0d26\u0005\u0264\u0000\u0000\u0d26\u0d2c\u0005\u020e"+
"\u0000\u0000\u0d27\u0d2a\u0005\u0297\u0000\u0000\u0d28\u0d29\u0005\u016d"+
"\u0000\u0000\u0d29\u0d2b\u0003\u01c2\u00e1\u0000\u0d2a\u0d28\u0001\u0000"+
"\u0000\u0000\u0d2a\u0d2b\u0001\u0000\u0000\u0000\u0d2b\u0d2d\u0001\u0000"+
"\u0000\u0000\u0d2c\u0d27\u0001\u0000\u0000\u0000\u0d2c\u0d2d\u0001\u0000"+
"\u0000\u0000\u0d2d\u0fc4\u0001\u0000\u0000\u0000\u0d2e\u0d2f\u0005\u0254"+
"\u0000\u0000\u0d2f\u0fc4\u0005\u025e\u0000\u0000\u0d30\u0d31\u0005\u0254"+
"\u0000\u0000\u0d31\u0d32\u0005\u0264\u0000\u0000\u0d32\u0fc4\u0007+\u0000"+
"\u0000\u0d33\u0d34\u0005\u0254\u0000\u0000\u0d34\u0d35\u0005\u0119\u0000"+
"\u0000\u0d35\u0d36\u0005\u0230\u0000\u0000\u0d36\u0d37\u0005\u016d\u0000"+
"\u0000\u0d37\u0fc4\u0003\u02ca\u0165\u0000\u0d38\u0d39\u0005\u0254\u0000"+
"\u0000\u0d39\u0fc4\u0005\u02a9\u0000\u0000\u0d3a\u0d3c\u0005\u0254\u0000"+
"\u0000\u0d3b\u0d3d\u0007\u0011\u0000\u0000\u0d3c\u0d3b\u0001\u0000\u0000"+
"\u0000\u0d3c\u0d3d\u0001\u0000\u0000\u0000\u0d3d\u0d3e\u0001\u0000\u0000"+
"\u0000\u0d3e\u0d40\u0005\u029c\u0000\u0000\u0d3f\u0d41\u0003\u0150\u00a8"+
"\u0000\u0d40\u0d3f\u0001\u0000\u0000\u0000\u0d40\u0d41\u0001\u0000\u0000"+
"\u0000\u0d41\u0fc4\u0001\u0000\u0000\u0000\u0d42\u0d43\u0005\u0254\u0000"+
"\u0000\u0d43\u0d44\u0005\u01ef\u0000\u0000\u0d44\u0d47\u0005\u026f\u0000"+
"\u0000\u0d45\u0d46\u0007(\u0000\u0000\u0d46\u0d48\u0003\u0250\u0128\u0000"+
"\u0d47\u0d45\u0001\u0000\u0000\u0000\u0d47\u0d48\u0001\u0000\u0000\u0000"+
"\u0d48\u0d4a\u0001\u0000\u0000\u0000\u0d49\u0d4b\u0003\u0150\u00a8\u0000"+
"\u0d4a\u0d49\u0001\u0000\u0000\u0000\u0d4a\u0d4b\u0001\u0000\u0000\u0000"+
"\u0d4b\u0fc4\u0001\u0000\u0000\u0000\u0d4c\u0d4d\u0005\u0254\u0000\u0000"+
"\u0d4d\u0d4e\u0005\u026e\u0000\u0000\u0d4e\u0d51\u0005\u0262\u0000\u0000"+
"\u0d4f\u0d50\u0007(\u0000\u0000\u0d50\u0d52\u0003\u0250\u0128\u0000\u0d51"+
"\u0d4f\u0001\u0000\u0000\u0000\u0d51\u0d52\u0001\u0000\u0000\u0000\u0d52"+
"\u0d54\u0001\u0000\u0000\u0000\u0d53\u0d55\u0003\u0150\u00a8\u0000\u0d54"+
"\u0d53\u0001\u0000\u0000\u0000\u0d54\u0d55\u0001\u0000\u0000\u0000\u0d55"+
"\u0fc4\u0001\u0000\u0000\u0000\u0d56\u0d58\u0005\u0254\u0000\u0000\u0d57"+
"\u0d59\u0005\u0175\u0000\u0000\u0d58\u0d57\u0001\u0000\u0000\u0000\u0d58"+
"\u0d59\u0001\u0000\u0000\u0000\u0d59\u0d5a\u0001\u0000\u0000\u0000\u0d5a"+
"\u0d5d\u0005\u026f\u0000\u0000\u0d5b\u0d5c\u0007(\u0000\u0000\u0d5c\u0d5e"+
"\u0003\u0250\u0128\u0000\u0d5d\u0d5b\u0001\u0000\u0000\u0000\u0d5d\u0d5e"+
"\u0001\u0000\u0000\u0000\u0d5e\u0d60\u0001\u0000\u0000\u0000\u0d5f\u0d61"+
"\u0003\u0150\u00a8\u0000\u0d60\u0d5f\u0001\u0000\u0000\u0000\u0d60\u0d61"+
"\u0001\u0000\u0000\u0000\u0d61\u0fc4\u0001\u0000\u0000\u0000\u0d62\u0d64"+
"\u0005\u0254\u0000\u0000\u0d63\u0d65\u0005\u0175\u0000\u0000\u0d64\u0d63"+
"\u0001\u0000\u0000\u0000\u0d64\u0d65\u0001\u0000\u0000\u0000\u0d65\u0d66"+
"\u0001\u0000\u0000\u0000\u0d66\u0d69\u0005\u02a3\u0000\u0000\u0d67\u0d68"+
"\u0007(\u0000\u0000\u0d68\u0d6a\u0003\u0250\u0128\u0000\u0d69\u0d67\u0001"+
"\u0000\u0000\u0000\u0d69\u0d6a\u0001\u0000\u0000\u0000\u0d6a\u0d6c\u0001"+
"\u0000\u0000\u0000\u0d6b\u0d6d\u0003\u0150\u00a8\u0000\u0d6c\u0d6b\u0001"+
"\u0000\u0000\u0000\u0d6c\u0d6d\u0001\u0000\u0000\u0000\u0d6d\u0fc4\u0001"+
"\u0000\u0000\u0000\u0d6e\u0d6f\u0005\u0254\u0000\u0000\u0d6f\u0d70\u0005"+
"\u026e\u0000\u0000\u0d70\u0fc4\u0005\u02cf\u0000\u0000\u0d71\u0d73\u0005"+
"\u0254\u0000\u0000\u0d72\u0d74\u0005\u0175\u0000\u0000\u0d73\u0d72\u0001"+
"\u0000\u0000\u0000\u0d73\u0d74\u0001\u0000\u0000\u0000\u0d74\u0d75\u0001"+
"\u0000\u0000\u0000\u0d75\u0fc4\u0005\u0214\u0000\u0000\u0d76\u0d78\u0005"+
"\u0254\u0000\u0000\u0d77\u0d79\u0007\u0011\u0000\u0000\u0d78\u0d77\u0001"+
"\u0000\u0000\u0000\u0d78\u0d79\u0001\u0000\u0000\u0000\u0d79\u0d7a\u0001"+
"\u0000\u0000\u0000\u0d7a\u0d7c\u0005\u0262\u0000\u0000\u0d7b\u0d7d\u0003"+
"\u0150\u00a8\u0000\u0d7c\u0d7b\u0001\u0000\u0000\u0000\u0d7c\u0d7d\u0001"+
"\u0000\u0000\u0000\u0d7d\u0fc4\u0001\u0000\u0000\u0000\u0d7e\u0d80\u0005"+
"\u0254\u0000\u0000\u0d7f\u0d81\u0005\u0175\u0000\u0000\u0d80\u0d7f\u0001"+
"\u0000\u0000\u0000\u0d80\u0d81\u0001\u0000\u0000\u0000\u0d81\u0d82\u0001"+
"\u0000\u0000\u0000\u0d82\u0d85\u0005\u0284\u0000\u0000\u0d83\u0d84\u0007"+
"(\u0000\u0000\u0d84\u0d86\u0003\u0250\u0128\u0000\u0d85\u0d83\u0001\u0000"+
"\u0000\u0000\u0d85\u0d86\u0001\u0000\u0000\u0000\u0d86\u0d88\u0001\u0000"+
"\u0000\u0000\u0d87\u0d89\u0003\u0150\u00a8\u0000\u0d88\u0d87\u0001\u0000"+
"\u0000\u0000\u0d88\u0d89\u0001\u0000\u0000\u0000\u0d89\u0fc4\u0001\u0000"+
"\u0000\u0000\u0d8a\u0d8b\u0005\u0254\u0000\u0000\u0d8b\u0d8e\u0005\u0156"+
"\u0000\u0000\u0d8c\u0d8d\u0007(\u0000\u0000\u0d8d\u0d8f\u0003\u0250\u0128"+
"\u0000\u0d8e\u0d8c\u0001\u0000\u0000\u0000\u0d8e\u0d8f\u0001\u0000\u0000"+
"\u0000\u0d8f\u0d91\u0001\u0000\u0000\u0000\u0d90\u0d92\u0003\u0150\u00a8"+
"\u0000\u0d91\u0d90\u0001\u0000\u0000\u0000\u0d91\u0d92\u0001\u0000\u0000"+
"\u0000\u0d92\u0fc4\u0001\u0000\u0000\u0000\u0d93\u0d94\u0005\u0254\u0000"+
"\u0000\u0d94\u0fc4\u0005\u020d\u0000\u0000\u0d95\u0d97\u0005\u0254\u0000"+
"\u0000\u0d96\u0d98\u0005\u0264\u0000\u0000\u0d97\u0d96\u0001\u0000\u0000"+
"\u0000\u0d97\u0d98\u0001\u0000\u0000\u0000\u0d98\u0d99\u0001\u0000\u0000"+
"\u0000\u0d99\u0fc4\u0005\u0152\u0000\u0000\u0d9a\u0d9b\u0005\u0254\u0000"+
"\u0000\u0d9b\u0fc4\u0005\u00d4\u0000\u0000\u0d9c\u0d9e\u0005\u0254\u0000"+
"\u0000\u0d9d\u0d9f\u0005\u00eb\u0000\u0000\u0d9e\u0d9d\u0001\u0000\u0000"+
"\u0000\u0d9e\u0d9f\u0001\u0000\u0000\u0000\u0d9f\u0da0\u0001\u0000\u0000"+
"\u0000\u0da0\u0da1\u0005\u0119\u0000\u0000\u0da1\u0da2\u0005\u026e\u0000"+
"\u0000\u0da2\u0fc4\u0003\u0250\u0128\u0000\u0da3\u0da4\u0005\u0254\u0000"+
"\u0000\u0da4\u0da5\u0005\u0119\u0000\u0000\u0da5\u0da6\u0005\u02a2\u0000"+
"\u0000\u0da6\u0fc4\u0003\u0250\u0128\u0000\u0da7\u0da8\u0005\u0254\u0000"+
"\u0000\u0da8\u0da9\u0005\u0119\u0000\u0000\u0da9\u0daa\u0005\u01d0\u0000"+
"\u0000\u0daa\u0dab\u0005\u02a2\u0000\u0000\u0dab\u0fc4\u0003\u0250\u0128"+
"\u0000\u0dac\u0dad\u0005\u0254\u0000\u0000\u0dad\u0dae\u0005\u0119\u0000"+
"\u0000\u0dae\u0daf\u0007,\u0000\u0000\u0daf\u0fc4\u0003\u0250\u0128\u0000"+
"\u0db0\u0db1\u0005\u0254\u0000\u0000\u0db1\u0db2\u0005\u0119\u0000\u0000"+
"\u0db2\u0db3\u0005\u00f8\u0000\u0000\u0db3\u0fc4\u0003\u02ca\u0165\u0000"+
"\u0db4\u0db5\u0005\u0254\u0000\u0000\u0db5\u0db7\u0005\u0119\u0000\u0000"+
"\u0db6\u0db8\u0007\u0011\u0000\u0000\u0db7\u0db6\u0001\u0000\u0000\u0000"+
"\u0db7\u0db8\u0001\u0000\u0000\u0000\u0db8\u0db9\u0001\u0000\u0000\u0000"+
"\u0db9\u0dba\u0005\u0176\u0000\u0000\u0dba\u0dbb\u0003\u0290\u0148\u0000"+
"\u0dbb\u0dbd\u0005\u00b6\u0000\u0000\u0dbc\u0dbe\u0003\u0192\u00c9\u0000"+
"\u0dbd\u0dbc\u0001\u0000\u0000\u0000\u0dbd\u0dbe\u0001\u0000\u0000\u0000"+
"\u0dbe\u0dbf\u0001\u0000\u0000\u0000\u0dbf\u0dc2\u0005\u00b7\u0000\u0000"+
"\u0dc0\u0dc1\u0007(\u0000\u0000\u0dc1\u0dc3\u0003\u0250\u0128\u0000\u0dc2"+
"\u0dc0\u0001\u0000\u0000\u0000\u0dc2\u0dc3\u0001\u0000\u0000\u0000\u0dc3"+
"\u0fc4\u0001\u0000\u0000\u0000\u0dc4\u0dc5\u0005\u0254\u0000\u0000\u0dc5"+
"\u0dc8\u0007-\u0000\u0000\u0dc6\u0dc7\u0005\u0172\u0000\u0000\u0dc7\u0dc9"+
"\u0003\u02ca\u0165\u0000\u0dc8\u0dc6\u0001\u0000\u0000\u0000\u0dc8\u0dc9"+
"\u0001\u0000\u0000\u0000\u0dc9\u0dcb\u0001\u0000\u0000\u0000\u0dca\u0dcc"+
"\u0003\u0150\u00a8\u0000\u0dcb\u0dca\u0001\u0000\u0000\u0000\u0dcb\u0dcc"+
"\u0001\u0000\u0000\u0000\u0dcc\u0fc4\u0001\u0000\u0000\u0000\u0dcd\u0dce"+
"\u0005\u0254\u0000\u0000\u0dce\u0dcf\u0005\u0125\u0000\u0000\u0dcf\u0fc4"+
"\u0005\u02cf\u0000\u0000\u0dd0\u0dd1\u0005\u0254\u0000\u0000\u0dd1\u0dd2"+
"\u0005\u0124\u0000\u0000\u0dd2\u0fc4\u0005\u028a\u0000\u0000\u0dd3\u0dd4"+
"\u0005\u0254\u0000\u0000\u0dd4\u0dd6\u0005\u00f9\u0000\u0000\u0dd5\u0dd7"+
"\u0003\u0150\u00a8\u0000\u0dd6\u0dd5\u0001\u0000\u0000\u0000\u0dd6\u0dd7"+
"\u0001\u0000\u0000\u0000\u0dd7\u0fc4\u0001\u0000\u0000\u0000\u0dd8\u0dd9"+
"\u0005\u0254\u0000\u0000\u0dd9\u0dda\u0005\u00f8\u0000\u0000\u0dda\u0fc4"+
"\u0003\u02ca\u0165\u0000\u0ddb\u0ddc\u0005\u0254\u0000\u0000\u0ddc\u0ddd"+
"\u0005\u0149\u0000\u0000\u0ddd\u0dde\u0005\u01f9\u0000\u0000\u0dde\u0de1"+
"\u0005\u026f\u0000\u0000\u0ddf\u0de0\u0007(\u0000\u0000\u0de0\u0de2\u0003"+
"\u0250\u0128\u0000\u0de1\u0ddf\u0001\u0000\u0000\u0000\u0de1\u0de2\u0001"+
"\u0000\u0000\u0000\u0de2\u0fc4\u0001\u0000\u0000\u0000\u0de3\u0de5\u0005"+
"\u0254\u0000\u0000\u0de4\u0de6\u0005\u0175\u0000\u0000\u0de5\u0de4\u0001"+
"\u0000\u0000\u0000\u0de5\u0de6\u0001\u0000\u0000\u0000\u0de6\u0de7\u0001"+
"\u0000\u0000\u0000\u0de7\u0de8\u0007.\u0000\u0000\u0de8\u0de9\u0007(\u0000"+
"\u0000\u0de9\u0dec\u0003\u0250\u0128\u0000\u0dea\u0deb\u0007(\u0000\u0000"+
"\u0deb\u0ded\u0003\u0250\u0128\u0000\u0dec\u0dea\u0001\u0000\u0000\u0000"+
"\u0dec\u0ded\u0001\u0000\u0000\u0000\u0ded\u0def\u0001\u0000\u0000\u0000"+
"\u0dee\u0df0\u0003\u0150\u00a8\u0000\u0def\u0dee\u0001\u0000\u0000\u0000"+
"\u0def\u0df0\u0001\u0000\u0000\u0000\u0df0\u0fc4\u0001\u0000\u0000\u0000"+
"\u0df1\u0df2\u0005\u0254\u0000\u0000\u0df2\u0df4\u0005\u0102\u0000\u0000"+
"\u0df3\u0df5\u0003\u0150\u00a8\u0000\u0df4\u0df3\u0001\u0000\u0000\u0000"+
"\u0df4\u0df5\u0001\u0000\u0000\u0000\u0df5\u0fc4\u0001\u0000\u0000\u0000"+
"\u0df6\u0dfa\u0005\u0254\u0000\u0000\u0df7\u0df8\u0005\u00fb\u0000\u0000"+
"\u0df8\u0dfb\u0005\u0250\u0000\u0000\u0df9\u0dfb\u0005\u00fc\u0000\u0000"+
"\u0dfa\u0df7\u0001\u0000\u0000\u0000\u0dfa\u0df9\u0001\u0000\u0000\u0000"+
"\u0dfb\u0dfd\u0001\u0000\u0000\u0000\u0dfc\u0dfe\u0003\u0150\u00a8\u0000"+
"\u0dfd\u0dfc\u0001\u0000\u0000\u0000\u0dfd\u0dfe\u0001\u0000\u0000\u0000"+
"\u0dfe\u0fc4\u0001\u0000\u0000\u0000\u0dff\u0e00\u0005\u0254\u0000\u0000"+
"\u0e00\u0e01\u0005\u0212\u0000\u0000\u0e01\u0fc4\u0005\u02ca\u0000\u0000"+
"\u0e02\u0e03\u0005\u0254\u0000\u0000\u0e03\u0e04\u0005\u0118\u0000\u0000"+
"\u0e04\u0e05\u0005\u00b6\u0000\u0000\u0e05\u0e06\u0005\u02b9\u0000\u0000"+
"\u0e06\u0e07\u0005\u00b7\u0000\u0000\u0e07\u0fc4\u0007/\u0000\u0000\u0e08"+
"\u0e09\u0005\u0254\u0000\u0000\u0e09\u0e0b\u0007/\u0000\u0000\u0e0a\u0e0c"+
"\u0003\u0232\u0119\u0000\u0e0b\u0e0a\u0001\u0000\u0000\u0000\u0e0b\u0e0c"+
"\u0001\u0000\u0000\u0000\u0e0c\u0fc4\u0001\u0000\u0000\u0000\u0e0d\u0e0e"+
"\u0005\u0254\u0000\u0000\u0e0e\u0e0f\u0005\u01bd\u0000\u0000\u0e0f\u0e1c"+
"\u0005\u02a5\u0000\u0000\u0e10\u0e11\u0007(\u0000\u0000\u0e11\u0e13\u0003"+
"\u0250\u0128\u0000\u0e12\u0e10\u0001\u0000\u0000\u0000\u0e12\u0e13\u0001"+
"\u0000\u0000\u0000\u0e13\u0e15\u0001\u0000\u0000\u0000\u0e14\u0e16\u0003"+
"\u0150\u00a8\u0000\u0e15\u0e14\u0001\u0000\u0000\u0000\u0e15\u0e16\u0001"+
"\u0000\u0000\u0000\u0e16\u0e18\u0001\u0000\u0000\u0000\u0e17\u0e19\u0003"+
"\u0232\u0119\u0000\u0e18\u0e17\u0001\u0000\u0000\u0000\u0e18\u0e19\u0001"+
"\u0000\u0000\u0000\u0e19\u0e1d\u0001\u0000\u0000\u0000\u0e1a\u0e1b\u0005"+
"\u01ed\u0000\u0000\u0e1b\u0e1d\u0005\u02ca\u0000\u0000\u0e1c\u0e12\u0001"+
"\u0000\u0000\u0000\u0e1c\u0e1a\u0001\u0000\u0000\u0000\u0e1d\u0fc4\u0001"+
"\u0000\u0000\u0000\u0e1e\u0e20\u0005\u0254\u0000\u0000\u0e1f\u0e21\u0005"+
"\u0265\u0000\u0000\u0e20\u0e1f\u0001\u0000\u0000\u0000\u0e20\u0e21\u0001"+
"\u0000\u0000\u0000\u0e21\u0e22\u0001\u0000\u0000\u0000\u0e22\u0e25\u0005"+
"\u01bd\u0000\u0000\u0e23\u0e24\u0007(\u0000\u0000\u0e24\u0e26\u0003\u0250"+
"\u0128\u0000\u0e25\u0e23\u0001\u0000\u0000\u0000\u0e25\u0e26\u0001\u0000"+
"\u0000\u0000\u0e26\u0e28\u0001\u0000\u0000\u0000\u0e27\u0e29\u0003\u0150"+
"\u00a8\u0000\u0e28\u0e27\u0001\u0000\u0000\u0000\u0e28\u0e29\u0001\u0000"+
"\u0000\u0000\u0e29\u0e2b\u0001\u0000\u0000\u0000\u0e2a\u0e2c\u0003\u022e"+
"\u0117\u0000\u0e2b\u0e2a\u0001\u0000\u0000\u0000\u0e2b\u0e2c\u0001\u0000"+
"\u0000\u0000\u0e2c\u0e2e\u0001\u0000\u0000\u0000\u0e2d\u0e2f\u0003\u0232"+
"\u0119\u0000\u0e2e\u0e2d\u0001\u0000\u0000\u0000\u0e2e\u0e2f\u0001\u0000"+
"\u0000\u0000\u0e2f\u0fc4\u0001\u0000\u0000\u0000\u0e30\u0e31\u0005\u0254"+
"\u0000\u0000\u0e31\u0e34\u0005\u015e\u0000\u0000\u0e32\u0e33\u0007(\u0000"+
"\u0000\u0e33\u0e35\u0003\u0250\u0128\u0000\u0e34\u0e32\u0001\u0000\u0000"+
"\u0000\u0e34\u0e35\u0001\u0000\u0000\u0000\u0e35\u0e37\u0001\u0000\u0000"+
"\u0000\u0e36\u0e38\u0003\u0150\u00a8\u0000\u0e37\u0e36\u0001\u0000\u0000"+
"\u0000\u0e37\u0e38\u0001\u0000\u0000\u0000\u0e38\u0e3a\u0001\u0000\u0000"+
"\u0000\u0e39\u0e3b\u0003\u022e\u0117\u0000\u0e3a\u0e39\u0001\u0000\u0000"+
"\u0000\u0e3a\u0e3b\u0001\u0000\u0000\u0000\u0e3b\u0e3d\u0001\u0000\u0000"+
"\u0000\u0e3c\u0e3e\u0003\u0232\u0119\u0000\u0e3d\u0e3c\u0001\u0000\u0000"+
"\u0000\u0e3d\u0e3e\u0001\u0000\u0000\u0000\u0e3e\u0fc4\u0001\u0000\u0000"+
"\u0000\u0e3f\u0e40\u0005\u0254\u0000\u0000\u0e40\u0e43\u0005\u0134\u0000"+
"\u0000\u0e41\u0e42\u0007(\u0000\u0000\u0e42\u0e44\u0003\u0250\u0128\u0000"+
"\u0e43\u0e41\u0001\u0000\u0000\u0000\u0e43\u0e44\u0001\u0000\u0000\u0000"+
"\u0e44\u0fc4\u0001\u0000\u0000\u0000\u0e45\u0e46\u0005\u0254\u0000\u0000"+
"\u0e46\u0e47\u0005\u00c9\u0000\u0000\u0e47\u0e4c\u0005\u026e\u0000\u0000"+
"\u0e48\u0e4d\u0005\u0240\u0000\u0000\u0e49\u0e4a\u0005\u01d0\u0000\u0000"+
"\u0e4a\u0e4d\u0005\u02a2\u0000\u0000\u0e4b\u0e4d\u0005\u0105\u0000\u0000"+
"\u0e4c\u0e48\u0001\u0000\u0000\u0000\u0e4c\u0e49\u0001\u0000\u0000\u0000"+
"\u0e4c\u0e4b\u0001\u0000\u0000\u0000\u0e4d\u0e50\u0001\u0000\u0000\u0000"+
"\u0e4e\u0e4f\u0007(\u0000\u0000\u0e4f\u0e51\u0003\u0250\u0128\u0000\u0e50"+
"\u0e4e\u0001\u0000\u0000\u0000\u0e50\u0e51\u0001\u0000\u0000\u0000\u0e51"+
"\u0e53\u0001\u0000\u0000\u0000\u0e52\u0e54\u0003\u0150\u00a8\u0000\u0e53"+
"\u0e52\u0001\u0000\u0000\u0000\u0e53\u0e54\u0001\u0000\u0000\u0000\u0e54"+
"\u0e56\u0001\u0000\u0000\u0000\u0e55\u0e57\u0003\u022e\u0117\u0000\u0e56"+
"\u0e55\u0001\u0000\u0000\u0000\u0e56\u0e57\u0001\u0000\u0000\u0000\u0e57"+
"\u0e59\u0001\u0000\u0000\u0000\u0e58\u0e5a\u0003\u0232\u0119\u0000\u0e59"+
"\u0e58\u0001\u0000\u0000\u0000\u0e59\u0e5a\u0001\u0000\u0000\u0000\u0e5a"+
"\u0fc4\u0001\u0000\u0000\u0000\u0e5b\u0e5c\u0005\u0254\u0000\u0000\u0e5c"+
"\u0e5d\u0005\u0124\u0000\u0000\u0e5d\u0e5e\u0005\u0256\u0000\u0000\u0e5e"+
"\u0e5f\u0005\u0172\u0000\u0000\u0e5f\u0fc4\u0003\u014e\u00a7\u0000\u0e60"+
"\u0e61\u0005\u0254\u0000\u0000\u0e61\u0e63\u0005\u0124\u0000\u0000\u0e62"+
"\u0e64\u0005\u00c8\u0000\u0000\u0e63\u0e62\u0001\u0000\u0000\u0000\u0e63"+
"\u0e64\u0001\u0000\u0000\u0000\u0e64\u0e67\u0001\u0000\u0000\u0000\u0e65"+
"\u0e66\u0005\u0172\u0000\u0000\u0e66\u0e68\u0003\u0250\u0128\u0000\u0e67"+
"\u0e65\u0001\u0000\u0000\u0000\u0e67\u0e68\u0001\u0000\u0000\u0000\u0e68"+
"\u0e6a\u0001\u0000\u0000\u0000\u0e69\u0e6b\u0003\u022e\u0117\u0000\u0e6a"+
"\u0e69\u0001\u0000\u0000\u0000\u0e6a\u0e6b\u0001\u0000\u0000\u0000\u0e6b"+
"\u0e6d\u0001\u0000\u0000\u0000\u0e6c\u0e6e\u0003\u0244\u0122\u0000\u0e6d"+
"\u0e6c\u0001\u0000\u0000\u0000\u0e6d\u0e6e\u0001\u0000\u0000\u0000\u0e6e"+
"\u0fc4\u0001\u0000\u0000\u0000\u0e6f\u0e71\u0005\u0254\u0000\u0000\u0e70"+
"\u0e72\u0005\u0276\u0000\u0000\u0e71\u0e70\u0001\u0000\u0000\u0000\u0e71"+
"\u0e72\u0001\u0000\u0000\u0000\u0e72\u0e73\u0001\u0000\u0000\u0000\u0e73"+
"\u0e74\u0005\u01fa\u0000\u0000\u0e74\u0e75\u0005\u0172\u0000\u0000\u0e75"+
"\u0e77\u0003\u0250\u0128\u0000\u0e76\u0e78\u0003\u0150\u00a8\u0000\u0e77"+
"\u0e76\u0001\u0000\u0000\u0000\u0e77\u0e78\u0001\u0000\u0000\u0000\u0e78"+
"\u0e7a\u0001\u0000\u0000\u0000\u0e79\u0e7b\u0003\u022e\u0117\u0000\u0e7a"+
"\u0e79\u0001\u0000\u0000\u0000\u0e7a\u0e7b\u0001\u0000\u0000\u0000\u0e7b"+
"\u0e7d\u0001\u0000\u0000\u0000\u0e7c\u0e7e\u0003\u0232\u0119\u0000\u0e7d"+
"\u0e7c\u0001\u0000\u0000\u0000\u0e7d\u0e7e\u0001\u0000\u0000\u0000\u0e7e"+
"\u0fc4\u0001\u0000\u0000\u0000\u0e7f\u0e80\u0005\u0254\u0000\u0000\u0e80"+
"\u0e81\u0005\u01f9\u0000\u0000\u0e81\u0fc4\u0005\u02cf\u0000\u0000\u0e82"+
"\u0e83\u0005\u0254\u0000\u0000\u0e83\u0e84\u0005\u0271\u0000\u0000\u0e84"+
"\u0fc4\u0005\u02cf\u0000\u0000\u0e85\u0e86\u0005\u0254\u0000\u0000\u0e86"+
"\u0e87\u0005\u0272\u0000\u0000\u0e87\u0e88\u0005\u00dc\u0000\u0000\u0e88"+
"\u0e8d\u0005\u02cf\u0000\u0000\u0e89\u0e8a\u0005\u00b8\u0000\u0000\u0e8a"+
"\u0e8c\u0005\u02cf\u0000\u0000\u0e8b\u0e89\u0001\u0000\u0000\u0000\u0e8c"+
"\u0e8f\u0001\u0000\u0000\u0000\u0e8d\u0e8b\u0001\u0000\u0000\u0000\u0e8d"+
"\u0e8e\u0001\u0000\u0000\u0000\u0e8e\u0fc4\u0001\u0000\u0000\u0000\u0e8f"+
"\u0e8d\u0001\u0000\u0000\u0000\u0e90\u0e91\u0005\u0254\u0000\u0000\u0e91"+
"\u0e92\u0005\u0272\u0000\u0000\u0e92\u0e93\u0005\u0172\u0000\u0000\u0e93"+
"\u0e95\u0003\u0250\u0128\u0000\u0e94\u0e96\u0003\u01ae\u00d7\u0000\u0e95"+
"\u0e94\u0001\u0000\u0000\u0000\u0e95\u0e96\u0001\u0000\u0000\u0000\u0e96"+
"\u0e98\u0001\u0000\u0000\u0000\u0e97\u0e99\u0003\u0150\u00a8\u0000\u0e98"+
"\u0e97\u0001\u0000\u0000\u0000\u0e98\u0e99\u0001\u0000\u0000\u0000\u0e99"+
"\u0e9b\u0001\u0000\u0000\u0000\u0e9a\u0e9c\u0003\u022e\u0117\u0000\u0e9b"+
"\u0e9a\u0001\u0000\u0000\u0000\u0e9b\u0e9c\u0001\u0000\u0000\u0000\u0e9c"+
"\u0e9e\u0001\u0000\u0000\u0000\u0e9d\u0e9f\u0003\u0232\u0119\u0000\u0e9e"+
"\u0e9d\u0001\u0000\u0000\u0000\u0e9e\u0e9f\u0001\u0000\u0000\u0000\u0e9f"+
"\u0fc4\u0001\u0000\u0000\u0000\u0ea0\u0ea1\u0005\u0254\u0000\u0000\u0ea1"+
"\u0ea4\u0005\u0217\u0000\u0000\u0ea2\u0ea3\u0005\u016d\u0000\u0000\u0ea3"+
"\u0ea5\u0003\u01c2\u00e1\u0000\u0ea4\u0ea2\u0001\u0000\u0000\u0000\u0ea4"+
"\u0ea5\u0001\u0000\u0000\u0000\u0ea5\u0ea7\u0001\u0000\u0000\u0000\u0ea6"+
"\u0ea8\u0003\u0150\u00a8\u0000\u0ea7\u0ea6\u0001\u0000\u0000\u0000\u0ea7"+
"\u0ea8\u0001\u0000\u0000\u0000\u0ea8\u0fc4\u0001\u0000\u0000\u0000\u0ea9"+
"\u0eaa\u0005\u0254\u0000\u0000\u0eaa\u0eab\u0005\u00c8\u0000\u0000\u0eab"+
"\u0ead\u0005\u0216\u0000\u0000\u0eac\u0eae\u0003\u0150\u00a8\u0000\u0ead"+
"\u0eac\u0001\u0000\u0000\u0000\u0ead\u0eae\u0001\u0000\u0000\u0000\u0eae"+
"\u0fc4\u0001\u0000\u0000\u0000\u0eaf\u0eb0\u0005\u0254\u0000\u0000\u0eb0"+
"\u0eb3\u0005\u00da\u0000\u0000\u0eb1\u0eb2\u0007(\u0000\u0000\u0eb2\u0eb4"+
"\u0003\u0250\u0128\u0000\u0eb3\u0eb1\u0001\u0000\u0000\u0000\u0eb3\u0eb4"+
"\u0001\u0000\u0000\u0000\u0eb4\u0eb6\u0001\u0000\u0000\u0000\u0eb5\u0eb7"+
"\u0003\u0150\u00a8\u0000\u0eb6\u0eb5\u0001\u0000\u0000\u0000\u0eb6\u0eb7"+
"\u0001\u0000\u0000\u0000\u0eb7\u0fc4\u0001\u0000\u0000\u0000\u0eb8\u0eba"+
"\u0005\u0254\u0000\u0000\u0eb9\u0ebb\u0005\u00eb\u0000\u0000\u0eba\u0eb9"+
"\u0001\u0000\u0000\u0000\u0eba\u0ebb\u0001\u0000\u0000\u0000\u0ebb\u0ebc"+
"\u0001\u0000\u0000\u0000\u0ebc\u0ebf\u0005\u0233\u0000\u0000\u0ebd\u0ebe"+
"\u0007(\u0000\u0000\u0ebe\u0ec0\u0003\u0250\u0128\u0000\u0ebf\u0ebd\u0001"+
"\u0000\u0000\u0000\u0ebf\u0ec0\u0001\u0000\u0000\u0000\u0ec0\u0ec2\u0001"+
"\u0000\u0000\u0000\u0ec1\u0ec3\u0003\u0150\u00a8\u0000\u0ec2\u0ec1\u0001"+
"\u0000\u0000\u0000\u0ec2\u0ec3\u0001\u0000\u0000\u0000\u0ec3\u0fc4\u0001"+
"\u0000\u0000\u0000\u0ec4\u0ec5\u0005\u0254\u0000\u0000\u0ec5\u0fc4\u0005"+
"\u00ec\u0000\u0000\u0ec6\u0ec7\u0005\u0254\u0000\u0000\u0ec7\u0ec9\u0005";
private static final String _serializedATNSegment2 =
"\u0232\u0000\u0000\u0ec8\u0eca\u0003\u0150\u00a8\u0000\u0ec9\u0ec8\u0001"+
"\u0000\u0000\u0000\u0ec9\u0eca\u0001\u0000\u0000\u0000\u0eca\u0ecc\u0001"+
"\u0000\u0000\u0000\u0ecb\u0ecd\u0003\u022e\u0117\u0000\u0ecc\u0ecb\u0001"+
"\u0000\u0000\u0000\u0ecc\u0ecd\u0001\u0000\u0000\u0000\u0ecd\u0ecf\u0001"+
"\u0000\u0000\u0000\u0ece\u0ed0\u0003\u0232\u0119\u0000\u0ecf\u0ece\u0001"+
"\u0000\u0000\u0000\u0ecf\u0ed0\u0001\u0000\u0000\u0000\u0ed0\u0fc4\u0001"+
"\u0000\u0000\u0000\u0ed1\u0ed2\u0005\u0254\u0000\u0000\u0ed2\u0ed3\u0005"+
"\u02ac\u0000\u0000\u0ed3\u0ed5\u0005\u0180\u0000\u0000\u0ed4\u0ed6\u0003"+
"\u0150\u00a8\u0000\u0ed5\u0ed4\u0001\u0000\u0000\u0000\u0ed5\u0ed6\u0001"+
"\u0000\u0000\u0000\u0ed6\u0fc4\u0001\u0000\u0000\u0000\u0ed7\u0ed8\u0005"+
"\u0254\u0000\u0000\u0ed8\u0fc4\u0005\u00d9\u0000\u0000\u0ed9\u0eda\u0005"+
"\u0254\u0000\u0000\u0eda\u0edd\u0005\u0282\u0000\u0000\u0edb\u0edc\u0005"+
"\u01ed\u0000\u0000\u0edc\u0ede\u0005\u02ca\u0000\u0000\u0edd\u0edb\u0001"+
"\u0000\u0000\u0000\u0edd\u0ede\u0001\u0000\u0000\u0000\u0ede\u0fc4\u0001"+
"\u0000\u0000\u0000\u0edf\u0ee0\u0005\u0254\u0000\u0000\u0ee0\u0ee2\u0005"+
"\u0174\u0000\u0000\u0ee1\u0ee3\u0003\u02ca\u0165\u0000\u0ee2\u0ee1\u0001"+
"\u0000\u0000\u0000\u0ee2\u0ee3\u0001\u0000\u0000\u0000\u0ee3\u0fc4\u0001"+
"\u0000\u0000\u0000\u0ee4\u0ee5\u0005\u0254\u0000\u0000\u0ee5\u0fc4\u0005"+
"\u022f\u0000\u0000\u0ee6\u0ee7\u0005\u0254\u0000\u0000\u0ee7\u0ee8\u0005"+
"\u0258\u0000\u0000\u0ee8\u0ee9\u0005\u01ed\u0000\u0000\u0ee9\u0eeb\u0003"+
"\u02ca\u0165\u0000\u0eea\u0eec\u0003\u0150\u00a8\u0000\u0eeb\u0eea\u0001"+
"\u0000\u0000\u0000\u0eeb\u0eec\u0001\u0000\u0000\u0000\u0eec\u0fc4\u0001"+
"\u0000\u0000\u0000\u0eed\u0eef\u0005\u0254\u0000\u0000\u0eee\u0ef0\u0005"+
"\u00c8\u0000\u0000\u0eef\u0eee\u0001\u0000\u0000\u0000\u0eef\u0ef0\u0001"+
"\u0000\u0000\u0000\u0ef0\u0ef1\u0001\u0000\u0000\u0000\u0ef1\u0fc4\u0005"+
"\u017c\u0000\u0000\u0ef2\u0ef3\u0005\u0254\u0000\u0000\u0ef3\u0ef4\u0005"+
"\u017c\u0000\u0000\u0ef4\u0ef5\u0005\u016d\u0000\u0000\u0ef5\u0fc4\u0003"+
"\u01ca\u00e5\u0000\u0ef6\u0ef7\u0005\u0254\u0000\u0000\u0ef7\u0fc4\u0005"+
"\u023e\u0000\u0000\u0ef8\u0ef9\u0005\u0254\u0000\u0000\u0ef9\u0fc4\u0005"+
"\u020a\u0000\u0000\u0efa\u0efc\u0005\u0254\u0000\u0000\u0efb\u0efd\u0005"+
"\u0175\u0000\u0000\u0efc\u0efb\u0001\u0000\u0000\u0000\u0efc\u0efd\u0001"+
"\u0000\u0000\u0000\u0efd\u0eff\u0001\u0000\u0000\u0000\u0efe\u0f00\u0005"+
"\u00ef\u0000\u0000\u0eff\u0efe\u0001\u0000\u0000\u0000\u0eff\u0f00\u0001"+
"\u0000\u0000\u0000\u0f00\u0f01\u0001\u0000\u0000\u0000\u0f01\u0f04\u0005"+
"\u0177\u0000\u0000\u0f02\u0f03\u0007(\u0000\u0000\u0f03\u0f05\u0003\u0250"+
"\u0128\u0000\u0f04\u0f02\u0001\u0000\u0000\u0000\u0f04\u0f05\u0001\u0000"+
"\u0000\u0000\u0f05\u0f07\u0001\u0000\u0000\u0000\u0f06\u0f08\u0003\u0150"+
"\u00a8\u0000\u0f07\u0f06\u0001\u0000\u0000\u0000\u0f07\u0f08\u0001\u0000"+
"\u0000\u0000\u0f08\u0fc4\u0001\u0000\u0000\u0000\u0f09\u0f0a\u0005\u0254"+
"\u0000\u0000\u0f0a\u0f0c\u0005\u017a\u0000\u0000\u0f0b\u0f0d\u0005\u0175"+
"\u0000\u0000\u0f0c\u0f0b\u0001\u0000\u0000\u0000\u0f0c\u0f0d\u0001\u0000"+
"\u0000\u0000\u0f0d\u0f0e\u0001\u0000\u0000\u0000\u0f0e\u0f10\u0005\u0177"+
"\u0000\u0000\u0f0f\u0f11\u0003\u0150\u00a8\u0000\u0f10\u0f0f\u0001\u0000"+
"\u0000\u0000\u0f10\u0f11\u0001\u0000\u0000\u0000\u0f11\u0fc4\u0001\u0000"+
"\u0000\u0000\u0f12\u0f13\u0005\u0254\u0000\u0000\u0f13\u0f16\u0005\u0289"+
"\u0000\u0000\u0f14\u0f15\u0007(\u0000\u0000\u0f15\u0f17\u0003\u0250\u0128"+
"\u0000\u0f16\u0f14\u0001\u0000\u0000\u0000\u0f16\u0f17\u0001\u0000\u0000"+
"\u0000\u0f17\u0fc4\u0001\u0000\u0000\u0000\u0f18\u0f19\u0005\u0254\u0000"+
"\u0000\u0f19\u0f1c\u0005\u0167\u0000\u0000\u0f1a\u0f1b\u0007(\u0000\u0000"+
"\u0f1b\u0f1d\u0003\u0250\u0128\u0000\u0f1c\u0f1a\u0001\u0000\u0000\u0000"+
"\u0f1c\u0f1d\u0001\u0000\u0000\u0000\u0f1d\u0fc4\u0001\u0000\u0000\u0000"+
"\u0f1e\u0f1f\u0005\u0254\u0000\u0000\u0f1f\u0f20\u00070\u0000\u0000\u0f20"+
"\u0f21\u0007(\u0000\u0000\u0f21\u0f24\u0003\u0250\u0128\u0000\u0f22\u0f23"+
"\u0007(\u0000\u0000\u0f23\u0f25\u0003\u0250\u0128\u0000\u0f24\u0f22\u0001"+
"\u0000\u0000\u0000\u0f24\u0f25\u0001\u0000\u0000\u0000\u0f25\u0fc4\u0001"+
"\u0000\u0000\u0000\u0f26\u0f27\u0005\u0254\u0000\u0000\u0f27\u0f2a\u0005"+
"\u0281\u0000\u0000\u0f28\u0f29\u0007(\u0000\u0000\u0f29\u0f2b\u0003\u0250"+
"\u0128\u0000\u0f2a\u0f28\u0001\u0000\u0000\u0000\u0f2a\u0f2b\u0001\u0000"+
"\u0000\u0000\u0f2b\u0f2d\u0001\u0000\u0000\u0000\u0f2c\u0f2e\u0003\u0150"+
"\u00a8\u0000\u0f2d\u0f2c\u0001\u0000\u0000\u0000\u0f2d\u0f2e\u0001\u0000"+
"\u0000\u0000\u0f2e\u0fc4\u0001\u0000\u0000\u0000\u0f2f\u0f30\u0005\u0254"+
"\u0000\u0000\u0f30\u0f31\u0005\u021a\u0000\u0000\u0f31\u0f33\u0005\u0215"+
"\u0000\u0000\u0f32\u0f34\u0005\u02ca\u0000\u0000\u0f33\u0f32\u0001\u0000"+
"\u0000\u0000\u0f33\u0f34\u0001\u0000\u0000\u0000\u0f34\u0f36\u0001\u0000"+
"\u0000\u0000\u0f35\u0f37\u0003\u0232\u0119\u0000\u0f36\u0f35\u0001\u0000"+
"\u0000\u0000\u0f36\u0f37\u0001\u0000\u0000\u0000\u0f37\u0fc4\u0001\u0000"+
"\u0000\u0000\u0f38\u0f39\u0005\u0254\u0000\u0000\u0f39\u0f3a\u0005\u01bd"+
"\u0000\u0000\u0f3a\u0f3c\u0005\u0215\u0000\u0000\u0f3b\u0f3d\u0005\u02ca"+
"\u0000\u0000\u0f3c\u0f3b\u0001\u0000\u0000\u0000\u0f3c\u0f3d\u0001\u0000"+
"\u0000\u0000\u0f3d\u0f3f\u0001\u0000\u0000\u0000\u0f3e\u0f40\u0003\u0232"+
"\u0119\u0000\u0f3f\u0f3e\u0001\u0000\u0000\u0000\u0f3f\u0f40\u0001\u0000"+
"\u0000\u0000\u0f40\u0fc4\u0001\u0000\u0000\u0000\u0f41\u0f42\u0005\u0254"+
"\u0000\u0000\u0f42\u0f43\u0005\u00f2\u0000\u0000\u0f43\u0f44\u0005\u0189"+
"\u0000\u0000\u0f44\u0fc4\u0005\u02ca\u0000\u0000\u0f45\u0f46\u0005\u0254"+
"\u0000\u0000\u0f46\u0f49\u0005\u014e\u0000\u0000\u0f47\u0f48\u0007(\u0000"+
"\u0000\u0f48\u0f4a\u0003\u0250\u0128\u0000\u0f49\u0f47\u0001\u0000\u0000"+
"\u0000\u0f49\u0f4a\u0001\u0000\u0000\u0000\u0f4a\u0f4c\u0001\u0000\u0000"+
"\u0000\u0f4b\u0f4d\u0003\u0150\u00a8\u0000\u0f4c\u0f4b\u0001\u0000\u0000"+
"\u0000\u0f4c\u0f4d\u0001\u0000\u0000\u0000\u0f4d\u0fc4\u0001\u0000\u0000"+
"\u0000\u0f4e\u0f4f\u0005\u0254\u0000\u0000\u0f4f\u0f50\u0005\u026e\u0000"+
"\u0000\u0f50\u0f53\u0005\u011a\u0000\u0000\u0f51\u0f52\u0007(\u0000\u0000"+
"\u0f52\u0f54\u0003\u0250\u0128\u0000\u0f53\u0f51\u0001\u0000\u0000\u0000"+
"\u0f53\u0f54\u0001\u0000\u0000\u0000\u0f54\u0f56\u0001\u0000\u0000\u0000"+
"\u0f55\u0f57\u0003\u0150\u00a8\u0000\u0f56\u0f55\u0001\u0000\u0000\u0000"+
"\u0f56\u0f57\u0001\u0000\u0000\u0000\u0f57\u0fc4\u0001\u0000\u0000\u0000"+
"\u0f58\u0f59\u0005\u0254\u0000\u0000\u0f59\u0f5a\u0005\u01b1\u0000\u0000"+
"\u0f5a\u0fc4\u0005\u0197\u0000\u0000\u0f5b\u0f5c\u0005\u0254\u0000\u0000"+
"\u0f5c\u0f5d\u0005\u0119\u0000\u0000\u0f5d\u0f5e\u0005\u01d0\u0000\u0000"+
"\u0f5e\u0f5f\u0005\u02a2\u0000\u0000\u0f5f\u0f60\u0003\u02ca\u0165\u0000"+
"\u0f60\u0f61\u0005\u01ed\u0000\u0000\u0f61\u0f62\u0003\u0250\u0128\u0000"+
"\u0f62\u0fc4\u0001\u0000\u0000\u0000\u0f63\u0f64\u0005\u0254\u0000\u0000"+
"\u0f64\u0f65\u0005\u00f8\u0000\u0000\u0f65\u0f66\u0005\u0223\u0000\u0000"+
"\u0f66\u0f68\u0005\u00df\u0000\u0000\u0f67\u0f69\u0003\u0150\u00a8\u0000"+
"\u0f68\u0f67\u0001\u0000\u0000\u0000\u0f68\u0f69\u0001\u0000\u0000\u0000"+
"\u0f69\u0fc4\u0001\u0000\u0000\u0000\u0f6a\u0f6b\u0005\u0254\u0000\u0000"+
"\u0f6b\u0f6c\u0005\u021a\u0000\u0000\u0f6c\u0f77\u0005\u0261\u0000\u0000"+
"\u0f6d\u0f6e\u0005\u016d\u0000\u0000\u0f6e\u0f78\u0003\u02ca\u0165\u0000"+
"\u0f6f\u0f70\u0005\u0172\u0000\u0000\u0f70\u0f75\u0003\u0250\u0128\u0000"+
"\u0f71\u0f73\u0005\u00c8\u0000\u0000\u0f72\u0f74\u0005\u02a0\u0000\u0000"+
"\u0f73\u0f72\u0001\u0000\u0000\u0000\u0f73\u0f74\u0001\u0000\u0000\u0000"+
"\u0f74\u0f76\u0001\u0000\u0000\u0000\u0f75\u0f71\u0001\u0000\u0000\u0000"+
"\u0f75\u0f76\u0001\u0000\u0000\u0000\u0f76\u0f78\u0001\u0000\u0000\u0000"+
"\u0f77\u0f6d\u0001\u0000\u0000\u0000\u0f77\u0f6f\u0001\u0000\u0000\u0000"+
"\u0f77\u0f78\u0001\u0000\u0000\u0000\u0f78\u0fc4\u0001\u0000\u0000\u0000"+
"\u0f79\u0f7a\u0005\u0254\u0000\u0000\u0f7a\u0f7b\u0005\u00ee\u0000\u0000"+
"\u0f7b\u0f7e\u0005\u0193\u0000\u0000\u0f7c\u0f7d\u0007(\u0000\u0000\u0f7d"+
"\u0f7f\u0003\u0250\u0128\u0000\u0f7e\u0f7c\u0001\u0000\u0000\u0000\u0f7e"+
"\u0f7f\u0001\u0000\u0000\u0000\u0f7f\u0f81\u0001\u0000\u0000\u0000\u0f80"+
"\u0f82\u0003\u0150\u00a8\u0000\u0f81\u0f80\u0001\u0000\u0000\u0000\u0f81"+
"\u0f82\u0001\u0000\u0000\u0000\u0f82\u0f84\u0001\u0000\u0000\u0000\u0f83"+
"\u0f85\u0003\u022e\u0117\u0000\u0f84\u0f83\u0001\u0000\u0000\u0000\u0f84"+
"\u0f85\u0001\u0000\u0000\u0000\u0f85\u0f87\u0001\u0000\u0000\u0000\u0f86"+
"\u0f88\u0003\u0232\u0119\u0000\u0f87\u0f86\u0001\u0000\u0000\u0000\u0f87"+
"\u0f88\u0001\u0000\u0000\u0000\u0f88\u0fc4\u0001\u0000\u0000\u0000\u0f89"+
"\u0f8d\u0005\u0254\u0000\u0000\u0f8a\u0f8e\u0005\u0100\u0000\u0000\u0f8b"+
"\u0f8c\u0005\u010d\u0000\u0000\u0f8c\u0f8e\u0005\u0180\u0000\u0000\u0f8d"+
"\u0f8a\u0001\u0000\u0000\u0000\u0f8d\u0f8b\u0001\u0000\u0000\u0000\u0f8e"+
"\u0fc4\u0001\u0000\u0000\u0000\u0f8f\u0f90\u0005\u0254\u0000\u0000\u0f90"+
"\u0f93\u0005\u0116\u0000\u0000\u0f91\u0f92\u0007(\u0000\u0000\u0f92\u0f94"+
"\u0003\u0250\u0128\u0000\u0f93\u0f91\u0001\u0000\u0000\u0000\u0f93\u0f94"+
"\u0001\u0000\u0000\u0000\u0f94\u0fc4\u0001\u0000\u0000\u0000\u0f95\u0f96"+
"\u0005\u0254\u0000\u0000\u0f96\u0f97\u0005\u022e\u0000\u0000\u0f97\u0f98"+
"\u0005\u0262\u0000\u0000\u0f98\u0f99\u0005\u0172\u0000\u0000\u0f99\u0f9b"+
"\u0003\u014e\u00a7\u0000\u0f9a\u0f9c\u0003\u0150\u00a8\u0000\u0f9b\u0f9a"+
"\u0001\u0000\u0000\u0000\u0f9b\u0f9c\u0001\u0000\u0000\u0000\u0f9c\u0fc4"+
"\u0001\u0000\u0000\u0000\u0f9d\u0f9e\u0005\u0254\u0000\u0000\u0f9e\u0f9f"+
"\u0005\u022e\u0000\u0000\u0f9f\u0fa0\u0005\u013f\u0000\u0000\u0fa0\u0fa1"+
"\u0005\u0172\u0000\u0000\u0fa1\u0fc4\u0003\u014e\u00a7\u0000\u0fa2\u0fa3"+
"\u0005\u0254\u0000\u0000\u0fa3\u0fa4\u0005\u0271\u0000\u0000\u0fa4\u0fa5"+
"\u0005\u0264\u0000\u0000\u0fa5\u0fa7\u0005\u0170\u0000\u0000\u0fa6\u0fa8"+
"\u0005\u02a0\u0000\u0000\u0fa7\u0fa6\u0001\u0000\u0000\u0000\u0fa7\u0fa8"+
"\u0001\u0000\u0000\u0000\u0fa8\u0fc4\u0001\u0000\u0000\u0000\u0fa9\u0faa"+
"\u0005\u0254\u0000\u0000\u0faa\u0fab\u0005\u0271\u0000\u0000\u0fab\u0fac"+
"\u0005\u0139\u0000\u0000\u0fac\u0fc4\u0005\u02cf\u0000\u0000\u0fad\u0fae"+
"\u0005\u0254\u0000\u0000\u0fae\u0fb1\u0005\u0117\u0000\u0000\u0faf\u0fb0"+
"\u0007(\u0000\u0000\u0fb0\u0fb2\u0003\u0250\u0128\u0000\u0fb1\u0faf\u0001"+
"\u0000\u0000\u0000\u0fb1\u0fb2\u0001\u0000\u0000\u0000\u0fb2\u0fb4\u0001"+
"\u0000\u0000\u0000\u0fb3\u0fb5\u0003\u0204\u0102\u0000\u0fb4\u0fb3\u0001"+
"\u0000\u0000\u0000\u0fb4\u0fb5\u0001\u0000\u0000\u0000\u0fb5\u0fb7\u0001"+
"\u0000\u0000\u0000\u0fb6\u0fb8\u0003\u022e\u0117\u0000\u0fb7\u0fb6\u0001"+
"\u0000\u0000\u0000\u0fb7\u0fb8\u0001\u0000\u0000\u0000\u0fb8\u0fba\u0001"+
"\u0000\u0000\u0000\u0fb9\u0fbb\u0003\u0232\u0119\u0000\u0fba\u0fb9\u0001"+
"\u0000\u0000\u0000\u0fba\u0fbb\u0001\u0000\u0000\u0000\u0fbb\u0fc4\u0001"+
"\u0000\u0000\u0000\u0fbc\u0fbd\u0005\u0254\u0000\u0000\u0fbd\u0fbe\u0005"+
"\u02a4\u0000\u0000\u0fbe\u0fbf\u0005\u0293\u0000\u0000\u0fbf\u0fc1\u0005"+
"\u01a7\u0000\u0000\u0fc0\u0fc2\u0003\u0150\u00a8\u0000\u0fc1\u0fc0\u0001"+
"\u0000\u0000\u0000\u0fc1\u0fc2\u0001\u0000\u0000\u0000\u0fc2\u0fc4\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d13\u0001\u0000\u0000\u0000\u0fc3\u0d19\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d24\u0001\u0000\u0000\u0000\u0fc3\u0d2e\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d30\u0001\u0000\u0000\u0000\u0fc3\u0d33\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d38\u0001\u0000\u0000\u0000\u0fc3\u0d3a\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d42\u0001\u0000\u0000\u0000\u0fc3\u0d4c\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d56\u0001\u0000\u0000\u0000\u0fc3\u0d62\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d6e\u0001\u0000\u0000\u0000\u0fc3\u0d71\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d76\u0001\u0000\u0000\u0000\u0fc3\u0d7e\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d8a\u0001\u0000\u0000\u0000\u0fc3\u0d93\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d95\u0001\u0000\u0000\u0000\u0fc3\u0d9a\u0001"+
"\u0000\u0000\u0000\u0fc3\u0d9c\u0001\u0000\u0000\u0000\u0fc3\u0da3\u0001"+
"\u0000\u0000\u0000\u0fc3\u0da7\u0001\u0000\u0000\u0000\u0fc3\u0dac\u0001"+
"\u0000\u0000\u0000\u0fc3\u0db0\u0001\u0000\u0000\u0000\u0fc3\u0db4\u0001"+
"\u0000\u0000\u0000\u0fc3\u0dc4\u0001\u0000\u0000\u0000\u0fc3\u0dcd\u0001"+
"\u0000\u0000\u0000\u0fc3\u0dd0\u0001\u0000\u0000\u0000\u0fc3\u0dd3\u0001"+
"\u0000\u0000\u0000\u0fc3\u0dd8\u0001\u0000\u0000\u0000\u0fc3\u0ddb\u0001"+
"\u0000\u0000\u0000\u0fc3\u0de3\u0001\u0000\u0000\u0000\u0fc3\u0df1\u0001"+
"\u0000\u0000\u0000\u0fc3\u0df6\u0001\u0000\u0000\u0000\u0fc3\u0dff\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e02\u0001\u0000\u0000\u0000\u0fc3\u0e08\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e0d\u0001\u0000\u0000\u0000\u0fc3\u0e1e\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e30\u0001\u0000\u0000\u0000\u0fc3\u0e3f\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e45\u0001\u0000\u0000\u0000\u0fc3\u0e5b\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e60\u0001\u0000\u0000\u0000\u0fc3\u0e6f\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e7f\u0001\u0000\u0000\u0000\u0fc3\u0e82\u0001"+
"\u0000\u0000\u0000\u0fc3\u0e85\u0001\u0000\u0000\u0000\u0fc3\u0e90\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ea0\u0001\u0000\u0000\u0000\u0fc3\u0ea9\u0001"+
"\u0000\u0000\u0000\u0fc3\u0eaf\u0001\u0000\u0000\u0000\u0fc3\u0eb8\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ec4\u0001\u0000\u0000\u0000\u0fc3\u0ec6\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ed1\u0001\u0000\u0000\u0000\u0fc3\u0ed7\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ed9\u0001\u0000\u0000\u0000\u0fc3\u0edf\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ee4\u0001\u0000\u0000\u0000\u0fc3\u0ee6\u0001"+
"\u0000\u0000\u0000\u0fc3\u0eed\u0001\u0000\u0000\u0000\u0fc3\u0ef2\u0001"+
"\u0000\u0000\u0000\u0fc3\u0ef6\u0001\u0000\u0000\u0000\u0fc3\u0ef8\u0001"+
"\u0000\u0000\u0000\u0fc3\u0efa\u0001\u0000\u0000\u0000\u0fc3\u0f09\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f12\u0001\u0000\u0000\u0000\u0fc3\u0f18\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f1e\u0001\u0000\u0000\u0000\u0fc3\u0f26\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f2f\u0001\u0000\u0000\u0000\u0fc3\u0f38\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f41\u0001\u0000\u0000\u0000\u0fc3\u0f45\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f4e\u0001\u0000\u0000\u0000\u0fc3\u0f58\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f5b\u0001\u0000\u0000\u0000\u0fc3\u0f63\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f6a\u0001\u0000\u0000\u0000\u0fc3\u0f79\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f89\u0001\u0000\u0000\u0000\u0fc3\u0f8f\u0001"+
"\u0000\u0000\u0000\u0fc3\u0f95\u0001\u0000\u0000\u0000\u0fc3\u0f9d\u0001"+
"\u0000\u0000\u0000\u0fc3\u0fa2\u0001\u0000\u0000\u0000\u0fc3\u0fa9\u0001"+
"\u0000\u0000\u0000\u0fc3\u0fad\u0001\u0000\u0000\u0000\u0fc3\u0fbc\u0001"+
"\u0000\u0000\u0000\u0fc4\u0131\u0001\u0000\u0000\u0000\u0fc5\u0fc6\u0005"+
"\u01bd\u0000\u0000\u0fc6\u0fcc\u0003\u01ea\u00f5\u0000\u0fc7\u0fc8\u0005"+
"\u0216\u0000\u0000\u0fc8\u0fc9\u0005\u00b6\u0000\u0000\u0fc9\u0fca\u0003"+
"\u0246\u0123\u0000\u0fca\u0fcb\u0005\u00b7\u0000\u0000\u0fcb\u0fcd\u0001"+
"\u0000\u0000\u0000\u0fcc\u0fc7\u0001\u0000\u0000\u0000\u0fcc\u0fcd\u0001"+
"\u0000\u0000\u0000\u0fcd\u0fcf\u0001\u0000\u0000\u0000\u0fce\u0fd0\u0003"+
"\u02be\u015f\u0000\u0fcf\u0fce\u0001\u0000\u0000\u0000\u0fcf\u0fd0\u0001"+
"\u0000\u0000\u0000\u0fd0\u1036\u0001\u0000\u0000\u0000\u0fd1\u0fd2\u0005"+
"\u0119\u0000\u0000\u0fd2\u0fd3\u0005\u0241\u0000\u0000\u0fd3\u0fd4\u0005"+
"\u01bd\u0000\u0000\u0fd4\u0fd7\u0003\u0250\u0128\u0000\u0fd5\u0fd6\u0005"+
"\u01ed\u0000\u0000\u0fd6\u0fd8\u0003\u02ca\u0165\u0000\u0fd7\u0fd5\u0001"+
"\u0000\u0000\u0000\u0fd7\u0fd8\u0001\u0000\u0000\u0000\u0fd8\u0fdb\u0001"+
"\u0000\u0000\u0000\u0fd9\u0fda\u0005\u02aa\u0000\u0000\u0fda\u0fdc\u0007"+
"1\u0000\u0000\u0fdb\u0fd9\u0001\u0000\u0000\u0000\u0fdb\u0fdc\u0001\u0000"+
"\u0000\u0000\u0fdc\u0fe5\u0001\u0000\u0000\u0000\u0fdd\u0fe2\u0003\u0134"+
"\u009a\u0000\u0fde\u0fdf\u0005\u00b8\u0000\u0000\u0fdf\u0fe1\u0003\u0134"+
"\u009a\u0000\u0fe0\u0fde\u0001\u0000\u0000\u0000\u0fe1\u0fe4\u0001\u0000"+
"\u0000\u0000\u0fe2\u0fe0\u0001\u0000\u0000\u0000\u0fe2\u0fe3\u0001\u0000"+
"\u0000\u0000\u0fe3\u0fe6\u0001\u0000\u0000\u0000\u0fe4\u0fe2\u0001\u0000"+
"\u0000\u0000\u0fe5\u0fdd\u0001\u0000\u0000\u0000\u0fe5\u0fe6\u0001\u0000"+
"\u0000\u0000\u0fe6\u0fe8\u0001\u0000\u0000\u0000\u0fe7\u0fe9\u0003\u0244"+
"\u0122\u0000\u0fe8\u0fe7\u0001\u0000\u0000\u0000\u0fe8\u0fe9\u0001\u0000"+
"\u0000\u0000\u0fe9\u0fea\u0001\u0000\u0000\u0000\u0fea\u0feb\u0005\u0172"+
"\u0000\u0000\u0feb\u0fec\u0003\u02ca\u0165\u0000\u0fec\u0fed\u0005\u00b6"+
"\u0000\u0000\u0fed\u0fee\u0003\u0246\u0123\u0000\u0fee\u0ff0\u0005\u00b7"+
"\u0000\u0000\u0fef\u0ff1\u0003\u02be\u015f\u0000\u0ff0\u0fef\u0001\u0000"+
"\u0000\u0000\u0ff0\u0ff1\u0001\u0000\u0000\u0000\u0ff1\u1036\u0001\u0000"+
"\u0000\u0000\u0ff2\u0ff3\u0005\u0201\u0000\u0000\u0ff3\u0ff4\u0005\u0241"+
"\u0000\u0000\u0ff4\u0ff5\u0005\u01bd\u0000\u0000\u0ff5\u0ff6\u0005\u016d"+
"\u0000\u0000\u0ff6\u1036\u0003\u0250\u0128\u0000\u0ff7\u0ff8\u0005\u0201"+
"\u0000\u0000\u0ff8\u0ff9\u0005\u00c8\u0000\u0000\u0ff9\u0ffa\u0005\u0241"+
"\u0000\u0000\u0ffa\u1036\u0005\u01bd\u0000\u0000\u0ffb\u0ffc\u0005\u0235"+
"\u0000\u0000\u0ffc\u0ffd\u0005\u0241\u0000\u0000\u0ffd\u0ffe\u0005\u01bd"+
"\u0000\u0000\u0ffe\u0fff\u0005\u016d\u0000\u0000\u0fff\u1036\u0003\u0250"+
"\u0128\u0000\u1000\u1001\u0005\u0235\u0000\u0000\u1001\u1002\u0005\u00c8"+
"\u0000\u0000\u1002\u1003\u0005\u0241\u0000\u0000\u1003\u1036\u0005\u01bd"+
"\u0000\u0000\u1004\u1005\u0005\u0263\u0000\u0000\u1005\u1006\u0005\u0241"+
"\u0000\u0000\u1006\u1007\u0005\u01bd\u0000\u0000\u1007\u1008\u0005\u016d"+
"\u0000\u0000\u1008\u1036\u0003\u0250\u0128\u0000\u1009\u100b\u0005\u0254"+
"\u0000\u0000\u100a\u100c\u0005\u00c8\u0000\u0000\u100b\u100a\u0001\u0000"+
"\u0000\u0000\u100b\u100c\u0001\u0000\u0000\u0000\u100c\u100d\u0001\u0000"+
"\u0000\u0000\u100d\u100e\u0005\u0241\u0000\u0000\u100e\u1014\u0005\u01bd"+
"\u0000\u0000\u100f\u1010\u0005\u016d\u0000\u0000\u1010\u1015\u0003\u0250"+
"\u0128\u0000\u1011\u1013\u0003\u0150\u00a8\u0000\u1012\u1011\u0001\u0000"+
"\u0000\u0000\u1012\u1013\u0001\u0000\u0000\u0000\u1013\u1015\u0001\u0000"+
"\u0000\u0000\u1014\u100f\u0001\u0000\u0000\u0000\u1014\u1012\u0001\u0000"+
"\u0000\u0000\u1015\u1036\u0001\u0000\u0000\u0000\u1016\u1017\u0005\u0254"+
"\u0000\u0000\u1017\u1018\u0005\u0241\u0000\u0000\u1018\u1019\u0005\u01bd"+
"\u0000\u0000\u1019\u101c\u0005\u0274\u0000\u0000\u101a\u101b\u0007(\u0000"+
"\u0000\u101b\u101d\u0003\u02ca\u0165\u0000\u101c\u101a\u0001\u0000\u0000"+
"\u0000\u101c\u101d\u0001\u0000\u0000\u0000\u101d\u101f\u0001\u0000\u0000"+
"\u0000\u101e\u1020\u0003\u0150\u00a8\u0000\u101f\u101e\u0001\u0000\u0000"+
"\u0000\u101f\u1020\u0001\u0000\u0000\u0000\u1020\u1036\u0001\u0000\u0000"+
"\u0000\u1021\u1023\u0005\u0254\u0000\u0000\u1022\u1024\u0005\u00c8\u0000"+
"\u0000\u1023\u1022\u0001\u0000\u0000\u0000\u1023\u1024\u0001\u0000\u0000"+
"\u0000\u1024\u1025\u0001\u0000\u0000\u0000\u1025\u1026\u0005\u0119\u0000"+
"\u0000\u1026\u1027\u0005\u0241\u0000\u0000\u1027\u1028\u0005\u01bd\u0000"+
"\u0000\u1028\u1029\u0005\u016d\u0000\u0000\u1029\u1036\u0003\u0250\u0128"+
"\u0000\u102a\u102b\u0005\u0254\u0000\u0000\u102b\u102c\u0005\u0119\u0000"+
"\u0000\u102c\u102d\u0005\u01bd\u0000\u0000\u102d\u102e\u0005\u016d\u0000"+
"\u0000\u102e\u1036\u0003\u0250\u0128\u0000\u102f\u1036\u0005\u026c\u0000"+
"\u0000\u1030\u1036\u0003\u0136\u009b\u0000\u1031\u1036\u0003\u013c\u009e"+
"\u0000\u1032\u1036\u0003\u013a\u009d\u0000\u1033\u1036\u0003\u0138\u009c"+
"\u0000\u1034\u1036\u0003\u013e\u009f\u0000\u1035\u0fc5\u0001\u0000\u0000"+
"\u0000\u1035\u0fd1\u0001\u0000\u0000\u0000\u1035\u0ff2\u0001\u0000\u0000"+
"\u0000\u1035\u0ff7\u0001\u0000\u0000\u0000\u1035\u0ffb\u0001\u0000\u0000"+
"\u0000\u1035\u1000\u0001\u0000\u0000\u0000\u1035\u1004\u0001\u0000\u0000"+
"\u0000\u1035\u1009\u0001\u0000\u0000\u0000\u1035\u1016\u0001\u0000\u0000"+
"\u0000\u1035\u1021\u0001\u0000\u0000\u0000\u1035\u102a\u0001\u0000\u0000"+
"\u0000\u1035\u102f\u0001\u0000\u0000\u0000\u1035\u1030\u0001\u0000\u0000"+
"\u0000\u1035\u1031\u0001\u0000\u0000\u0000\u1035\u1032\u0001\u0000\u0000"+
"\u0000\u1035\u1033\u0001\u0000\u0000\u0000\u1035\u1034\u0001\u0000\u0000"+
"\u0000\u1036\u0133\u0001\u0000\u0000\u0000\u1037\u1038\u0005\u0106\u0000"+
"\u0000\u1038\u1039\u0005\u0277\u0000\u0000\u1039\u103a\u0005\u00f1\u0000"+
"\u0000\u103a\u1042\u0005\u02ca\u0000\u0000\u103b\u1042\u0003\u013e\u009f"+
"\u0000\u103c\u1042\u0003\u013c\u009e\u0000\u103d\u1042\u0003\u013a\u009d"+
"\u0000\u103e\u1042\u0003\u0138\u009c\u0000\u103f\u1042\u0003\u0136\u009b"+
"\u0000\u1040\u1042\u0003\u01ae\u00d7\u0000\u1041\u1037\u0001\u0000\u0000"+
"\u0000\u1041\u103b\u0001\u0000\u0000\u0000\u1041\u103c\u0001\u0000\u0000"+
"\u0000\u1041\u103d\u0001\u0000\u0000\u0000\u1041\u103e\u0001\u0000\u0000"+
"\u0000\u1041\u103f\u0001\u0000\u0000\u0000\u1041\u1040\u0001\u0000\u0000"+
"\u0000\u1042\u0135\u0001\u0000\u0000\u0000\u1043\u1044\u0005\u01f2\u0000"+
"\u0000\u1044\u1045\u0005\u00f1\u0000\u0000\u1045\u1046\u0003\u02ca\u0165"+
"\u0000\u1046\u0137\u0001\u0000\u0000\u0000\u1047\u1048\u0005\u0134\u0000"+
"\u0000\u1048\u1049\u0005\u01ed\u0000\u0000\u1049\u104a\u0003\u0280\u0140"+
"\u0000\u104a\u0139\u0001\u0000\u0000\u0000\u104b\u104c\u0005\u02a8\u0000"+
"\u0000\u104c\u104d\u0003\u0280\u0140\u0000\u104d\u013b\u0001\u0000\u0000"+
"\u0000\u104e\u104f\u0005\u020f\u0000\u0000\u104f\u1050\u0005\u0168\u0000"+
"\u0000\u1050\u1051\u0003\u0280\u0140\u0000\u1051\u013d\u0001\u0000\u0000"+
"\u0000\u1052\u1053\u0005\u0106\u0000\u0000\u1053\u1054\u0005\u00b6\u0000"+
"\u0000\u1054\u1059\u0003\u0140\u00a0\u0000\u1055\u1056\u0005\u00b8\u0000"+
"\u0000\u1056\u1058\u0003\u0140\u00a0\u0000\u1057\u1055\u0001\u0000\u0000"+
"\u0000\u1058\u105b\u0001\u0000\u0000\u0000\u1059\u1057\u0001\u0000\u0000"+
"\u0000\u1059\u105a\u0001\u0000\u0000\u0000\u105a\u105c\u0001\u0000\u0000"+
"\u0000\u105b\u1059\u0001\u0000\u0000\u0000\u105c\u105d\u0005\u00b7\u0000"+
"\u0000\u105d\u013f\u0001\u0000\u0000\u0000\u105e\u1061\u0003\u02ca\u0165"+
"\u0000\u105f\u1060\u0005\u02b0\u0000\u0000\u1060\u1062\u0003\u0280\u0140"+
"\u0000\u1061\u105f\u0001\u0000\u0000\u0000\u1061\u1062\u0001\u0000\u0000"+
"\u0000\u1062\u106c\u0001\u0000\u0000\u0000\u1063\u1064\u0005\u00b6\u0000"+
"\u0000\u1064\u1067\u0003\u02ca\u0165\u0000\u1065\u1066\u0005\u02b0\u0000"+
"\u0000\u1066\u1068\u0003\u0280\u0140\u0000\u1067\u1065\u0001\u0000\u0000"+
"\u0000\u1067\u1068\u0001\u0000\u0000\u0000\u1068\u1069\u0001\u0000\u0000"+
"\u0000\u1069\u106a\u0005\u00b7\u0000\u0000\u106a\u106c\u0001\u0000\u0000"+
"\u0000\u106b\u105e\u0001\u0000\u0000\u0000\u106b\u1063\u0001\u0000\u0000"+
"\u0000\u106c\u0141\u0001\u0000\u0000\u0000\u106d\u106e\u0005\u0224\u0000"+
"\u0000\u106e\u106f\u0005\u026e\u0000\u0000\u106f\u1084\u0003\u0250\u0128"+
"\u0000\u1070\u1071\u0005\u0224\u0000\u0000\u1071\u1072\u0005\u0125\u0000"+
"\u0000\u1072\u1074\u0003\u0250\u0128\u0000\u1073\u1075\u0003\u0244\u0122"+
"\u0000\u1074\u1073\u0001\u0000\u0000\u0000\u1074\u1075\u0001\u0000\u0000"+
"\u0000\u1075\u1084\u0001\u0000\u0000\u0000\u1076\u1077\u0005\u0224\u0000"+
"\u0000\u1077\u1078\u0005\u00f8\u0000\u0000\u1078\u107a\u0003\u02ca\u0165"+
"\u0000\u1079\u107b\u0003\u0244\u0122\u0000\u107a\u1079\u0001\u0000\u0000"+
"\u0000\u107a\u107b\u0001\u0000\u0000\u0000\u107b\u1084\u0001\u0000\u0000"+
"\u0000\u107c\u107d\u0005\u0224\u0000\u0000\u107d\u1081\u0005\u01b3\u0000"+
"\u0000\u107e\u1082\u0005\u00c8\u0000\u0000\u107f\u1080\u0005\u016d\u0000"+
"\u0000\u1080\u1082\u0003\u01c2\u00e1\u0000\u1081\u107e\u0001\u0000\u0000"+
"\u0000\u1081\u107f\u0001\u0000\u0000\u0000\u1082\u1084\u0001\u0000\u0000"+
"\u0000\u1083\u106d\u0001\u0000\u0000\u0000\u1083\u1070\u0001\u0000\u0000"+
"\u0000\u1083\u1076\u0001\u0000\u0000\u0000\u1083\u107c\u0001\u0000\u0000"+
"\u0000\u1084\u0143\u0001\u0000\u0000\u0000\u1085\u1086\u0005\u00fe\u0000"+
"\u0000\u1086\u1088\u0005\u01af\u0000\u0000\u1087\u1089\u0003\u02ca\u0165"+
"\u0000\u1088\u1087\u0001\u0000\u0000\u0000\u1088\u1089\u0001\u0000\u0000"+
"\u0000\u1089\u108a\u0001\u0000\u0000\u0000\u108a\u108b\u0007(\u0000\u0000"+
"\u108b\u109d\u0003\u02ca\u0165\u0000\u108c\u108d\u0005\u00fe\u0000\u0000"+
"\u108d\u108e\u0005\u00c8\u0000\u0000\u108e\u109d\u0005\u0215\u0000\u0000"+
"\u108f\u1090\u0005\u00fe\u0000\u0000\u1090\u1091\u0005\u021a\u0000\u0000"+
"\u1091\u1096\u0005\u0261\u0000\u0000\u1092\u1093\u0005\u016d\u0000\u0000"+
"\u1093\u1097\u0003\u02ca\u0165\u0000\u1094\u1095\u0007(\u0000\u0000\u1095"+
"\u1097\u0003\u0250\u0128\u0000\u1096\u1092\u0001\u0000\u0000\u0000\u1096"+
"\u1094\u0001\u0000\u0000\u0000\u1097\u109d\u0001\u0000\u0000\u0000\u1098"+
"\u1099\u0005\u00fe\u0000\u0000\u1099\u109a\u0005\u00c8\u0000\u0000\u109a"+
"\u109b\u0005\u021a\u0000\u0000\u109b\u109d\u0005\u0261\u0000\u0000\u109c"+
"\u1085\u0001\u0000\u0000\u0000\u109c\u108c\u0001\u0000\u0000\u0000\u109c"+
"\u108f\u0001\u0000\u0000\u0000\u109c\u1098\u0001\u0000\u0000\u0000\u109d"+
"\u0145\u0001\u0000\u0000\u0000\u109e\u109f\u0005\u0201\u0000\u0000\u109f"+
"\u10a1\u0005\u01a7\u0000\u0000\u10a0\u10a2\u0003\u0150\u00a8\u0000\u10a1"+
"\u10a0\u0001\u0000\u0000\u0000\u10a1\u10a2\u0001\u0000\u0000\u0000\u10a2"+
"\u10b7\u0001\u0000\u0000\u0000\u10a3\u10a4\u0005\u0144\u0000\u0000\u10a4"+
"\u10a7\u0005\u01a7\u0000\u0000\u10a5\u10a6\u0005\u018e\u0000\u0000\u10a6"+
"\u10a8\u0005\u015b\u0000\u0000\u10a7\u10a5\u0001\u0000\u0000\u0000\u10a7"+
"\u10a8\u0001\u0000\u0000\u0000\u10a8\u10aa\u0001\u0000\u0000\u0000\u10a9"+
"\u10ab\u0003\u0150\u00a8\u0000\u10aa\u10a9\u0001\u0000\u0000\u0000\u10aa"+
"\u10ab\u0001\u0000\u0000\u0000\u10ab\u10b7\u0001\u0000\u0000\u0000\u10ac"+
"\u10ad\u0005\u0235\u0000\u0000\u10ad\u10af\u0005\u01a7\u0000\u0000\u10ae"+
"\u10b0\u0003\u0150\u00a8\u0000\u10af\u10ae\u0001\u0000\u0000\u0000\u10af"+
"\u10b0\u0001\u0000\u0000\u0000\u10b0\u10b7\u0001\u0000\u0000\u0000\u10b1"+
"\u10b2\u0005\u00f5\u0000\u0000\u10b2\u10b4\u0005\u0274\u0000\u0000\u10b3"+
"\u10b5\u0003\u0150\u00a8\u0000\u10b4\u10b3\u0001\u0000\u0000\u0000\u10b4"+
"\u10b5\u0001\u0000\u0000\u0000\u10b5\u10b7\u0001\u0000\u0000\u0000\u10b6"+
"\u109e\u0001\u0000\u0000\u0000\u10b6\u10a3\u0001\u0000\u0000\u0000\u10b6"+
"\u10ac\u0001\u0000\u0000\u0000\u10b6\u10b1\u0001\u0000\u0000\u0000\u10b7"+
"\u0147\u0001\u0000\u0000\u0000\u10b8\u10b9\u0005\u00f5\u0000\u0000\u10b9"+
"\u10bc\u0005\u01bd\u0000\u0000\u10ba\u10bb\u0007(\u0000\u0000\u10bb\u10bd"+
"\u0003\u02ca\u0165\u0000\u10bc\u10ba\u0001\u0000\u0000\u0000\u10bc\u10bd"+
"\u0001\u0000\u0000\u0000\u10bd\u10bf\u0001\u0000\u0000\u0000\u10be\u10c0"+
"\u0003\u0150\u00a8\u0000\u10bf\u10be\u0001\u0000\u0000\u0000\u10bf\u10c0"+
"\u0001\u0000\u0000\u0000\u10c0\u1111\u0001\u0000\u0000\u0000\u10c1\u10c2"+
"\u0005\u00f5\u0000\u0000\u10c2\u10c5\u0005\u015e\u0000\u0000\u10c3\u10c4"+
"\u0007(\u0000\u0000\u10c4\u10c6\u0003\u02ca\u0165\u0000\u10c5\u10c3\u0001"+
"\u0000\u0000\u0000\u10c5\u10c6\u0001\u0000\u0000\u0000\u10c6\u10c8\u0001"+
"\u0000\u0000\u0000\u10c7\u10c9\u0003\u0150\u00a8\u0000\u10c8\u10c7\u0001"+
"\u0000\u0000\u0000\u10c8\u10c9\u0001\u0000\u0000\u0000\u10c9\u1111\u0001"+
"\u0000\u0000\u0000\u10ca\u10cb\u0005\u00f5\u0000\u0000\u10cb\u10cc\u0005"+
"\u00c9\u0000\u0000\u10cc\u10d1\u0005\u026e\u0000\u0000\u10cd\u10d2\u0005"+
"\u0240\u0000\u0000\u10ce\u10cf\u0005\u01d0\u0000\u0000\u10cf\u10d2\u0005"+
"\u02a2\u0000\u0000\u10d0\u10d2\u0005\u0105\u0000\u0000\u10d1\u10cd\u0001"+
"\u0000\u0000\u0000\u10d1\u10ce\u0001\u0000\u0000\u0000\u10d1\u10d0\u0001"+
"\u0000\u0000\u0000\u10d2\u10d3\u0001\u0000\u0000\u0000\u10d3\u10d4\u0005"+
"\u0172\u0000\u0000\u10d4\u10df\u0003\u0250\u0128\u0000\u10d5\u10d6\u0005"+
"\u00b6\u0000\u0000\u10d6\u10db\u0005\u02cf\u0000\u0000\u10d7\u10d8\u0005"+
"\u00b8\u0000\u0000\u10d8\u10da\u0005\u02cf\u0000\u0000\u10d9\u10d7\u0001"+
"\u0000\u0000\u0000\u10da\u10dd\u0001\u0000\u0000\u0000\u10db\u10d9\u0001"+
"\u0000\u0000\u0000\u10db\u10dc\u0001\u0000\u0000\u0000\u10dc\u10de\u0001"+
"\u0000\u0000\u0000\u10dd\u10db\u0001\u0000\u0000\u0000\u10de\u10e0\u0005"+
"\u00b7\u0000\u0000\u10df\u10d5\u0001\u0000\u0000\u0000\u10df\u10e0\u0001"+
"\u0000\u0000\u0000\u10e0\u1111\u0001\u0000\u0000\u0000\u10e1\u10e2\u0005"+
"\u00f5\u0000\u0000\u10e2\u10e3\u0005\u00ee\u0000\u0000\u10e3\u10e4\u0005"+
"\u0193\u0000\u0000\u10e4\u10e5\u0005\u01ed\u0000\u0000\u10e5\u10f0\u0003"+
"\u0250\u0128\u0000\u10e6\u10e7\u0005\u00b6\u0000\u0000\u10e7\u10ec\u0005"+
"\u02cf\u0000\u0000\u10e8\u10e9\u0005\u00b8\u0000\u0000\u10e9\u10eb\u0005"+
"\u02cf\u0000\u0000\u10ea\u10e8\u0001\u0000\u0000\u0000\u10eb\u10ee\u0001"+
"\u0000\u0000\u0000\u10ec\u10ea\u0001\u0000\u0000\u0000\u10ec\u10ed\u0001"+
"\u0000\u0000\u0000\u10ed\u10ef\u0001\u0000\u0000\u0000\u10ee\u10ec\u0001"+
"\u0000\u0000\u0000\u10ef\u10f1\u0005\u00b7\u0000\u0000\u10f0\u10e6\u0001"+
"\u0000\u0000\u0000\u10f0\u10f1\u0001\u0000\u0000\u0000\u10f1\u1111\u0001"+
"\u0000\u0000\u0000\u10f2\u10f3\u0005\u00f5\u0000\u0000\u10f3\u10f4\u0005"+
"\u0131\u0000\u0000\u10f4\u10f5\u0005\u00d8\u0000\u0000\u10f5\u10fa\u0005"+
"\u02ca\u0000\u0000\u10f6\u10f7\u0005\u00b8\u0000\u0000\u10f7\u10f9\u0005"+
"\u02ca\u0000\u0000\u10f8\u10f6\u0001\u0000\u0000\u0000\u10f9\u10fc\u0001"+
"\u0000\u0000\u0000\u10fa\u10f8\u0001\u0000\u0000\u0000\u10fa\u10fb\u0001"+
"\u0000\u0000\u0000\u10fb\u1111\u0001\u0000\u0000\u0000\u10fc\u10fa\u0001"+
"\u0000\u0000\u0000\u10fd\u10fe\u0005\u00f5\u0000\u0000\u10fe\u1101\u0005"+
"\u00da\u0000\u0000\u10ff\u1100\u0007(\u0000\u0000\u1100\u1102\u0003\u02ca"+
"\u0165\u0000\u1101\u10ff\u0001\u0000\u0000\u0000\u1101\u1102\u0001\u0000"+
"\u0000\u0000\u1102\u1111\u0001\u0000\u0000\u0000\u1103\u1104\u0005\u00f5"+
"\u0000\u0000\u1104\u1107\u0005\u0233\u0000\u0000\u1105\u1106\u0007(\u0000"+
"\u0000\u1106\u1108\u0003\u02ca\u0165\u0000\u1107\u1105\u0001\u0000\u0000"+
"\u0000\u1107\u1108\u0001\u0000\u0000\u0000\u1108\u1111\u0001\u0000\u0000"+
"\u0000\u1109\u110a\u0005\u00f5\u0000\u0000\u110a\u110b\u0005\u02a4\u0000"+
"\u0000\u110b\u110c\u0005\u0293\u0000\u0000\u110c\u110e\u0005\u01a7\u0000"+
"\u0000\u110d\u110f\u0003\u0150\u00a8\u0000\u110e\u110d\u0001\u0000\u0000"+
"\u0000\u110e\u110f\u0001\u0000\u0000\u0000\u110f\u1111\u0001\u0000\u0000"+
"\u0000\u1110\u10b8\u0001\u0000\u0000\u0000\u1110\u10c1\u0001\u0000\u0000"+
"\u0000\u1110\u10ca\u0001\u0000\u0000\u0000\u1110\u10e1\u0001\u0000\u0000"+
"\u0000\u1110\u10f2\u0001\u0000\u0000\u0000\u1110\u10fd\u0001\u0000\u0000"+
"\u0000\u1110\u1103\u0001\u0000\u0000\u0000\u1110\u1109\u0001\u0000\u0000"+
"\u0000\u1111\u0149\u0001\u0000\u0000\u0000\u1112\u1113\u0005\u0222\u0000"+
"\u0000\u1113\u1114\u0005\u0125\u0000\u0000\u1114\u1116\u0003\u02ca\u0165"+
"\u0000\u1115\u1117\u0005\u02cf\u0000\u0000\u1116\u1115\u0001\u0000\u0000"+
"\u0000\u1116\u1117\u0001\u0000\u0000\u0000\u1117\u111a\u0001\u0000\u0000"+
"\u0000\u1118\u1119\u0005\u00d1\u0000\u0000\u1119\u111b\u0003\u02ca\u0165"+
"\u0000\u111a\u1118\u0001\u0000\u0000\u0000\u111a\u111b\u0001\u0000\u0000"+
"\u0000\u111b\u1134\u0001\u0000\u0000\u0000\u111c\u111d\u0005\u0222\u0000"+
"\u0000\u111d\u111e\u0005\u026e\u0000\u0000\u111e\u1120\u0003\u0250\u0128"+
"\u0000\u111f\u1121\u0005\u02cf\u0000\u0000\u1120\u111f\u0001\u0000\u0000"+
"\u0000\u1120\u1121\u0001\u0000\u0000\u0000\u1121\u1124\u0001\u0000\u0000"+
"\u0000\u1122\u1123\u0005\u00d1\u0000\u0000\u1123\u1125\u0003\u02ca\u0165"+
"\u0000\u1124\u1122\u0001\u0000\u0000\u0000\u1124\u1125\u0001\u0000\u0000"+
"\u0000\u1125\u1134\u0001\u0000\u0000\u0000\u1126\u1127\u0005\u0222\u0000"+
"\u0000\u1127\u1128\u0005\u01f9\u0000\u0000\u1128\u112a\u0003\u02ca\u0165"+
"\u0000\u1129\u112b\u0005\u02cf\u0000\u0000\u112a\u1129\u0001\u0000\u0000"+
"\u0000\u112a\u112b\u0001\u0000\u0000\u0000\u112b\u112e\u0001\u0000\u0000"+
"\u0000\u112c\u112d\u0005\u00d1\u0000\u0000\u112d\u112f\u0003\u02ca\u0165"+
"\u0000\u112e\u112c\u0001\u0000\u0000\u0000\u112e\u112f\u0001\u0000\u0000"+
"\u0000\u112f\u1130\u0001\u0000\u0000\u0000\u1130\u1131\u0005\u0172\u0000"+
"\u0000\u1131\u1132\u0003\u0250\u0128\u0000\u1132\u1134\u0001\u0000\u0000"+
"\u0000\u1133\u1112\u0001\u0000\u0000\u0000\u1133\u111c\u0001\u0000\u0000"+
"\u0000\u1133\u1126\u0001\u0000\u0000\u0000\u1134\u014b\u0001\u0000\u0000"+
"\u0000\u1135\u1136\u0005\u00c3\u0000\u0000\u1136\u1137\u0005\u0254\u0000"+
"\u0000\u1137\u1138\u0005\u022e\u0000\u0000\u1138\u1139\u0005\u0262\u0000"+
"\u0000\u1139\u113a\u0005\u0172\u0000\u0000\u113a\u113c\u0003\u014e\u00a7"+
"\u0000\u113b\u113d\u0003\u0150\u00a8\u0000\u113c\u113b\u0001\u0000\u0000"+
"\u0000\u113c\u113d\u0001\u0000\u0000\u0000\u113d\u11c7\u0001\u0000\u0000"+
"\u0000\u113e\u113f\u0005\u00c3\u0000\u0000\u113f\u1140\u0005\u0254\u0000"+
"\u0000\u1140\u1141\u0005\u022e\u0000\u0000\u1141\u1142\u0005\u013f\u0000"+
"\u0000\u1142\u1143\u0005\u0172\u0000\u0000\u1143\u11c7\u0003\u014e\u00a7"+
"\u0000\u1144\u1145\u0005\u00c3\u0000\u0000\u1145\u1146\u0005\u0250\u0000"+
"\u0000\u1146\u1147\u0005\u022e\u0000\u0000\u1147\u1148\u0005\u0262\u0000"+
"\u0000\u1148\u1149\u0005\u0216\u0000\u0000\u1149\u114a\u0005\u00b6\u0000"+
"\u0000\u114a\u114b\u0003\u0246\u0123\u0000\u114b\u114c\u0005\u00b7\u0000"+
"\u0000\u114c\u11c7\u0001\u0000\u0000\u0000\u114d\u114e\u0005\u00c3\u0000"+
"\u0000\u114e\u114f\u0005\u0250\u0000\u0000\u114f\u1150\u0005\u022e\u0000"+
"\u0000\u1150\u1151\u0005\u02a1\u0000\u0000\u1151\u1152\u0005\u0216\u0000"+
"\u0000\u1152\u1153\u0005\u00b6\u0000\u0000\u1153\u1154\u0003\u0246\u0123"+
"\u0000\u1154\u1155\u0005\u00b7\u0000\u0000\u1155\u11c7\u0001\u0000\u0000"+
"\u0000\u1156\u1157\u0005\u00c3\u0000\u0000\u1157\u1158\u0005\u0229\u0000"+
"\u0000\u1158\u1159\u0005\u026e\u0000\u0000\u1159\u11c7\u0003\u014e\u00a7"+
"\u0000\u115a\u115b\u0005\u00c3\u0000\u0000\u115b\u115c\u0005\u00f5\u0000"+
"\u0000\u115c\u115d\u0005\u0229\u0000\u0000\u115d\u115e\u0005\u026e\u0000"+
"\u0000\u115e\u11c7\u0003\u014e\u00a7\u0000\u115f\u1160\u0005\u00c3\u0000"+
"\u0000\u1160\u1161\u0005\u010a\u0000\u0000\u1161\u1162\u0005\u026e\u0000"+
"\u0000\u1162\u1164\u0003\u014e\u00a7\u0000\u1163\u1165\u0003\u0150\u00a8"+
"\u0000\u1164\u1163\u0001\u0000\u0000\u0000\u1164\u1165\u0001\u0000\u0000"+
"\u0000\u1165\u11c7\u0001\u0000\u0000\u0000\u1166\u1167\u0005\u00c3\u0000"+
"\u0000\u1167\u116b\u0005\u0250\u0000\u0000\u1168\u116c\u0005\u0173\u0000"+
"\u0000\u1169\u116a\u0005\u00c8\u0000\u0000\u116a\u116c\u0005\u0174\u0000"+
"\u0000\u116b\u1168\u0001\u0000\u0000\u0000\u116b\u1169\u0001\u0000\u0000"+
"\u0000\u116c\u116d\u0001\u0000\u0000\u0000\u116d\u1172\u0005\u010f\u0000"+
"\u0000\u116e\u116f\u0005\u00b6\u0000\u0000\u116f\u1170\u0003\u0246\u0123"+
"\u0000\u1170\u1171\u0005\u00b7\u0000\u0000\u1171\u1173\u0001\u0000\u0000"+
"\u0000\u1172\u116e\u0001\u0000\u0000\u0000\u1172\u1173\u0001\u0000\u0000"+
"\u0000\u1173\u1175\u0001\u0000\u0000\u0000\u1174\u1176\u0005\u00c8\u0000"+
"\u0000\u1175\u1174\u0001\u0000\u0000\u0000\u1175\u1176\u0001\u0000\u0000"+
"\u0000\u1176\u11c7\u0001\u0000\u0000\u0000\u1177\u1178\u0005\u00c3\u0000"+
"\u0000\u1178\u1179\u0005\u00fd\u0000\u0000\u1179\u117b\u0003\u0274\u013a"+
"\u0000\u117a\u117c\u0003\u0244\u0122\u0000\u117b\u117a\u0001\u0000\u0000"+
"\u0000\u117b\u117c\u0001\u0000\u0000\u0000\u117c\u11c7\u0001\u0000\u0000"+
"\u0000\u117d\u117e\u0005\u00c3\u0000\u0000\u117e\u117f\u0005\u0220\u0000"+
"\u0000\u117f\u1187\u0005\u013a\u0000\u0000\u1180\u1181\u0005\u01ed\u0000"+
"\u0000\u1181\u1182\u0005\u00b6\u0000\u0000\u1182\u1183\u0005\u02ca\u0000"+
"\u0000\u1183\u1184\u0005\u00b8\u0000\u0000\u1184\u1185\u0005\u02ca\u0000"+
"\u0000\u1185\u1186\u0001\u0000\u0000\u0000\u1186\u1188\u0005\u00b7\u0000"+
"\u0000\u1187\u1180\u0001\u0000\u0000\u0000\u1187\u1188\u0001\u0000\u0000"+
"\u0000\u1188\u11c7\u0001\u0000\u0000\u0000\u1189\u118a\u0005\u00c3\u0000"+
"\u0000\u118a\u118b\u0005\u00f5\u0000\u0000\u118b\u118c\u0005\u0220\u0000"+
"\u0000\u118c\u1194\u0005\u013a\u0000\u0000\u118d\u118e\u0005\u01ed\u0000"+
"\u0000\u118e\u118f\u0005\u00b6\u0000\u0000\u118f\u1190\u0005\u02ca\u0000"+
"\u0000\u1190\u1191\u0005\u00b8\u0000\u0000\u1191\u1192\u0005\u02ca\u0000"+
"\u0000\u1192\u1193\u0001\u0000\u0000\u0000\u1193\u1195\u0005\u00b7\u0000"+
"\u0000\u1194\u118d\u0001\u0000\u0000\u0000\u1194\u1195\u0001\u0000\u0000"+
"\u0000\u1195\u11c7\u0001\u0000\u0000\u0000\u1196\u1197\u0005\u00c3\u0000"+
"\u0000\u1197\u1198\u0005\u00fe\u0000\u0000\u1198\u11a0\u0005\u0282\u0000"+
"\u0000\u1199\u119a\u0005\u01ed\u0000\u0000\u119a\u119b\u0005\u00b6\u0000"+
"\u0000\u119b\u119c\u0005\u02ca\u0000\u0000\u119c\u119d\u0005\u00b8\u0000"+
"\u0000\u119d\u119e\u0005\u02ca\u0000\u0000\u119e\u119f\u0001\u0000\u0000"+
"\u0000\u119f\u11a1\u0005\u00b7\u0000\u0000\u11a0\u1199\u0001\u0000\u0000"+
"\u0000\u11a0\u11a1\u0001\u0000\u0000\u0000\u11a1\u11c7\u0001\u0000\u0000"+
"\u0000\u11a2\u11a3\u0005\u00c3\u0000\u0000\u11a3\u11a4\u0005\u0250\u0000"+
"\u0000\u11a4\u11a5\u0005\u026e\u0000\u0000\u11a5\u11a6\u0003\u0250\u0128"+
"\u0000\u11a6\u11a7\u0005\u01f9\u0000\u0000\u11a7\u11a9\u0005\u02a1\u0000"+
"\u0000\u11a8\u11aa\u0003\u0244\u0122\u0000\u11a9\u11a8\u0001\u0000\u0000"+
"\u0000\u11a9\u11aa\u0001\u0000\u0000\u0000\u11aa\u11c7\u0001\u0000\u0000"+
"\u0000\u11ab\u11ac\u0005\u00c3\u0000\u0000\u11ac\u11ad\u0005\u0138\u0000"+
"\u0000\u11ad\u11ae\u0005\u0271\u0000\u0000\u11ae\u11c7\u0005\u02cf\u0000"+
"\u0000\u11af\u11b0\u0005\u00c3\u0000\u0000\u11b0\u11b1\u0005\u0254\u0000"+
"\u0000\u11b1\u11b2\u0005\u0271\u0000\u0000\u11b2\u11b3\u0005\u0264\u0000"+
"\u0000\u11b3\u11b5\u0005\u0170\u0000\u0000\u11b4\u11b6\u0005\u02a0\u0000"+
"\u0000\u11b5\u11b4\u0001\u0000\u0000\u0000\u11b5\u11b6\u0001\u0000\u0000"+
"\u0000\u11b6\u11c7\u0001\u0000\u0000\u0000\u11b7\u11b8\u0005\u00c3\u0000"+
"\u0000\u11b8\u11b9\u0005\u0117\u0000\u0000\u11b9\u11ba\u0005\u0271\u0000"+
"\u0000\u11ba\u11bc\u0005\u02cf\u0000\u0000\u11bb\u11bd\u0003\u0244\u0122"+
"\u0000\u11bc\u11bb\u0001\u0000\u0000\u0000\u11bc\u11bd\u0001\u0000\u0000"+
"\u0000\u11bd\u11c7\u0001\u0000\u0000\u0000\u11be\u11bf\u0005\u00c3\u0000"+
"\u0000\u11bf\u11c0\u0005\u0250\u0000\u0000\u11c0\u11c1\u0005\u026e\u0000"+
"\u0000\u11c1\u11c2\u0003\u0250\u0128\u0000\u11c2\u11c4\u0005\u0262\u0000"+
"\u0000\u11c3\u11c5\u0003\u0244\u0122\u0000\u11c4\u11c3\u0001\u0000\u0000"+
"\u0000\u11c4\u11c5\u0001\u0000\u0000\u0000\u11c5\u11c7\u0001\u0000\u0000"+
"\u0000\u11c6\u1135\u0001\u0000\u0000\u0000\u11c6\u113e\u0001\u0000\u0000"+
"\u0000\u11c6\u1144\u0001\u0000\u0000\u0000\u11c6\u114d\u0001\u0000\u0000"+
"\u0000\u11c6\u1156\u0001\u0000\u0000\u0000\u11c6\u115a\u0001\u0000\u0000"+
"\u0000\u11c6\u115f\u0001\u0000\u0000\u0000\u11c6\u1166\u0001\u0000\u0000"+
"\u0000\u11c6\u1177\u0001\u0000\u0000\u0000\u11c6\u117d\u0001\u0000\u0000"+
"\u0000\u11c6\u1189\u0001\u0000\u0000\u0000\u11c6\u1196\u0001\u0000\u0000"+
"\u0000\u11c6\u11a2\u0001\u0000\u0000\u0000\u11c6\u11ab\u0001\u0000\u0000"+
"\u0000\u11c6\u11af\u0001\u0000\u0000\u0000\u11c6\u11b7\u0001\u0000\u0000"+
"\u0000\u11c6\u11be\u0001\u0000\u0000\u0000\u11c7\u014d\u0001\u0000\u0000"+
"\u0000\u11c8\u11ca\u0003\u0250\u0128\u0000\u11c9\u11cb\u0003\u023e\u011f"+
"\u0000\u11ca\u11c9\u0001\u0000\u0000\u0000\u11ca\u11cb\u0001\u0000\u0000"+
"\u0000\u11cb\u11cd\u0001\u0000\u0000\u0000\u11cc\u11ce\u0003\u02c4\u0162"+
"\u0000\u11cd\u11cc\u0001\u0000\u0000\u0000\u11cd\u11ce\u0001\u0000\u0000"+
"\u0000\u11ce\u11d0\u0001\u0000\u0000\u0000\u11cf\u11d1\u0003\u029e\u014f"+
"\u0000\u11d0\u11cf\u0001\u0000\u0000\u0000\u11d0\u11d1\u0001\u0000\u0000"+
"\u0000\u11d1\u11d3\u0001\u0000\u0000\u0000\u11d2\u11d4\u0003\u0274\u013a"+
"\u0000\u11d3\u11d2\u0001\u0000\u0000\u0000\u11d3\u11d4\u0001\u0000\u0000"+
"\u0000\u11d4\u11d5\u0001\u0000\u0000\u0000\u11d5\u11d7\u0003\u024e\u0127"+
"\u0000\u11d6\u11d8\u0003\u02c0\u0160\u0000\u11d7\u11d6\u0001\u0000\u0000"+
"\u0000\u11d7\u11d8\u0001\u0000\u0000\u0000\u11d8\u11da\u0001\u0000\u0000"+
"\u0000\u11d9\u11db\u0003\u0216\u010b\u0000\u11da\u11d9\u0001\u0000\u0000"+
"\u0000\u11da\u11db\u0001\u0000\u0000\u0000\u11db\u014f\u0001\u0000\u0000"+
"\u0000\u11dc\u11dd\u0005\u01b8\u0000\u0000\u11dd\u11e1\u0005\u02ca\u0000"+
"\u0000\u11de\u11df\u0005\u02a8\u0000\u0000\u11df\u11e1\u0003\u027c\u013e"+
"\u0000\u11e0\u11dc\u0001\u0000\u0000\u0000\u11e0\u11de\u0001\u0000\u0000"+
"\u0000\u11e1\u0151\u0001\u0000\u0000\u0000\u11e2\u11e8\u0005\u00db\u0000"+
"\u0000\u11e3\u11e4\u0005\u02aa\u0000\u0000\u11e4\u11e6\u0005\u01af\u0000"+
"\u0000\u11e5\u11e7\u0003\u02ca\u0165\u0000\u11e6\u11e5\u0001\u0000\u0000"+
"\u0000\u11e6\u11e7\u0001\u0000\u0000\u0000\u11e7\u11e9\u0001\u0000\u0000"+
"\u0000\u11e8\u11e3\u0001\u0000\u0000\u0000\u11e8\u11e9\u0001\u0000\u0000"+
"\u0000\u11e9\u120d\u0001\u0000\u0000\u0000\u11ea\u11ec\u0005\u0108\u0000"+
"\u0000\u11eb\u11ed\u0005\u02ab\u0000\u0000\u11ec\u11eb\u0001\u0000\u0000"+
"\u0000\u11ec\u11ed\u0001\u0000\u0000\u0000\u11ed\u11f3\u0001\u0000\u0000"+
"\u0000\u11ee\u11f0\u0005\u00cd\u0000\u0000\u11ef\u11f1\u0005\u01e5\u0000"+
"\u0000\u11f0\u11ef\u0001\u0000\u0000\u0000\u11f0\u11f1\u0001\u0000\u0000"+
"\u0000\u11f1\u11f2\u0001\u0000\u0000\u0000\u11f2\u11f4\u0005\u00fa\u0000"+
"\u0000\u11f3\u11ee\u0001\u0000\u0000\u0000\u11f3\u11f4\u0001\u0000\u0000"+
"\u0000\u11f4\u11f9\u0001\u0000\u0000\u0000\u11f5\u11f7\u0005\u01e5\u0000"+
"\u0000\u11f6\u11f5\u0001\u0000\u0000\u0000\u11f6\u11f7\u0001\u0000\u0000"+
"\u0000\u11f7\u11f8\u0001\u0000\u0000\u0000\u11f8\u11fa\u0005\u0227\u0000"+
"\u0000\u11f9\u11f6\u0001\u0000\u0000\u0000\u11f9\u11fa\u0001\u0000\u0000"+
"\u0000\u11fa\u120d\u0001\u0000\u0000\u0000\u11fb\u11fd\u0005\u023f\u0000"+
"\u0000\u11fc\u11fe\u0005\u02ab\u0000\u0000\u11fd\u11fc\u0001\u0000\u0000"+
"\u0000\u11fd\u11fe\u0001\u0000\u0000\u0000\u11fe\u1204\u0001\u0000\u0000"+
"\u0000\u11ff\u1201\u0005\u00cd\u0000\u0000\u1200\u1202\u0005\u01e5\u0000"+
"\u0000\u1201\u1200\u0001\u0000\u0000\u0000\u1201\u1202\u0001\u0000\u0000"+
"\u0000\u1202\u1203\u0001\u0000\u0000\u0000\u1203\u1205\u0005\u00fa\u0000"+
"\u0000\u1204\u11ff\u0001\u0000\u0000\u0000\u1204\u1205\u0001\u0000\u0000"+
"\u0000\u1205\u120a\u0001\u0000\u0000\u0000\u1206\u1208\u0005\u01e5\u0000"+
"\u0000\u1207\u1206\u0001\u0000\u0000\u0000\u1207\u1208\u0001\u0000\u0000"+
"\u0000\u1208\u1209\u0001\u0000\u0000\u0000\u1209\u120b\u0005\u0227\u0000"+
"\u0000\u120a\u1207\u0001\u0000\u0000\u0000\u120a\u120b\u0001\u0000\u0000"+
"\u0000\u120b\u120d\u0001\u0000\u0000\u0000\u120c\u11e2\u0001\u0000\u0000"+
"\u0000\u120c\u11ea\u0001\u0000\u0000\u0000\u120c\u11fb\u0001\u0000\u0000"+
"\u0000\u120d\u0153\u0001\u0000\u0000\u0000\u120e\u120f\u0005\u017b\u0000"+
"\u0000\u120f\u1210\u0003\u0158\u00ac\u0000\u1210\u1211\u0005\u01ed\u0000"+
"\u0000\u1211\u1212\u0003\u01c6\u00e3\u0000\u1212\u1216\u0005\u027e\u0000"+
"\u0000\u1213\u1217\u0003\u01ca\u00e5\u0000\u1214\u1215\u0005\u023d\u0000"+
"\u0000\u1215\u1217\u0005\u02ca\u0000\u0000\u1216\u1213\u0001\u0000\u0000"+
"\u0000\u1216\u1214\u0001\u0000\u0000\u0000\u1217\u1263\u0001\u0000\u0000"+
"\u0000\u1218\u1219\u0005\u017b\u0000\u0000\u1219\u121a\u0003\u0158\u00ac"+
"\u0000\u121a\u1224\u0005\u01ed\u0000\u0000\u121b\u1225\u0005\u0231\u0000"+
"\u0000\u121c\u1225\u0005\u00ff\u0000\u0000\u121d\u121e\u0005\u010d\u0000"+
"\u0000\u121e\u1225\u0005\u017e\u0000\u0000\u121f\u1225\u0005\u025d\u0000"+
"\u0000\u1220\u1221\u0005\u0264\u0000\u0000\u1221\u1225\u0005\u029e\u0000"+
"\u0000\u1222\u1223\u0005\u02ac\u0000\u0000\u1223\u1225\u0005\u017e\u0000"+
"\u0000\u1224\u121b\u0001\u0000\u0000\u0000\u1224\u121c\u0001\u0000\u0000"+
"\u0000\u1224\u121d\u0001\u0000\u0000\u0000\u1224\u121f\u0001\u0000\u0000"+
"\u0000\u1224\u1220\u0001\u0000\u0000\u0000\u1224\u1222\u0001\u0000\u0000"+
"\u0000\u1225\u1226\u0001\u0000\u0000\u0000\u1226\u1227\u0003\u01c4\u00e2"+
"\u0000\u1227\u122b\u0005\u027e\u0000\u0000\u1228\u122c\u0003\u01ca\u00e5"+
"\u0000\u1229\u122a\u0005\u023d\u0000\u0000\u122a\u122c\u0005\u02ca\u0000"+
"\u0000\u122b\u1228\u0001\u0000\u0000\u0000\u122b\u1229\u0001\u0000\u0000"+
"\u0000\u122c\u1263\u0001\u0000\u0000\u0000\u122d\u122e\u0005\u017b\u0000"+
"\u0000\u122e\u1233\u0005\u02ca\u0000\u0000\u122f\u1230\u0005\u00b8\u0000"+
"\u0000\u1230\u1232\u0005\u02ca\u0000\u0000\u1231\u122f\u0001\u0000\u0000"+
"\u0000\u1232\u1235\u0001\u0000\u0000\u0000\u1233\u1231\u0001\u0000\u0000"+
"\u0000\u1233\u1234\u0001\u0000\u0000\u0000\u1234\u1236\u0001\u0000\u0000"+
"\u0000\u1235\u1233\u0001\u0000\u0000\u0000\u1236\u1237\u0005\u027e\u0000"+
"\u0000\u1237\u1263\u0003\u01ca\u00e5\u0000\u1238\u1239\u0005\u0239\u0000"+
"\u0000\u1239\u123a\u0003\u0158\u00ac\u0000\u123a\u123b\u0005\u01ed\u0000"+
"\u0000\u123b\u123c\u0003\u01c6\u00e3\u0000\u123c\u1240\u0005\u0172\u0000"+
"\u0000\u123d\u1241\u0003\u01ca\u00e5\u0000\u123e\u123f\u0005\u023d\u0000"+
"\u0000\u123f\u1241\u0005\u02ca\u0000\u0000\u1240\u123d\u0001\u0000\u0000"+
"\u0000\u1240\u123e\u0001\u0000\u0000\u0000\u1241\u1263\u0001\u0000\u0000"+
"\u0000\u1242\u1243\u0005\u0239\u0000\u0000\u1243\u1244\u0003\u0158\u00ac"+
"\u0000\u1244\u124e\u0005\u01ed\u0000\u0000\u1245\u124f\u0005\u0231\u0000"+
"\u0000\u1246\u124f\u0005\u00ff\u0000\u0000\u1247\u1248\u0005\u010d\u0000"+
"\u0000\u1248\u124f\u0005\u017e\u0000\u0000\u1249\u124f\u0005\u025d\u0000"+
"\u0000\u124a\u124b\u0005\u0264\u0000\u0000\u124b\u124f\u0005\u029e\u0000"+
"\u0000\u124c\u124d\u0005\u02ac\u0000\u0000\u124d\u124f\u0005\u017e\u0000"+
"\u0000\u124e\u1245\u0001\u0000\u0000\u0000\u124e\u1246\u0001\u0000\u0000"+
"\u0000\u124e\u1247\u0001\u0000\u0000\u0000\u124e\u1249\u0001\u0000\u0000"+
"\u0000\u124e\u124a\u0001\u0000\u0000\u0000\u124e\u124c\u0001\u0000\u0000"+
"\u0000\u124f\u1250\u0001\u0000\u0000\u0000\u1250\u1251\u0003\u01c4\u00e2"+
"\u0000\u1251\u1255\u0005\u0172\u0000\u0000\u1252\u1256\u0003\u01ca\u00e5"+
"\u0000\u1253\u1254\u0005\u023d\u0000\u0000\u1254\u1256\u0005\u02ca\u0000"+
"\u0000\u1255\u1252\u0001\u0000\u0000\u0000\u1255\u1253\u0001\u0000\u0000"+
"\u0000\u1256\u1263\u0001\u0000\u0000\u0000\u1257\u1258\u0005\u0239\u0000"+
"\u0000\u1258\u125d\u0005\u02ca\u0000\u0000\u1259\u125a\u0005\u00b8\u0000"+
"\u0000\u125a\u125c\u0005\u02ca\u0000\u0000\u125b\u1259\u0001\u0000\u0000"+
"\u0000\u125c\u125f\u0001\u0000\u0000\u0000\u125d\u125b\u0001\u0000\u0000"+
"\u0000\u125d\u125e\u0001\u0000\u0000\u0000\u125e\u1260\u0001\u0000\u0000"+
"\u0000\u125f\u125d\u0001\u0000\u0000\u0000\u1260\u1261\u0005\u0172\u0000"+
"\u0000\u1261\u1263\u0003\u01ca\u00e5\u0000\u1262\u120e\u0001\u0000\u0000"+
"\u0000\u1262\u1218\u0001\u0000\u0000\u0000\u1262\u122d\u0001\u0000\u0000"+
"\u0000\u1262\u1238\u0001\u0000\u0000\u0000\u1262\u1242\u0001\u0000\u0000"+
"\u0000\u1262\u1257\u0001\u0000\u0000\u0000\u1263\u0155\u0001\u0000\u0000"+
"\u0000\u1264\u1266\u0003\u02ca\u0165\u0000\u1265\u1267\u0003\u023a\u011d"+
"\u0000\u1266\u1265\u0001\u0000\u0000\u0000\u1266\u1267\u0001\u0000\u0000"+
"\u0000\u1267\u126a\u0001\u0000\u0000\u0000\u1268\u126a\u0005\u00c8\u0000"+
"\u0000\u1269\u1264\u0001\u0000\u0000\u0000\u1269\u1268\u0001\u0000\u0000"+
"\u0000\u126a\u0157\u0001\u0000\u0000\u0000\u126b\u1270\u0003\u0156\u00ab"+
"\u0000\u126c\u126d\u0005\u00b8\u0000\u0000\u126d\u126f\u0003\u0156\u00ab"+
"\u0000\u126e\u126c\u0001\u0000\u0000\u0000\u126f\u1272\u0001\u0000\u0000"+
"\u0000\u1270\u126e\u0001\u0000\u0000\u0000\u1270\u1271\u0001\u0000\u0000"+
"\u0000\u1271\u0159\u0001\u0000\u0000\u0000\u1272\u1270\u0001\u0000\u0000"+
"\u0000\u1273\u1274\u0005\u00c9\u0000\u0000\u1274\u1275\u0005\u026e\u0000"+
"\u0000\u1275\u1276\u0003\u0250\u0128\u0000\u1276\u127b\u0003\u0162\u00b1"+
"\u0000\u1277\u1278\u0005\u00b8\u0000\u0000\u1278\u127a\u0003\u0162\u00b1"+
"\u0000\u1279\u1277\u0001\u0000\u0000\u0000\u127a\u127d\u0001\u0000\u0000"+
"\u0000\u127b\u1279\u0001\u0000\u0000\u0000\u127b\u127c\u0001\u0000\u0000"+
"\u0000\u127c\u1323\u0001\u0000\u0000\u0000\u127d\u127b\u0001\u0000\u0000"+
"\u0000\u127e\u127f\u0005\u00c9\u0000\u0000\u127f\u1280\u0005\u026e\u0000"+
"\u0000\u1280\u1281\u0003\u0250\u0128\u0000\u1281\u1282\u0005\u00c2\u0000"+
"\u0000\u1282\u1283\u0005\u0240\u0000\u0000\u1283\u1288\u0003\u0160\u00b0"+
"\u0000\u1284\u1285\u0005\u00b8\u0000\u0000\u1285\u1287\u0003\u0160\u00b0"+
"\u0000\u1286\u1284\u0001\u0000\u0000\u0000\u1287\u128a\u0001\u0000\u0000"+
"\u0000\u1288\u1286\u0001\u0000\u0000\u0000\u1288\u1289\u0001\u0000\u0000"+
"\u0000\u1289\u1323\u0001\u0000\u0000\u0000\u128a\u1288\u0001\u0000\u0000"+
"\u0000\u128b\u128c\u0005\u00c9\u0000\u0000\u128c\u128d\u0005\u026e\u0000"+
"\u0000\u128d\u128e\u0003\u0250\u0128\u0000\u128e\u128f\u0005\u0144\u0000"+
"\u0000\u128f\u1290\u0005\u0240\u0000\u0000\u1290\u1295\u0003\u015e\u00af"+
"\u0000\u1291\u1292\u0005\u00b8\u0000\u0000\u1292\u1294\u0003\u015e\u00af"+
"\u0000\u1293\u1291\u0001\u0000\u0000\u0000\u1294\u1297\u0001\u0000\u0000"+
"\u0000\u1295\u1293\u0001\u0000\u0000\u0000\u1295\u1296\u0001\u0000\u0000"+
"\u0000\u1296\u1323\u0001\u0000\u0000\u0000\u1297\u1295\u0001\u0000\u0000"+
"\u0000\u1298\u1299\u0005\u00c9\u0000\u0000\u1299\u129a\u0005\u026d\u0000"+
"\u0000\u129a\u1323\u0003\u015c\u00ae\u0000\u129b\u129c\u0005\u00c9\u0000"+
"\u0000\u129c\u129d\u0005\u0125\u0000\u0000\u129d\u129e\u0003\u02ca\u0165"+
"\u0000\u129e\u129f\u0005\u0250\u0000\u0000\u129f\u12a0\u00072\u0000\u0000"+
"\u12a0\u12a1\u0005\u021b\u0000\u0000\u12a1\u12a3\u0005\u02cf\u0000\u0000"+
"\u12a2\u12a4\u0003\u02ca\u0165\u0000\u12a3\u12a2\u0001\u0000\u0000\u0000"+
"\u12a3\u12a4\u0001\u0000\u0000\u0000\u12a4\u1323\u0001\u0000\u0000\u0000"+
"\u12a5\u12a6\u0005\u00c9\u0000\u0000\u12a6\u12a7\u0005\u0125\u0000\u0000"+
"\u12a7\u12a8\u0003\u02ca\u0165\u0000\u12a8\u12a9\u0005\u0228\u0000\u0000"+
"\u12a9\u12aa\u0003\u02ca\u0165\u0000\u12aa\u1323\u0001\u0000\u0000\u0000"+
"\u12ab\u12ac\u0005\u00c9\u0000\u0000\u12ac\u12ad\u0005\u0125\u0000\u0000"+
"\u12ad\u12ae\u0003\u02ca\u0165\u0000\u12ae\u12af\u0005\u0250\u0000\u0000"+
"\u12af\u12b0\u0005\u0216\u0000\u0000\u12b0\u12b1\u0005\u00b6\u0000\u0000"+
"\u12b1\u12b2\u0003\u0246\u0123\u0000\u12b2\u12b3\u0005\u00b7\u0000\u0000"+
"\u12b3\u1323\u0001\u0000\u0000\u0000\u12b4\u12b5\u0005\u00c9\u0000\u0000"+
"\u12b5\u12b6\u0005\u00f8\u0000\u0000\u12b6\u12b7\u0003\u02ca\u0165\u0000"+
"\u12b7\u12b8\u0005\u0228\u0000\u0000\u12b8\u12b9\u0003\u02ca\u0165\u0000"+
"\u12b9\u1323\u0001\u0000\u0000\u0000\u12ba\u12bb\u0005\u00c9\u0000\u0000"+
"\u12bb\u12bc\u0005\u00f8\u0000\u0000\u12bc\u12bd\u0003\u02ca\u0165\u0000"+
"\u12bd\u12be\u0005\u0250\u0000\u0000\u12be\u12bf\u0005\u0216\u0000\u0000"+
"\u12bf\u12c0\u0005\u00b6\u0000\u0000\u12c0\u12c1\u0003\u0246\u0123\u0000"+
"\u12c1\u12c2\u0005\u00b7\u0000\u0000\u12c2\u1323\u0001\u0000\u0000\u0000"+
"\u12c3\u12c4\u0005\u00c9\u0000\u0000\u12c4\u12c5\u0005\u00f8\u0000\u0000"+
"\u12c5\u12c6\u0003\u02ca\u0165\u0000\u12c6\u12c7\u0005\u01db\u0000\u0000"+
"\u12c7\u12c8\u0005\u0107\u0000\u0000\u12c8\u12c9\u0005\u02ca\u0000\u0000"+
"\u12c9\u1323\u0001\u0000\u0000\u0000\u12ca\u12cb\u0005\u00c9\u0000\u0000"+
"\u12cb\u12cc\u0005\u0231\u0000\u0000\u12cc\u12ce\u0003\u01c2\u00e1\u0000"+
"\u12cd\u12cf\u0003\u0244\u0122\u0000\u12ce\u12cd\u0001\u0000\u0000\u0000"+
"\u12ce\u12cf\u0001\u0000\u0000\u0000\u12cf\u1323\u0001\u0000\u0000\u0000"+
"\u12d0\u12d1\u0005\u00c9\u0000\u0000\u12d1\u12d2\u0005\u0104\u0000\u0000"+
"\u12d2\u12d3\u0005\u017e\u0000\u0000\u12d3\u12d4\u0003\u0250\u0128\u0000"+
"\u12d4\u12d5\u0005\u0250\u0000\u0000\u12d5\u12d6\u0005\u00b6\u0000\u0000"+
"\u12d6\u12d7\u0003\u0246\u0123\u0000\u12d7\u12d8\u0005\u00b7\u0000\u0000"+
"\u12d8\u1323\u0001\u0000\u0000\u0000\u12d9\u12da\u0005\u00c9\u0000\u0000"+
"\u12da\u12db\u0005\u02ac\u0000\u0000\u12db\u12dc\u0005\u017e\u0000\u0000"+
"\u12dc\u12de\u0003\u01c2\u00e1\u0000\u12dd\u12df\u0003\u0244\u0122\u0000"+
"\u12de\u12dd\u0001\u0000\u0000\u0000\u12de\u12df\u0001\u0000\u0000\u0000"+
"\u12df\u1323\u0001\u0000\u0000\u0000\u12e0\u12e1\u0005\u00c9\u0000\u0000"+
"\u12e1\u12e2\u0005\u02ac\u0000\u0000\u12e2\u12e3\u0005\u020e\u0000\u0000"+
"\u12e3\u12e5\u0003\u01c2\u00e1\u0000\u12e4\u12e6\u0003\u0244\u0122\u0000"+
"\u12e5\u12e4\u0001\u0000\u0000\u0000\u12e5\u12e6\u0001\u0000\u0000\u0000"+
"\u12e6\u1323\u0001\u0000\u0000\u0000\u12e7\u12e8\u0005\u00c9\u0000\u0000"+
"\u12e8\u12e9\u0005\u0241\u0000\u0000\u12e9\u12ea\u0005\u01bd\u0000\u0000"+
"\u12ea\u12eb\u0005\u016d\u0000\u0000\u12eb\u12ed\u0003\u0250\u0128\u0000"+
"\u12ec\u12ee\u0003\u0244\u0122\u0000\u12ed\u12ec\u0001\u0000\u0000\u0000"+
"\u12ed\u12ee\u0001\u0000\u0000\u0000\u12ee\u12f5\u0001\u0000\u0000\u0000"+
"\u12ef\u12f0\u0005\u0172\u0000\u0000\u12f0\u12f1\u0003\u02ca\u0165\u0000"+
"\u12f1\u12f2\u0005\u00b6\u0000\u0000\u12f2\u12f3\u0003\u0246\u0123\u0000"+
"\u12f3\u12f4\u0005\u00b7\u0000\u0000\u12f4\u12f6\u0001\u0000\u0000\u0000"+
"\u12f5\u12ef\u0001\u0000\u0000\u0000\u12f5\u12f6\u0001\u0000\u0000\u0000"+
"\u12f6\u1323\u0001\u0000\u0000\u0000\u12f7\u12f8\u0005\u00c9\u0000\u0000"+
"\u12f8\u12f9\u0005\u025c\u0000\u0000\u12f9\u12fb\u0003\u02ca\u0165\u0000"+
"\u12fa\u12fc\u0003\u0244\u0122\u0000\u12fb\u12fa\u0001\u0000\u0000\u0000"+
"\u12fb\u12fc\u0001\u0000\u0000\u0000\u12fc\u1323\u0001\u0000\u0000\u0000"+
"\u12fd\u12fe\u0005\u00c9\u0000\u0000\u12fe\u12ff\u0005\u026e\u0000\u0000"+
"\u12ff\u1300\u0003\u0250\u0128\u0000\u1300\u1301\u0005\u0250\u0000\u0000"+
"\u1301\u1302\u0005\u00b6\u0000\u0000\u1302\u1303\u0003\u0246\u0123\u0000"+
"\u1303\u1304\u0005\u00b7\u0000\u0000\u1304\u1323\u0001\u0000\u0000\u0000"+
"\u1305\u1306\u0005\u00c9\u0000\u0000\u1306\u1307\u0005\u0264\u0000\u0000"+
"\u1307\u1308\u0005\u020e\u0000\u0000\u1308\u1309\u0003\u01c2\u00e1\u0000"+
"\u1309\u130a\u0003\u0244\u0122\u0000\u130a\u1323\u0001\u0000\u0000\u0000"+
"\u130b\u130c\u0005\u00c9\u0000\u0000\u130c\u130f\u0005\u0296\u0000\u0000"+
"\u130d\u130e\u0005\u018e\u0000\u0000\u130e\u1310\u0005\u015b\u0000\u0000"+
"\u130f\u130d\u0001\u0000\u0000\u0000\u130f\u1310\u0001\u0000\u0000\u0000"+
"\u1310\u1311\u0001\u0000\u0000\u0000\u1311\u1312\u0003\u01cc\u00e6\u0000"+
"\u1312\u1315\u0003\u0190\u00c8\u0000\u1313\u1314\u0005\u0107\u0000\u0000"+
"\u1314\u1316\u0005\u02ca\u0000\u0000\u1315\u1313\u0001\u0000\u0000\u0000"+
"\u1315\u1316\u0001\u0000\u0000\u0000\u1316\u1323\u0001\u0000\u0000\u0000"+
"\u1317\u1318\u0005\u00c9\u0000\u0000\u1318\u1319\u0005\u023d\u0000\u0000"+
"\u1319\u131a\u0003\u02ca\u0165\u0000\u131a\u131b\u0003\u02be\u015f\u0000"+
"\u131b\u1323\u0001\u0000\u0000\u0000\u131c\u131d\u0005\u00c9\u0000\u0000"+
"\u131d\u131e\u0005\u0230\u0000\u0000\u131e\u1320\u0003\u02ca\u0165\u0000"+
"\u131f\u1321\u0003\u0244\u0122\u0000\u1320\u131f\u0001\u0000\u0000\u0000"+
"\u1320\u1321\u0001\u0000\u0000\u0000\u1321\u1323\u0001\u0000\u0000\u0000"+
"\u1322\u1273\u0001\u0000\u0000\u0000\u1322\u127e\u0001\u0000\u0000\u0000"+
"\u1322\u128b\u0001\u0000\u0000\u0000\u1322\u1298\u0001\u0000\u0000\u0000"+
"\u1322\u129b\u0001\u0000\u0000\u0000\u1322\u12a5\u0001\u0000\u0000\u0000"+
"\u1322\u12ab\u0001\u0000\u0000\u0000\u1322\u12b4\u0001\u0000\u0000\u0000"+
"\u1322\u12ba\u0001\u0000\u0000\u0000\u1322\u12c3\u0001\u0000\u0000\u0000"+
"\u1322\u12ca\u0001\u0000\u0000\u0000\u1322\u12d0\u0001\u0000\u0000\u0000"+
"\u1322\u12d9\u0001\u0000\u0000\u0000\u1322\u12e0\u0001\u0000\u0000\u0000"+
"\u1322\u12e7\u0001\u0000\u0000\u0000\u1322\u12f7\u0001\u0000\u0000\u0000"+
"\u1322\u12fd\u0001\u0000\u0000\u0000\u1322\u1305\u0001\u0000\u0000\u0000"+
"\u1322\u130b\u0001\u0000\u0000\u0000\u1322\u1317\u0001\u0000\u0000\u0000"+
"\u1322\u131c\u0001\u0000\u0000\u0000\u1323\u015b\u0001\u0000\u0000\u0000"+
"\u1324\u1325\u0005\u00c2\u0000\u0000\u1325\u1326\u0005\u00d8\u0000\u0000"+
"\u1326\u132b\u0005\u02ca\u0000\u0000\u1327\u1328\u0005\u00b8\u0000\u0000"+
"\u1328\u132a\u0005\u02ca\u0000\u0000\u1329\u1327\u0001\u0000\u0000\u0000"+
"\u132a\u132d\u0001\u0000\u0000\u0000\u132b\u1329\u0001\u0000\u0000\u0000"+
"\u132b\u132c\u0001\u0000\u0000\u0000\u132c\u132f\u0001\u0000\u0000\u0000"+
"\u132d\u132b\u0001\u0000\u0000\u0000\u132e\u1330\u0003\u0244\u0122\u0000"+
"\u132f\u132e\u0001\u0000\u0000\u0000\u132f\u1330\u0001\u0000\u0000\u0000"+
"\u1330\u1387\u0001\u0000\u0000\u0000\u1331\u1332\u00073\u0000\u0000\u1332"+
"\u1333\u0005\u00d8\u0000\u0000\u1333\u1338\u0005\u02ca\u0000\u0000\u1334"+
"\u1335\u0005\u00b8\u0000\u0000\u1335\u1337\u0005\u02ca\u0000\u0000\u1336"+
"\u1334\u0001\u0000\u0000\u0000\u1337\u133a\u0001\u0000\u0000\u0000\u1338"+
"\u1336\u0001\u0000\u0000\u0000\u1338\u1339\u0001\u0000\u0000\u0000\u1339"+
"\u1387\u0001\u0000\u0000\u0000\u133a\u1338\u0001\u0000\u0000\u0000\u133b"+
"\u133c\u0005\u0131\u0000\u0000\u133c\u133d\u0005\u00d8\u0000\u0000\u133d"+
"\u1342\u0005\u02ca\u0000\u0000\u133e\u133f\u0005\u00b8\u0000\u0000\u133f"+
"\u1341\u0005\u02ca\u0000\u0000\u1340\u133e\u0001\u0000\u0000\u0000\u1341"+
"\u1344\u0001\u0000\u0000\u0000\u1342\u1340\u0001\u0000\u0000\u0000\u1342"+
"\u1343\u0001\u0000\u0000\u0000\u1343\u1387\u0001\u0000\u0000\u0000\u1344"+
"\u1342\u0001\u0000\u0000\u0000\u1345\u1346\u0005\u00c2\u0000\u0000\u1346"+
"\u1347\u0005\u01ea\u0000\u0000\u1347\u1387\u0005\u02ca\u0000\u0000\u1348"+
"\u1349\u0005\u0144\u0000\u0000\u1349\u134a\u0005\u01ea\u0000\u0000\u134a"+
"\u1387\u0005\u02ca\u0000\u0000\u134b\u134c\u0005\u00c2\u0000\u0000\u134c"+
"\u134d\u0005\u016b\u0000\u0000\u134d\u1387\u0005\u02ca\u0000\u0000\u134e"+
"\u134f\u0005\u0144\u0000\u0000\u134f\u1350\u0005\u016b\u0000\u0000\u1350"+
"\u1387\u0005\u02ca\u0000\u0000\u1351\u1352\u0005\u00c2\u0000\u0000\u1352"+
"\u1353\u0005\u00ec\u0000\u0000\u1353\u1354\u0003\u01c2\u00e1\u0000\u1354"+
"\u1359\u0005\u02ca\u0000\u0000\u1355\u1356\u0005\u00b8\u0000\u0000\u1356"+
"\u1358\u0005\u02ca\u0000\u0000\u1357\u1355\u0001\u0000\u0000\u0000\u1358"+
"\u135b\u0001\u0000\u0000\u0000\u1359\u1357\u0001\u0000\u0000\u0000\u1359"+
"\u135a\u0001\u0000\u0000\u0000\u135a\u1387\u0001\u0000\u0000\u0000\u135b"+
"\u1359\u0001\u0000\u0000\u0000\u135c\u135d\u0005\u0144\u0000\u0000\u135d"+
"\u135e\u0005\u00ec\u0000\u0000\u135e\u135f\u0003\u01c2\u00e1\u0000\u135f"+
"\u1364\u0005\u02ca\u0000\u0000\u1360\u1361\u0005\u00b8\u0000\u0000\u1361"+
"\u1363\u0005\u02ca\u0000\u0000\u1362\u1360\u0001\u0000\u0000\u0000\u1363"+
"\u1366\u0001\u0000\u0000\u0000\u1364\u1362\u0001\u0000\u0000\u0000\u1364"+
"\u1365\u0001\u0000\u0000\u0000\u1365\u1387\u0001\u0000\u0000\u0000\u1366"+
"\u1364\u0001\u0000\u0000\u0000\u1367\u1368\u0005\u0144\u0000\u0000\u1368"+
"\u1369\u0005\u00c8\u0000\u0000\u1369\u136a\u0005\u00ec\u0000\u0000\u136a"+
"\u1387\u0003\u01c2\u00e1\u0000\u136b\u136c\u0005\u0250\u0000\u0000\u136c"+
"\u136d\u0005\u01bd\u0000\u0000\u136d\u136e\u0005\u0154\u0000\u0000\u136e"+
"\u1370\u0005\u018c\u0000\u0000\u136f\u1371\u0003\u0244\u0122\u0000\u1370"+
"\u136f\u0001\u0000\u0000\u0000\u1370\u1371\u0001\u0000\u0000\u0000\u1371"+
"\u1387\u0001\u0000\u0000\u0000\u1372\u1373\u0005\u01db\u0000\u0000\u1373"+
"\u1374\u0005\u00d8\u0000\u0000\u1374\u1379\u0005\u02ca\u0000\u0000\u1375"+
"\u1376\u0005\u00b8\u0000\u0000\u1376\u1378\u0005\u02ca\u0000\u0000\u1377"+
"\u1375\u0001\u0000\u0000\u0000\u1378\u137b\u0001\u0000\u0000\u0000\u1379"+
"\u1377\u0001\u0000\u0000\u0000\u1379\u137a\u0001\u0000\u0000\u0000\u137a"+
"\u137c\u0001\u0000\u0000\u0000\u137b\u1379\u0001\u0000\u0000\u0000\u137c"+
"\u137d\u0005\u0250\u0000\u0000\u137d\u137e\u0005\u00b6\u0000\u0000\u137e"+
"\u137f\u0003\u0246\u0123\u0000\u137f\u1380\u0005\u00b7\u0000\u0000\u1380"+
"\u1387\u0001\u0000\u0000\u0000\u1381\u1382\u0005\u01db\u0000\u0000\u1382"+
"\u1383\u0007\r\u0000\u0000\u1383\u1384\u0005\u02ca\u0000\u0000\u1384\u1385"+
"\u0005\u0188\u0000\u0000\u1385\u1387\u0005\u02ca\u0000\u0000\u1386\u1324"+
"\u0001\u0000\u0000\u0000\u1386\u1331\u0001\u0000\u0000\u0000\u1386\u133b"+
"\u0001\u0000\u0000\u0000\u1386\u1345\u0001\u0000\u0000\u0000\u1386\u1348"+
"\u0001\u0000\u0000\u0000\u1386\u134b\u0001\u0000\u0000\u0000\u1386\u134e"+
"\u0001\u0000\u0000\u0000\u1386\u1351\u0001\u0000\u0000\u0000\u1386\u135c"+
"\u0001\u0000\u0000\u0000\u1386\u1367\u0001\u0000\u0000\u0000\u1386\u136b"+
"\u0001\u0000\u0000\u0000\u1386\u1372\u0001\u0000\u0000\u0000\u1386\u1381"+
"\u0001\u0000\u0000\u0000\u1387\u015d\u0001\u0000\u0000\u0000\u1388\u138a"+
"\u0003\u02ca\u0165\u0000\u1389\u138b\u0003\u0244\u0122\u0000\u138a\u1389"+
"\u0001\u0000\u0000\u0000\u138a\u138b\u0001\u0000\u0000\u0000\u138b\u015f"+
"\u0001\u0000\u0000\u0000\u138c\u138d\u0003\u02ca\u0165\u0000\u138d\u1391"+
"\u0003\u023a\u011d\u0000\u138e\u138f\u0005\u0148\u0000\u0000\u138f\u1390"+
"\u0005\u01ac\u0000\u0000\u1390\u1392\u0003\u023a\u011d\u0000\u1391\u138e"+
"\u0001\u0000\u0000\u0000\u1391\u1392\u0001\u0000\u0000\u0000\u1392\u1394"+
"\u0001\u0000\u0000\u0000\u1393\u1395\u0003\u017c\u00be\u0000\u1394\u1393"+
"\u0001\u0000\u0000\u0000\u1394\u1395\u0001\u0000\u0000\u0000\u1395\u1397"+
"\u0001\u0000\u0000\u0000\u1396\u1398\u0003\u0244\u0122\u0000\u1397\u1396"+
"\u0001\u0000\u0000\u0000\u1397\u1398\u0001\u0000\u0000\u0000\u1398\u0161"+
"\u0001\u0000\u0000\u0000\u1399\u139a\u0005\u00c2\u0000\u0000\u139a\u139b"+
"\u0005\u0105\u0000\u0000\u139b\u139d\u0003\u0258\u012c\u0000\u139c\u139e"+
"\u0003\u0178\u00bc\u0000\u139d\u139c\u0001\u0000\u0000\u0000\u139d\u139e"+
"\u0001\u0000\u0000\u0000\u139e\u13a0\u0001\u0000\u0000\u0000\u139f\u13a1"+
"\u0003\u017a\u00bd\u0000\u13a0\u139f\u0001\u0000\u0000\u0000\u13a0\u13a1"+
"\u0001\u0000\u0000\u0000\u13a1\u13a3\u0001\u0000\u0000\u0000\u13a2\u13a4"+
"\u0003\u0244\u0122\u0000\u13a3\u13a2\u0001\u0000\u0000\u0000\u13a3\u13a4"+
"\u0001\u0000\u0000\u0000\u13a4\u148c\u0001\u0000\u0000\u0000\u13a5\u13a6"+
"\u0005\u00c2\u0000\u0000\u13a6\u13a7\u0005\u0105\u0000\u0000\u13a7\u13a8"+
"\u0005\u00b6\u0000\u0000\u13a8\u13ad\u0003\u0258\u012c\u0000\u13a9\u13aa"+
"\u0005\u00b8\u0000\u0000\u13aa\u13ac\u0003\u0258\u012c\u0000\u13ab\u13a9"+
"\u0001\u0000\u0000\u0000\u13ac\u13af\u0001\u0000\u0000\u0000\u13ad\u13ab"+
"\u0001\u0000\u0000\u0000\u13ad\u13ae\u0001\u0000\u0000\u0000\u13ae\u13b0"+
"\u0001\u0000\u0000\u0000\u13af\u13ad\u0001\u0000\u0000\u0000\u13b0\u13b2"+
"\u0005\u00b7\u0000\u0000\u13b1\u13b3\u0003\u017a\u00bd\u0000\u13b2\u13b1"+
"\u0001\u0000\u0000\u0000\u13b2\u13b3\u0001\u0000\u0000\u0000\u13b3\u13b5"+
"\u0001\u0000\u0000\u0000\u13b4\u13b6\u0003\u0244\u0122\u0000\u13b5\u13b4"+
"\u0001\u0000\u0000\u0000\u13b5\u13b6\u0001\u0000\u0000\u0000\u13b6\u148c"+
"\u0001\u0000\u0000\u0000\u13b7\u13b8\u0005\u0144\u0000\u0000\u13b8\u13b9"+
"\u0005\u0105\u0000\u0000\u13b9\u13bb\u0003\u02ca\u0165\u0000\u13ba\u13bc"+
"\u0003\u017c\u00be\u0000\u13bb\u13ba\u0001\u0000\u0000\u0000\u13bb\u13bc"+
"\u0001\u0000\u0000\u0000\u13bc\u13be\u0001\u0000\u0000\u0000\u13bd\u13bf"+
"\u0003\u0244\u0122\u0000\u13be\u13bd\u0001\u0000\u0000\u0000\u13be\u13bf"+
"\u0001\u0000\u0000\u0000\u13bf\u148c\u0001\u0000\u0000\u0000\u13c0\u13c1"+
"\u0005\u01db\u0000\u0000\u13c1\u13c2\u0005\u0105\u0000\u0000\u13c2\u13c4"+
"\u0003\u0258\u012c\u0000\u13c3\u13c5\u0003\u0178\u00bc\u0000\u13c4\u13c3"+
"\u0001\u0000\u0000\u0000\u13c4\u13c5\u0001\u0000\u0000\u0000\u13c5\u13c7"+
"\u0001\u0000\u0000\u0000\u13c6\u13c8\u0003\u017c\u00be\u0000\u13c7\u13c6"+
"\u0001\u0000\u0000\u0000\u13c7\u13c8\u0001\u0000\u0000\u0000\u13c8\u13ca"+
"\u0001\u0000\u0000\u0000\u13c9\u13cb\u0003\u0244\u0122\u0000\u13ca\u13c9"+
"\u0001\u0000\u0000\u0000\u13ca\u13cb\u0001\u0000\u0000\u0000\u13cb\u148c"+
"\u0001\u0000\u0000\u0000\u13cc\u13cd\u0005\u01f2\u0000\u0000\u13cd\u13ce"+
"\u0005\u00f1\u0000\u0000\u13ce\u13d0\u0003\u023a\u011d\u0000\u13cf\u13d1"+
"\u0003\u017c\u00be\u0000\u13d0\u13cf\u0001\u0000\u0000\u0000\u13d0\u13d1"+
"\u0001\u0000\u0000\u0000\u13d1\u13d3\u0001\u0000\u0000\u0000\u13d2\u13d4"+
"\u0003\u0244\u0122\u0000\u13d3\u13d2\u0001\u0000\u0000\u0000\u13d3\u13d4"+
"\u0001\u0000\u0000\u0000\u13d4\u148c\u0001\u0000\u0000\u0000\u13d5\u13d7"+
"\u0005\u00c2\u0000\u0000\u13d6\u13d8\u0005\u0276\u0000\u0000\u13d7\u13d6"+
"\u0001\u0000\u0000\u0000\u13d7\u13d8\u0001\u0000\u0000\u0000\u13d8\u13dc"+
"\u0001\u0000\u0000\u0000\u13d9\u13dd\u0003\u0262\u0131\u0000\u13da\u13dd"+
"\u0003\u0264\u0132\u0000\u13db\u13dd\u0003\u0268\u0134\u0000\u13dc\u13d9"+
"\u0001\u0000\u0000\u0000\u13dc\u13da\u0001\u0000\u0000\u0000\u13dc\u13db"+
"\u0001\u0000\u0000\u0000\u13dd\u13e2\u0001\u0000\u0000\u0000\u13de\u13df"+
"\u0005\u00b6\u0000\u0000\u13df\u13e0\u0003\u0246\u0123\u0000\u13e0\u13e1"+
"\u0005\u00b7\u0000\u0000\u13e1\u13e3\u0001\u0000\u0000\u0000\u13e2\u13de"+
"\u0001\u0000\u0000\u0000\u13e2\u13e3\u0001\u0000\u0000\u0000\u13e3\u13f2"+
"\u0001\u0000\u0000\u0000\u13e4\u13e5\u0005\u013e\u0000\u0000\u13e5\u13e9"+
"\u0005\u00f1\u0000\u0000\u13e6\u13e7\u0005\u0181\u0000\u0000\u13e7\u13ea"+
"\u0003\u023a\u011d\u0000\u13e8\u13ea\u0005\u021c\u0000\u0000\u13e9\u13e6"+
"\u0001\u0000\u0000\u0000\u13e9\u13e8\u0001\u0000\u0000\u0000\u13ea\u13f0"+
"\u0001\u0000\u0000\u0000\u13eb\u13ee\u0005\u00ed\u0000\u0000\u13ec\u13ef"+
"\u0005\u02cf\u0000\u0000\u13ed\u13ef\u0005\u00d5\u0000\u0000\u13ee\u13ec"+
"\u0001\u0000\u0000\u0000\u13ee\u13ed\u0001\u0000\u0000\u0000\u13ef\u13f1"+
"\u0001\u0000\u0000\u0000\u13f0\u13eb\u0001\u0000\u0000\u0000\u13f0\u13f1"+
"\u0001\u0000\u0000\u0000\u13f1\u13f3\u0001\u0000\u0000\u0000\u13f2\u13e4"+
"\u0001\u0000\u0000\u0000\u13f2\u13f3\u0001\u0000\u0000\u0000\u13f3\u13f5"+
"\u0001\u0000\u0000\u0000\u13f4\u13f6\u0003\u0244\u0122\u0000\u13f5\u13f4"+
"\u0001\u0000\u0000\u0000\u13f5\u13f6\u0001\u0000\u0000\u0000\u13f6\u148c"+
"\u0001\u0000\u0000\u0000\u13f7\u13f9\u0005\u0144\u0000\u0000\u13f8\u13fa"+
"\u0005\u0276\u0000\u0000\u13f9\u13f8\u0001\u0000\u0000\u0000\u13f9\u13fa"+
"\u0001\u0000\u0000\u0000\u13fa\u13fb\u0001\u0000\u0000\u0000\u13fb\u13fe"+
"\u0005\u01f9\u0000\u0000\u13fc\u13fd\u0005\u018e\u0000\u0000\u13fd\u13ff"+
"\u0005\u015b\u0000\u0000\u13fe\u13fc\u0001\u0000\u0000\u0000\u13fe\u13ff"+
"\u0001\u0000\u0000\u0000\u13ff\u1400\u0001\u0000\u0000\u0000\u1400\u1402"+
"\u0003\u02ca\u0165\u0000\u1401\u1403\u0005\u016f\u0000\u0000\u1402\u1401"+
"\u0001\u0000\u0000\u0000\u1402\u1403\u0001\u0000\u0000\u0000\u1403\u1407"+
"\u0001\u0000\u0000\u0000\u1404\u1405\u0005\u0172\u0000\u0000\u1405\u1406"+
"\u0005\u0193\u0000\u0000\u1406\u1408\u0003\u02ca\u0165\u0000\u1407\u1404"+
"\u0001\u0000\u0000\u0000\u1407\u1408\u0001\u0000\u0000\u0000\u1408\u148c"+
"\u0001\u0000\u0000\u0000\u1409\u140b\u0005\u01db\u0000\u0000\u140a\u140c"+
"\u0005\u0276\u0000\u0000\u140b\u140a\u0001\u0000\u0000\u0000\u140b\u140c"+
"\u0001\u0000\u0000\u0000\u140c\u140d\u0001\u0000\u0000\u0000\u140d\u1410"+
"\u0005\u01f9\u0000\u0000\u140e\u140f\u0005\u018e\u0000\u0000\u140f\u1411"+
"\u0005\u015b\u0000\u0000\u1410\u140e\u0001\u0000\u0000\u0000\u1410\u1411"+
"\u0001\u0000\u0000\u0000\u1411\u1417\u0001\u0000\u0000\u0000\u1412\u1418"+
"\u0003\u02ca\u0165\u0000\u1413\u1418\u0003\u023a\u011d\u0000\u1414\u1415"+
"\u0005\u00b6\u0000\u0000\u1415\u1416\u0005\u02b9\u0000\u0000\u1416\u1418"+
"\u0005\u00b7\u0000\u0000\u1417\u1412\u0001\u0000\u0000\u0000\u1417\u1413"+
"\u0001\u0000\u0000\u0000\u1417\u1414\u0001\u0000\u0000\u0000\u1418\u1419"+
"\u0001\u0000\u0000\u0000\u1419\u141a\u0005\u0250\u0000\u0000\u141a\u141b"+
"\u0005\u00b6\u0000\u0000\u141b\u141c\u0003\u0246\u0123\u0000\u141c\u141d"+
"\u0005\u00b7\u0000\u0000\u141d\u148c\u0001\u0000\u0000\u0000\u141e\u1420"+
"\u0005\u022b\u0000\u0000\u141f\u1421\u0003\u01ae\u00d7\u0000\u1420\u141f"+
"\u0001\u0000\u0000\u0000\u1420\u1421\u0001\u0000\u0000\u0000\u1421\u1422"+
"\u0001\u0000\u0000\u0000\u1422\u1424\u0005\u02aa\u0000\u0000\u1423\u1425"+
"\u0003\u01ae\u00d7\u0000\u1424\u1423\u0001\u0000\u0000\u0000\u1424\u1425"+
"\u0001\u0000\u0000\u0000\u1425\u1427\u0001\u0000\u0000\u0000\u1426\u1428"+
"\u0005\u016f\u0000\u0000\u1427\u1426\u0001\u0000\u0000\u0000\u1427\u1428"+
"\u0001\u0000\u0000\u0000\u1428\u142a\u0001\u0000\u0000\u0000\u1429\u142b"+
"\u0003\u0244\u0122\u0000\u142a\u1429\u0001\u0000\u0000\u0000\u142a\u142b"+
"\u0001\u0000\u0000\u0000\u142b\u148c\u0001\u0000\u0000\u0000\u142c\u142d"+
"\u0005\u022b\u0000\u0000\u142d\u142e\u0005\u02aa\u0000\u0000\u142e\u142f"+
"\u0005\u026e\u0000\u0000\u142f\u1431\u0003\u02ca\u0165\u0000\u1430\u1432"+
"\u0003\u0244\u0122\u0000\u1431\u1430\u0001\u0000\u0000\u0000\u1431\u1432"+
"\u0001\u0000\u0000\u0000\u1432\u148c\u0001\u0000\u0000\u0000\u1433\u1434"+
"\u0005\u0228\u0000\u0000\u1434\u148c\u0003\u02ca\u0165\u0000\u1435\u1436"+
"\u0005\u0228\u0000\u0000\u1436\u1437\u0005\u0240\u0000\u0000\u1437\u1438"+
"\u0003\u02ca\u0165\u0000\u1438\u1439\u0003\u02ca\u0165\u0000\u1439\u148c"+
"\u0001\u0000\u0000\u0000\u143a\u143b\u0005\u0228\u0000\u0000\u143b\u143c"+
"\u0005\u01f9\u0000\u0000\u143c\u143d\u0003\u02ca\u0165\u0000\u143d\u143e"+
"\u0003\u02ca\u0165\u0000\u143e\u148c\u0001\u0000\u0000\u0000\u143f\u1440"+
"\u0005\u0228\u0000\u0000\u1440\u1441\u0005\u0105\u0000\u0000\u1441\u1442"+
"\u0003\u02ca\u0165\u0000\u1442\u1443\u0003\u02ca\u0165\u0000\u1443\u148c"+
"\u0001\u0000\u0000\u0000\u1444\u1445\u0005\u00c2\u0000\u0000\u1445\u148c"+
"\u0003\u025c\u012e\u0000\u1446\u1447\u0005\u0144\u0000\u0000\u1447\u144a"+
"\u0005\u0193\u0000\u0000\u1448\u1449\u0005\u018e\u0000\u0000\u1449\u144b"+
"\u0005\u015b\u0000\u0000\u144a\u1448\u0001\u0000\u0000\u0000\u144a\u144b"+
"\u0001\u0000\u0000\u0000\u144b\u144c\u0001\u0000\u0000\u0000\u144c\u148c"+
"\u0003\u02ca\u0165\u0000\u144d\u144e\u0005\u014c\u0000\u0000\u144e\u144f"+
"\u0005\u0165\u0000\u0000\u144f\u1452\u0005\u02ca\u0000\u0000\u1450\u1451"+
"\u0005\u02aa\u0000\u0000\u1451\u1453\u0003\u0244\u0122\u0000\u1452\u1450"+
"\u0001\u0000\u0000\u0000\u1452\u1453\u0001\u0000\u0000\u0000\u1453\u148c"+
"\u0001\u0000\u0000\u0000\u1454\u1455\u0005\u01db\u0000\u0000\u1455\u1464"+
"\u0005\u013f\u0000\u0000\u1456\u1457\u0005\u013e\u0000\u0000\u1457\u145b"+
"\u0005\u00f1\u0000\u0000\u1458\u1459\u0005\u0181\u0000\u0000\u1459\u145c"+
"\u0003\u023a\u011d\u0000\u145a\u145c\u0005\u021c\u0000\u0000\u145b\u1458"+
"\u0001\u0000\u0000\u0000\u145b\u145a\u0001\u0000\u0000\u0000\u145c\u1462"+
"\u0001\u0000\u0000\u0000\u145d\u1460\u0005\u00ed\u0000\u0000\u145e\u1461"+
"\u0005\u02cf\u0000\u0000\u145f\u1461\u0005\u00d5\u0000\u0000\u1460\u145e"+
"\u0001\u0000\u0000\u0000\u1460\u145f\u0001\u0000\u0000\u0000\u1461\u1463"+
"\u0001\u0000\u0000\u0000\u1462\u145d\u0001\u0000\u0000\u0000\u1462\u1463"+
"\u0001\u0000\u0000\u0000\u1463\u1465\u0001\u0000\u0000\u0000\u1464\u1456"+
"\u0001\u0000\u0000\u0000\u1464\u1465\u0001\u0000\u0000\u0000\u1465\u148c"+
"\u0001\u0000\u0000\u0000\u1466\u1467\u0005\u01db\u0000\u0000\u1467\u1468"+
"\u0005\u0107\u0000\u0000\u1468\u148c\u0005\u02ca\u0000\u0000\u1469\u146a"+
"\u0005\u01db\u0000\u0000\u146a\u146b\u0005\u0105\u0000\u0000\u146b\u146c"+
"\u0003\u02ca\u0165\u0000\u146c\u146d\u0005\u0107\u0000\u0000\u146d\u146e"+
"\u0005\u02ca\u0000\u0000\u146e\u148c\u0001\u0000\u0000\u0000\u146f\u1470"+
"\u0005\u01db\u0000\u0000\u1470\u1471\u0005\u0151\u0000\u0000\u1471\u1472"+
"\u0005\u027e\u0000\u0000\u1472\u1474\u0003\u02ca\u0165\u0000\u1473\u1475"+
"\u0003\u0244\u0122\u0000\u1474\u1473\u0001\u0000\u0000\u0000\u1474\u1475"+
"\u0001\u0000\u0000\u0000\u1475\u148c\u0001\u0000\u0000\u0000\u1476\u1478"+
"\u0005\u00c2\u0000\u0000\u1477\u1479\u0005\u0276\u0000\u0000\u1478\u1477"+
"\u0001\u0000\u0000\u0000\u1478\u1479\u0001\u0000\u0000\u0000\u1479\u147a"+
"\u0001\u0000\u0000\u0000\u147a\u147b\u0005\u01fa\u0000\u0000\u147b\u147c"+
"\u0005\u0172\u0000\u0000\u147c\u147d\u0003\u026a\u0135\u0000\u147d\u147e"+
"\u0005\u027e\u0000\u0000\u147e\u147f\u0003\u026a\u0135\u0000\u147f\u1480"+
"\u0005\u019d\u0000\u0000\u1480\u1482\u0005\u02cf\u0000\u0000\u1481\u1483"+
"\u0003\u02ca\u0165\u0000\u1482\u1481\u0001\u0000\u0000\u0000\u1482\u1483"+
"\u0001\u0000\u0000\u0000\u1483\u1485\u0001\u0000\u0000\u0000\u1484\u1486"+
"\u0003\u0244\u0122\u0000\u1485\u1484\u0001\u0000\u0000\u0000\u1485\u1486"+
"\u0001\u0000\u0000\u0000\u1486\u148c\u0001\u0000\u0000\u0000\u1487\u148c"+
"\u0003\u0164\u00b2\u0000\u1488\u148c\u0003\u0166\u00b3\u0000\u1489\u148c"+
"\u0003\u0174\u00ba\u0000\u148a\u148c\u0003\u0176\u00bb\u0000\u148b\u1399"+
"\u0001\u0000\u0000\u0000\u148b\u13a5\u0001\u0000\u0000\u0000\u148b\u13b7"+
"\u0001\u0000\u0000\u0000\u148b\u13c0\u0001\u0000\u0000\u0000\u148b\u13cc"+
"\u0001\u0000\u0000\u0000\u148b\u13d5\u0001\u0000\u0000\u0000\u148b\u13f7"+
"\u0001\u0000\u0000\u0000\u148b\u1409\u0001\u0000\u0000\u0000\u148b\u141e"+
"\u0001\u0000\u0000\u0000\u148b\u142c\u0001\u0000\u0000\u0000\u148b\u1433"+
"\u0001\u0000\u0000\u0000\u148b\u1435\u0001\u0000\u0000\u0000\u148b\u143a"+
"\u0001\u0000\u0000\u0000\u148b\u143f\u0001\u0000\u0000\u0000\u148b\u1444"+
"\u0001\u0000\u0000\u0000\u148b\u1446\u0001\u0000\u0000\u0000\u148b\u144d"+
"\u0001\u0000\u0000\u0000\u148b\u1454\u0001\u0000\u0000\u0000\u148b\u1466"+
"\u0001\u0000\u0000\u0000\u148b\u1469\u0001\u0000\u0000\u0000\u148b\u146f"+
"\u0001\u0000\u0000\u0000\u148b\u1476\u0001\u0000\u0000\u0000\u148b\u1487"+
"\u0001\u0000\u0000\u0000\u148b\u1488\u0001\u0000\u0000\u0000\u148b\u1489"+
"\u0001\u0000\u0000\u0000\u148b\u148a\u0001\u0000\u0000\u0000\u148c\u0163"+
"\u0001\u0000\u0000\u0000\u148d\u148e\u0005\u0119\u0000\u0000\u148e\u1492"+
"\u0005\u0273\u0000\u0000\u148f\u1490\u0005\u018e\u0000\u0000\u1490\u1491"+
"\u0005\u01e7\u0000\u0000\u1491\u1493\u0005\u015b\u0000\u0000\u1492\u148f"+
"\u0001\u0000\u0000\u0000\u1492\u1493\u0001\u0000\u0000\u0000\u1493\u1494"+
"\u0001\u0000\u0000\u0000\u1494\u1495\u0003\u02ca\u0165\u0000\u1495\u1496"+
"\u0003\u0168\u00b4\u0000\u1496\u14a1\u0001\u0000\u0000\u0000\u1497\u1498"+
"\u0005\u0119\u0000\u0000\u1498\u149a\u0005\u01f1\u0000\u0000\u1499\u1497"+
"\u0001\u0000\u0000\u0000\u1499\u149a\u0001\u0000\u0000\u0000\u149a\u149b"+
"\u0001\u0000\u0000\u0000\u149b\u149c\u0005\u022b\u0000\u0000\u149c\u149d"+
"\u0005\u0273\u0000\u0000\u149d\u149e\u0003\u02ca\u0165\u0000\u149e\u149f"+
"\u0003\u0168\u00b4\u0000\u149f\u14a1\u0001\u0000\u0000\u0000\u14a0\u148d"+
"\u0001\u0000\u0000\u0000\u14a0\u1499\u0001\u0000\u0000\u0000\u14a1\u0165"+
"\u0001\u0000\u0000\u0000\u14a2\u14a3\u0005\u0119\u0000\u0000\u14a3\u14a7"+
"\u0005\u00ea\u0000\u0000\u14a4\u14a5\u0005\u018e\u0000\u0000\u14a5\u14a6"+
"\u0005\u01e7\u0000\u0000\u14a6\u14a8\u0005\u015b\u0000\u0000\u14a7\u14a4"+
"\u0001\u0000\u0000\u0000\u14a7\u14a8\u0001\u0000\u0000\u0000\u14a8\u14a9"+
"\u0001\u0000\u0000\u0000\u14a9\u14aa\u0003\u02ca\u0165\u0000\u14aa\u14ab"+
"\u0003\u016a\u00b5\u0000\u14ab\u14b6\u0001\u0000\u0000\u0000\u14ac\u14ad"+
"\u0005\u0119\u0000\u0000\u14ad\u14af\u0005\u01f1\u0000\u0000\u14ae\u14ac"+
"\u0001\u0000\u0000\u0000\u14ae\u14af\u0001\u0000\u0000\u0000\u14af\u14b0"+
"\u0001\u0000\u0000\u0000\u14b0\u14b1\u0005\u022b\u0000\u0000\u14b1\u14b2"+
"\u0005\u00ea\u0000\u0000\u14b2\u14b3\u0003\u02ca\u0165\u0000\u14b3\u14b4"+
"\u0003\u016a\u00b5\u0000\u14b4\u14b6\u0001\u0000\u0000\u0000\u14b5\u14a2"+
"\u0001\u0000\u0000\u0000\u14b5\u14ae\u0001\u0000\u0000\u0000\u14b6\u0167"+
"\u0001\u0000\u0000\u0000\u14b7\u14b8\u0005\u00d1\u0000\u0000\u14b8\u14b9"+
"\u0005\u01eb\u0000\u0000\u14b9\u14ba\u0005\u02a1\u0000\u0000\u14ba\u14bc"+
"\u0005\u02cf\u0000\u0000\u14bb\u14b7\u0001\u0000\u0000\u0000\u14bb\u14bc"+
"\u0001\u0000\u0000\u0000\u14bc\u14be\u0001\u0000\u0000\u0000\u14bd\u14bf"+
"\u0003\u016c\u00b6\u0000\u14be\u14bd\u0001\u0000\u0000\u0000\u14be\u14bf"+
"\u0001\u0000\u0000\u0000\u14bf\u0169\u0001\u0000\u0000\u0000\u14c0\u14c1"+
"\u0005\u00d1\u0000\u0000\u14c1\u14c2\u0005\u01eb\u0000\u0000\u14c2\u14c3"+
"\u0005\u02a1\u0000\u0000\u14c3\u14c5\u0005\u02cf\u0000\u0000\u14c4\u14c0"+
"\u0001\u0000\u0000\u0000\u14c4\u14c5\u0001\u0000\u0000\u0000\u14c5\u14c7"+
"\u0001\u0000\u0000\u0000\u14c6\u14c8\u0003\u016c\u00b6\u0000\u14c7\u14c6"+
"\u0001\u0000\u0000\u0000\u14c7\u14c8\u0001\u0000\u0000\u0000\u14c8\u14ca"+
"\u0001\u0000\u0000\u0000\u14c9\u14cb\u0003\u016e\u00b7\u0000\u14ca\u14c9"+
"\u0001\u0000\u0000\u0000\u14ca\u14cb\u0001\u0000\u0000\u0000\u14cb\u016b"+
"\u0001\u0000\u0000\u0000\u14cc\u14cd\u0005\u0236\u0000\u0000\u14cd\u14ce"+
"\u0003\u0172\u00b9\u0000\u14ce\u016d\u0001\u0000\u0000\u0000\u14cf\u14d0"+
"\u0005\u02aa\u0000\u0000\u14d0\u14d1\u0005\u0258\u0000\u0000\u14d1\u14d2"+
"\u0005\u0237\u0000\u0000\u14d2\u14de\u0003\u0170\u00b8\u0000\u14d3\u14d4"+
"\u0005\u02aa\u0000\u0000\u14d4\u14d5\u0005\u0258\u0000\u0000\u14d5\u14d6"+
"\u0005\u0237\u0000\u0000\u14d6\u14de\u0003\u0172\u00b9\u0000\u14d7\u14d8"+
"\u0005\u02aa\u0000\u0000\u14d8\u14d9\u0005\u0258\u0000\u0000\u14d9\u14da"+
"\u0005\u0237\u0000\u0000\u14da\u14db\u0003\u0170\u00b8\u0000\u14db\u14dc"+
"\u0003\u0172\u00b9\u0000\u14dc\u14de\u0001\u0000\u0000\u0000\u14dd\u14cf"+
"\u0001\u0000\u0000\u0000\u14dd\u14d3\u0001\u0000\u0000\u0000\u14dd\u14d7"+
"\u0001\u0000\u0000\u0000\u14de\u016f\u0001\u0000\u0000\u0000\u14df\u14e0"+
"\u0005\u02cf\u0000\u0000\u14e0\u14e1\u0005\u0259\u0000\u0000\u14e1\u0171"+
"\u0001\u0000\u0000\u0000\u14e2\u14e3\u0005\u02cf\u0000\u0000\u14e3\u14e4"+
"\u00074\u0000\u0000\u14e4\u0173\u0001\u0000\u0000\u0000\u14e5\u14e6\u0005"+
"\u0144\u0000\u0000\u14e6\u14e9\u0005\u00ea\u0000\u0000\u14e7\u14e8\u0005"+
"\u018e\u0000\u0000\u14e8\u14ea\u0005\u015b\u0000\u0000\u14e9\u14e7\u0001"+
"\u0000\u0000\u0000\u14e9\u14ea\u0001\u0000\u0000\u0000\u14ea\u14eb\u0001"+
"\u0000\u0000\u0000\u14eb\u14ec\u0003\u02ca\u0165\u0000\u14ec\u0175\u0001"+
"\u0000\u0000\u0000\u14ed\u14ee\u0005\u0144\u0000\u0000\u14ee\u14f1\u0005"+
"\u0273\u0000\u0000\u14ef\u14f0\u0005\u018e\u0000\u0000\u14f0\u14f2\u0005"+
"\u015b\u0000\u0000\u14f1\u14ef\u0001\u0000\u0000\u0000\u14f1\u14f2\u0001"+
"\u0000\u0000\u0000\u14f2\u14f3\u0001\u0000\u0000\u0000\u14f3\u14f4\u0003"+
"\u02ca\u0165\u0000\u14f4\u0177\u0001\u0000\u0000\u0000\u14f5\u14f9\u0005"+
"\u0169\u0000\u0000\u14f6\u14f7\u0005\u00c4\u0000\u0000\u14f7\u14f9\u0003"+
"\u02ca\u0165\u0000\u14f8\u14f5\u0001\u0000\u0000\u0000\u14f8\u14f6\u0001"+
"\u0000\u0000\u0000\u14f9\u0179\u0001\u0000\u0000\u0000\u14fa\u14fb\u0007"+
"5\u0000\u0000\u14fb\u14fc\u0003\u02ca\u0165\u0000\u14fc\u017b\u0001\u0000"+
"\u0000\u0000\u14fd\u14fe\u0005\u0172\u0000\u0000\u14fe\u14ff\u0003\u02ca"+
"\u0165\u0000\u14ff\u017d\u0001\u0000\u0000\u0000\u1500\u1501\u0005\u0144"+
"\u0000\u0000\u1501\u1504\u0007,\u0000\u0000\u1502\u1503\u0005\u018e\u0000"+
"\u0000\u1503\u1505\u0005\u015b\u0000\u0000\u1504\u1502\u0001\u0000\u0000"+
"\u0000\u1504\u1505\u0001\u0000\u0000\u0000\u1505\u1506\u0001\u0000\u0000"+
"\u0000\u1506\u1508\u0003\u0250\u0128\u0000\u1507\u1509\u0005\u016f\u0000"+
"\u0000\u1508\u1507\u0001\u0000\u0000\u0000\u1508\u1509\u0001\u0000\u0000"+
"\u0000\u1509\u1595\u0001\u0000\u0000\u0000\u150a\u150b\u0005\u0144\u0000"+
"\u0000\u150b\u150e\u0005\u00f8\u0000\u0000\u150c\u150d\u0005\u018e\u0000"+
"\u0000\u150d\u150f\u0005\u015b\u0000\u0000\u150e\u150c\u0001\u0000\u0000"+
"\u0000\u150e\u150f\u0001\u0000\u0000\u0000\u150f\u1510\u0001\u0000\u0000"+
"\u0000\u1510\u1595\u0003\u02ca\u0165\u0000\u1511\u1513\u0005\u0144\u0000"+
"\u0000\u1512\u1514\u0007\u0011\u0000\u0000\u1513\u1512\u0001\u0000\u0000"+
"\u0000\u1513\u1514\u0001\u0000\u0000\u0000\u1514\u1515\u0001\u0000\u0000"+
"\u0000\u1515\u1518\u0005\u0176\u0000\u0000\u1516\u1517\u0005\u018e\u0000"+
"\u0000\u1517\u1519\u0005\u015b\u0000\u0000\u1518\u1516\u0001\u0000\u0000"+
"\u0000\u1518\u1519\u0001\u0000\u0000\u0000\u1519\u151a\u0001\u0000\u0000"+
"\u0000\u151a\u151b\u0003\u0290\u0148\u0000\u151b\u151d\u0005\u00b6\u0000"+
"\u0000\u151c\u151e\u0003\u0192\u00c9\u0000\u151d\u151c\u0001\u0000\u0000"+
"\u0000\u151d\u151e\u0001\u0000\u0000\u0000\u151e\u151f\u0001\u0000\u0000"+
"\u0000\u151f\u1520\u0005\u00b7\u0000\u0000\u1520\u1595\u0001\u0000\u0000"+
"\u0000\u1521\u1522\u0005\u0144\u0000\u0000\u1522\u1525\u0005\u026e\u0000"+
"\u0000\u1523\u1524\u0005\u018e\u0000\u0000\u1524\u1526\u0005\u015b\u0000"+
"\u0000\u1525\u1523\u0001\u0000\u0000\u0000\u1525\u1526\u0001\u0000\u0000"+
"\u0000\u1526\u1527\u0001\u0000\u0000\u0000\u1527\u1529\u0003\u0250\u0128"+
"\u0000\u1528\u152a\u0005\u016f\u0000\u0000\u1529\u1528\u0001\u0000\u0000"+
"\u0000\u1529\u152a\u0001\u0000\u0000\u0000\u152a\u1595\u0001\u0000\u0000"+
"\u0000\u152b\u152c\u0005\u0144\u0000\u0000\u152c\u152f\u0005\u0296\u0000"+
"\u0000\u152d\u152e\u0005\u018e\u0000\u0000\u152e\u1530\u0005\u015b\u0000"+
"\u0000\u152f\u152d\u0001\u0000\u0000\u0000\u152f\u1530\u0001\u0000\u0000"+
"\u0000\u1530\u1531\u0001\u0000\u0000\u0000\u1531\u1595\u0003\u01ca\u00e5"+
"\u0000\u1532\u1533\u0005\u0144\u0000\u0000\u1533\u1536\u0005\u02a2\u0000"+
"\u0000\u1534\u1535\u0005\u018e\u0000\u0000\u1535\u1537\u0005\u015b\u0000"+
"\u0000\u1536\u1534\u0001\u0000\u0000\u0000\u1536\u1537\u0001\u0000\u0000"+
"\u0000\u1537\u1538\u0001\u0000\u0000\u0000\u1538\u1595\u0003\u0250\u0128"+
"\u0000\u1539\u153a\u0005\u0144\u0000\u0000\u153a\u153b\u0005\u0230\u0000"+
"\u0000\u153b\u1595\u0003\u02ca\u0165\u0000\u153c\u153d\u0005\u0144\u0000"+
"\u0000\u153d\u153e\u0005\u0167\u0000\u0000\u153e\u1541\u0005\u02ca\u0000"+
"\u0000\u153f\u1540\u0007(\u0000\u0000\u1540\u1542\u0003\u02ca\u0165\u0000"+
"\u1541\u153f\u0001\u0000\u0000\u0000\u1541\u1542\u0001\u0000\u0000\u0000"+
"\u1542\u1543\u0001\u0000\u0000\u0000\u1543\u1595\u0003\u0244\u0122\u0000"+
"\u1544\u1545\u0005\u0144\u0000\u0000\u1545\u1548\u0005\u0193\u0000\u0000"+
"\u1546\u1547\u0005\u018e\u0000\u0000\u1547\u1549\u0005\u015b\u0000\u0000"+
"\u1548\u1546\u0001\u0000\u0000\u0000\u1548\u1549\u0001\u0000\u0000\u0000"+
"\u1549\u154a\u0001\u0000\u0000\u0000\u154a\u154b\u0003\u02ca\u0165\u0000"+
"\u154b\u154c\u0005\u01ed\u0000\u0000\u154c\u154d\u0003\u0250\u0128\u0000"+
"\u154d\u1595\u0001\u0000\u0000\u0000\u154e\u154f\u0005\u0144\u0000\u0000"+
"\u154f\u1552\u0005\u0231\u0000\u0000\u1550\u1551\u0005\u018e\u0000\u0000"+
"\u1551\u1553\u0005\u015b\u0000\u0000\u1552\u1550\u0001\u0000\u0000\u0000"+
"\u1552\u1553\u0001\u0000\u0000\u0000\u1553\u1554\u0001\u0000\u0000\u0000"+
"\u1554\u1595\u0003\u01c2\u00e1\u0000\u1555\u1556\u0005\u0144\u0000\u0000"+
"\u1556\u1557\u0005\u02ac\u0000\u0000\u1557\u155a\u0005\u017e\u0000\u0000"+
"\u1558\u1559\u0005\u018e\u0000\u0000\u1559\u155b\u0005\u015b\u0000\u0000"+
"\u155a\u1558\u0001\u0000\u0000\u0000\u155a\u155b\u0001\u0000\u0000\u0000"+
"\u155b\u155c\u0001\u0000\u0000\u0000\u155c\u1595\u0003\u01c2\u00e1\u0000"+
"\u155d\u155e\u0005\u0144\u0000\u0000\u155e\u155f\u0005\u02ac\u0000\u0000"+
"\u155f\u1562\u0005\u020e\u0000\u0000\u1560\u1561\u0005\u018e\u0000\u0000"+
"\u1561\u1563\u0005\u015b\u0000\u0000\u1562\u1560\u0001\u0000\u0000\u0000"+
"\u1562\u1563\u0001\u0000\u0000\u0000\u1563\u1564\u0001\u0000\u0000\u0000"+
"\u1564\u1595\u0003\u01c2\u00e1\u0000\u1565\u1566\u0005\u0144\u0000\u0000"+
"\u1566\u1569\u0005\u014d\u0000\u0000\u1567\u1568\u0005\u018e\u0000\u0000"+
"\u1568\u156a\u0005\u015b\u0000\u0000\u1569\u1567\u0001\u0000\u0000\u0000"+
"\u1569\u156a\u0001\u0000\u0000\u0000\u156a\u156b\u0001\u0000\u0000\u0000"+
"\u156b\u1595\u0003\u0250\u0128\u0000\u156c\u156d\u0005\u0144\u0000\u0000"+
"\u156d\u1570\u0005\u025c\u0000\u0000\u156e\u156f\u0005\u018e\u0000\u0000"+
"\u156f\u1571\u0005\u015b\u0000\u0000\u1570\u156e\u0001\u0000\u0000\u0000"+
"\u1570\u1571\u0001\u0000\u0000\u0000\u1571\u1572\u0001\u0000\u0000\u0000"+
"\u1572\u1595\u0003\u023c\u011e\u0000\u1573\u1574\u0005\u0144\u0000\u0000"+
"\u1574\u1575\u0005\u0242\u0000\u0000\u1575\u1578\u0005\u020e\u0000\u0000"+
"\u1576\u1577\u0005\u018e\u0000\u0000\u1577\u1579\u0005\u015b\u0000\u0000"+
"\u1578\u1576\u0001\u0000\u0000\u0000\u1578\u1579\u0001\u0000\u0000\u0000"+
"\u1579\u157a\u0001\u0000\u0000\u0000\u157a\u157b\u0003\u02ca\u0165\u0000"+
"\u157b\u157c\u0005\u01ed\u0000\u0000\u157c\u1583\u0003\u0250\u0128\u0000"+
"\u157d\u1581\u0005\u016d\u0000\u0000\u157e\u1582\u0003\u01ca\u00e5\u0000"+
"\u157f\u1580\u0005\u023d\u0000\u0000\u1580\u1582\u0003\u02ca\u0165\u0000"+
"\u1581\u157e\u0001\u0000\u0000\u0000\u1581\u157f\u0001\u0000\u0000\u0000"+
"\u1582\u1584\u0001\u0000\u0000\u0000\u1583\u157d\u0001\u0000\u0000\u0000"+
"\u1583\u1584\u0001\u0000\u0000\u0000\u1584\u1595\u0001\u0000\u0000\u0000"+
"\u1585\u1586\u0005\u0144\u0000\u0000\u1586\u1587\u0005\u0264\u0000\u0000"+
"\u1587\u158a\u0005\u020e\u0000\u0000\u1588\u1589\u0005\u018e\u0000\u0000"+
"\u1589\u158b\u0005\u015b\u0000\u0000\u158a\u1588\u0001\u0000\u0000\u0000"+
"\u158a\u158b\u0001\u0000\u0000\u0000\u158b\u158c\u0001\u0000\u0000\u0000"+
"\u158c\u1595\u0003\u02ca\u0165\u0000\u158d\u158e\u0005\u0144\u0000\u0000"+
"\u158e\u1591\u0005\u025d\u0000\u0000\u158f\u1590\u0005\u018e\u0000\u0000"+
"\u1590\u1592\u0005\u015b\u0000\u0000\u1591\u158f\u0001\u0000\u0000\u0000"+
"\u1591\u1592\u0001\u0000\u0000\u0000\u1592\u1593\u0001\u0000\u0000\u0000"+
"\u1593\u1595\u0003\u02ca\u0165\u0000\u1594\u1500\u0001\u0000\u0000\u0000"+
"\u1594\u150a\u0001\u0000\u0000\u0000\u1594\u1511\u0001\u0000\u0000\u0000"+
"\u1594\u1521\u0001\u0000\u0000\u0000\u1594\u152b\u0001\u0000\u0000\u0000"+
"\u1594\u1532\u0001\u0000\u0000\u0000\u1594\u1539\u0001\u0000\u0000\u0000"+
"\u1594\u153c\u0001\u0000\u0000\u0000\u1594\u1544\u0001\u0000\u0000\u0000"+
"\u1594\u154e\u0001\u0000\u0000\u0000\u1594\u1555\u0001\u0000\u0000\u0000"+
"\u1594\u155d\u0001\u0000\u0000\u0000\u1594\u1565\u0001\u0000\u0000\u0000"+
"\u1594\u156c\u0001\u0000\u0000\u0000\u1594\u1573\u0001\u0000\u0000\u0000"+
"\u1594\u1585\u0001\u0000\u0000\u0000\u1594\u158d\u0001\u0000\u0000\u0000"+
"\u1595\u017f\u0001\u0000\u0000\u0000\u1596\u1597\u0005\u00ca\u0000\u0000"+
"\u1597\u1598\u0005\u026e\u0000\u0000\u1598\u159a\u0003\u0250\u0128\u0000"+
"\u1599\u159b\u0003\u01ae\u00d7\u0000\u159a\u1599\u0001\u0000\u0000\u0000"+
"\u159a\u159b\u0001\u0000\u0000\u0000\u159b\u159d\u0001\u0000\u0000\u0000"+
"\u159c\u159e\u0003\u023a\u011d\u0000\u159d\u159c\u0001\u0000\u0000\u0000"+
"\u159d\u159e\u0001\u0000\u0000\u0000\u159e\u15a3\u0001\u0000\u0000\u0000"+
"\u159f\u15a0\u0005\u02aa\u0000\u0000\u15a0\u15a2\u0003\u0182\u00c1\u0000"+
"\u15a1\u159f\u0001\u0000\u0000\u0000\u15a2\u15a5\u0001\u0000\u0000\u0000"+
"\u15a3\u15a1\u0001\u0000\u0000\u0000\u15a3\u15a4\u0001\u0000\u0000\u0000"+
"\u15a4\u15a7\u0001\u0000\u0000\u0000\u15a5\u15a3\u0001\u0000\u0000\u0000"+
"\u15a6\u15a8\u0003\u0244\u0122\u0000\u15a7\u15a6\u0001\u0000\u0000\u0000"+
"\u15a7\u15a8\u0001\u0000\u0000\u0000\u15a8\u1631\u0001\u0000\u0000\u0000"+
"\u15a9\u15aa\u0005\u00ca\u0000\u0000\u15aa\u15ab\u0005\u0125\u0000\u0000"+
"\u15ab\u15b0\u0003\u0250\u0128\u0000\u15ac\u15ad\u0005\u02aa\u0000\u0000"+
"\u15ad\u15af\u0003\u0182\u00c1\u0000\u15ae\u15ac\u0001\u0000\u0000\u0000"+
"\u15af\u15b2\u0001\u0000\u0000\u0000\u15b0\u15ae\u0001\u0000\u0000\u0000"+
"\u15b0\u15b1\u0001\u0000\u0000\u0000\u15b1\u15b4\u0001\u0000\u0000\u0000"+
"\u15b2\u15b0\u0001\u0000\u0000\u0000\u15b3\u15b5\u0003\u0244\u0122\u0000"+
"\u15b4\u15b3\u0001\u0000\u0000\u0000\u15b4\u15b5\u0001\u0000\u0000\u0000"+
"\u15b5\u1631\u0001\u0000\u0000\u0000\u15b6\u15b7\u0005\u00c9\u0000\u0000"+
"\u15b7\u15b8\u0005\u026e\u0000\u0000\u15b8\u15b9\u0003\u0250\u0128\u0000"+
"\u15b9\u15ba\u0005\u0250\u0000\u0000\u15ba\u15bb\u0005\u0261\u0000\u0000"+
"\u15bb\u15bc\u0005\u00b6\u0000\u0000\u15bc\u15bd\u0003\u0246\u0123\u0000"+
"\u15bd\u15bf\u0005\u00b7\u0000\u0000\u15be\u15c0\u0003\u01ae\u00d7\u0000"+
"\u15bf\u15be\u0001\u0000\u0000\u0000\u15bf\u15c0\u0001\u0000\u0000\u0000"+
"\u15c0\u1631\u0001\u0000\u0000\u0000\u15c1\u15c2\u0005\u00c9\u0000\u0000"+
"\u15c2\u15c3\u0005\u026e\u0000\u0000\u15c3\u15c6\u0003\u0250\u0128\u0000"+
"\u15c4\u15c5\u0005\u0193\u0000\u0000\u15c5\u15c7\u0003\u02ca\u0165\u0000"+
"\u15c6\u15c4\u0001\u0000\u0000\u0000\u15c6\u15c7\u0001\u0000\u0000\u0000"+
"\u15c7\u15c8\u0001\u0000\u0000\u0000\u15c8\u15c9\u0005\u01db\u0000\u0000"+
"\u15c9\u15ca\u0005\u0105\u0000\u0000\u15ca\u15cb\u0003\u02ca\u0165\u0000"+
"\u15cb\u15cc\u0005\u0250\u0000\u0000\u15cc\u15cd\u0005\u0261\u0000\u0000"+
"\u15cd\u15ce\u0005\u00b6\u0000\u0000\u15ce\u15cf\u0003\u0246\u0123\u0000"+
"\u15cf\u15d1\u0005\u00b7\u0000\u0000\u15d0\u15d2\u0003\u01ae\u00d7\u0000"+
"\u15d1\u15d0\u0001\u0000\u0000\u0000\u15d1\u15d2\u0001\u0000\u0000\u0000"+
"\u15d2\u1631\u0001\u0000\u0000\u0000\u15d3\u15d4\u0005\u0144\u0000\u0000"+
"\u15d4\u15d5\u0005\u0261\u0000\u0000\u15d5\u15d7\u0003\u0250\u0128\u0000"+
"\u15d6\u15d8\u0003\u023a\u011d\u0000\u15d7\u15d6\u0001\u0000\u0000\u0000"+
"\u15d7\u15d8\u0001\u0000\u0000\u0000\u15d8\u15da\u0001\u0000\u0000\u0000"+
"\u15d9\u15db\u0003\u01ae\u00d7\u0000\u15da\u15d9\u0001\u0000\u0000\u0000"+
"\u15da\u15db\u0001\u0000\u0000\u0000\u15db\u1631\u0001\u0000\u0000\u0000"+
"\u15dc\u15dd\u0005\u0144\u0000\u0000\u15dd\u15de\u0005\u00f3\u0000\u0000"+
"\u15de\u15df\u0005\u0261\u0000\u0000\u15df\u1631\u0003\u0250\u0128\u0000"+
"\u15e0\u15e1\u0005\u0144\u0000\u0000\u15e1\u15e2\u0005\u015c\u0000\u0000"+
"\u15e2\u1631\u0005\u0261\u0000\u0000\u15e3\u15e4\u0005\u0144\u0000\u0000"+
"\u15e4\u15e5\u0005\u00ca\u0000\u0000\u15e5\u15e6\u0005\u01a7\u0000\u0000"+
"\u15e6\u1631\u0005\u02cf\u0000\u0000\u15e7\u15e8\u0005\u01ae\u0000\u0000"+
"\u15e8\u15e9\u0005\u00ca\u0000\u0000\u15e9\u1631\u0005\u02cf\u0000\u0000"+
"\u15ea\u15eb\u0005\u0254\u0000\u0000\u15eb\u15ec\u0005\u026e\u0000\u0000"+
"\u15ec\u15ed\u0005\u0261\u0000\u0000\u15ed\u15ef\u0003\u0250\u0128\u0000"+
"\u15ee\u15f0\u0003\u01ae\u00d7\u0000\u15ef\u15ee\u0001\u0000\u0000\u0000"+
"\u15ef\u15f0\u0001\u0000\u0000\u0000\u15f0\u15f2\u0001\u0000\u0000\u0000"+
"\u15f1\u15f3\u0003\u023a\u011d\u0000\u15f2\u15f1\u0001\u0000\u0000\u0000"+
"\u15f2\u15f3\u0001\u0000\u0000\u0000\u15f3\u1631\u0001\u0000\u0000\u0000"+
"\u15f4\u15f5\u0005\u0254\u0000\u0000\u15f5\u15f6\u0005\u026e\u0000\u0000"+
"\u15f6\u15f7\u0005\u0261\u0000\u0000\u15f7\u1631\u0005\u02cf\u0000\u0000"+
"\u15f8\u15f9\u0005\u0254\u0000\u0000\u15f9\u15fa\u0005\u0193\u0000\u0000"+
"\u15fa\u15fb\u0005\u0261\u0000\u0000\u15fb\u15fc\u0003\u0250\u0128\u0000"+
"\u15fc\u15fd\u0003\u02ca\u0165\u0000\u15fd\u1631\u0001\u0000\u0000\u0000"+
"\u15fe\u15ff\u0005\u0254\u0000\u0000\u15ff\u1601\u0005\u0105\u0000\u0000"+
"\u1600\u1602\u0005\u00f3\u0000\u0000\u1601\u1600\u0001\u0000\u0000\u0000"+
"\u1601\u1602\u0001\u0000\u0000\u0000\u1602\u1603\u0001\u0000\u0000\u0000"+
"\u1603\u1604\u0005\u0261\u0000\u0000\u1604\u1606\u0003\u0250\u0128\u0000"+
"\u1605\u1607\u0003\u023a\u011d\u0000\u1606\u1605\u0001\u0000\u0000\u0000"+
"\u1606\u1607\u0001\u0000\u0000\u0000\u1607\u1609\u0001\u0000\u0000\u0000"+
"\u1608\u160a\u0003\u01ae\u00d7\u0000\u1609\u1608\u0001\u0000\u0000\u0000"+
"\u1609\u160a\u0001\u0000\u0000\u0000\u160a\u1631\u0001\u0000\u0000\u0000"+
"\u160b\u160c\u0005\u0254\u0000\u0000\u160c\u160d\u0005\u0105\u0000\u0000"+
"\u160d\u160e\u0005\u0185\u0000\u0000\u160e\u160f\u0003\u0250\u0128\u0000"+
"\u160f\u1610\u0003\u023a\u011d\u0000\u1610\u1631\u0001\u0000\u0000\u0000"+
"\u1611\u1613\u0005\u0254\u0000\u0000\u1612\u1614\u0005\u00d5\u0000\u0000"+
"\u1613\u1612\u0001\u0000\u0000\u0000\u1613\u1614\u0001\u0000\u0000\u0000"+
"\u1614\u1615\u0001\u0000\u0000\u0000\u1615\u1617\u0005\u00ca\u0000\u0000"+
"\u1616\u1618\u0003\u0250\u0128\u0000\u1617\u1616\u0001\u0000\u0000\u0000"+
"\u1617\u1618\u0001\u0000\u0000\u0000\u1618\u161a\u0001\u0000\u0000\u0000"+
"\u1619\u161b\u0003\u0150\u00a8\u0000\u161a\u1619\u0001\u0000\u0000\u0000"+
"\u161a\u161b\u0001\u0000\u0000\u0000\u161b\u1631\u0001\u0000\u0000\u0000"+
"\u161c\u161d\u0005\u0254\u0000\u0000\u161d\u161e\u0005\u00ca\u0000\u0000"+
"\u161e\u1620\u0005\u02cf\u0000\u0000\u161f\u1621\u0003\u0150\u00a8\u0000"+
"\u1620\u161f\u0001\u0000\u0000\u0000\u1620\u1621\u0001\u0000\u0000\u0000"+
"\u1621\u1631\u0001\u0000\u0000\u0000\u1622\u1623\u0005\u0254\u0000\u0000"+
"\u1623\u1624\u0005\u00d5\u0000\u0000\u1624\u1626\u0005\u01a8\u0000\u0000"+
"\u1625\u1627\u0003\u0250\u0128\u0000\u1626\u1625\u0001\u0000\u0000\u0000"+
"\u1626\u1627\u0001\u0000\u0000\u0000\u1627\u1629\u0001\u0000\u0000\u0000"+
"\u1628\u162a\u0003\u0150\u00a8\u0000\u1629\u1628\u0001\u0000\u0000\u0000"+
"\u1629\u162a\u0001\u0000\u0000\u0000\u162a\u1631\u0001\u0000\u0000\u0000"+
"\u162b\u162c\u0005\u0254\u0000\u0000\u162c\u162d\u0005\u00ca\u0000\u0000"+
"\u162d\u162e\u0005\u0274\u0000\u0000\u162e\u162f\u0005\u0262\u0000\u0000"+
"\u162f\u1631\u0005\u02cf\u0000\u0000\u1630\u1596\u0001\u0000\u0000\u0000"+
"\u1630\u15a9\u0001\u0000\u0000\u0000\u1630\u15b6\u0001\u0000\u0000\u0000"+
"\u1630\u15c1\u0001\u0000\u0000\u0000\u1630\u15d3\u0001\u0000\u0000\u0000"+
"\u1630\u15dc\u0001\u0000\u0000\u0000\u1630\u15e0\u0001\u0000\u0000\u0000"+
"\u1630\u15e3\u0001\u0000\u0000\u0000\u1630\u15e7\u0001\u0000\u0000\u0000"+
"\u1630\u15ea\u0001\u0000\u0000\u0000\u1630\u15f4\u0001\u0000\u0000\u0000"+
"\u1630\u15f8\u0001\u0000\u0000\u0000\u1630\u15fe\u0001\u0000\u0000\u0000"+
"\u1630\u160b\u0001\u0000\u0000\u0000\u1630\u1611\u0001\u0000\u0000\u0000"+
"\u1630\u161c\u0001\u0000\u0000\u0000\u1630\u1622\u0001\u0000\u0000\u0000"+
"\u1630\u162b\u0001\u0000\u0000\u0000\u1631\u0181\u0001\u0000\u0000\u0000"+
"\u1632\u1645\u0005\u026c\u0000\u0000\u1633\u1645\u0005\u0192\u0000\u0000"+
"\u1634\u1645\u0005\u0175\u0000\u0000\u1635\u1645\u0005\u0086\u0000\u0000"+
"\u1636\u1645\u0005\u0185\u0000\u0000\u1637\u163c\u0005\u0245\u0000\u0000"+
"\u1638\u1639\u0005\u0243\u0000\u0000\u1639\u163d\u0005\u02cf\u0000\u0000"+
"\u163a\u163b\u0005\u0202\u0000\u0000\u163b\u163d\u0005\u02cf\u0000\u0000"+
"\u163c\u1638\u0001\u0000\u0000\u0000\u163c\u163a\u0001\u0000\u0000\u0000"+
"\u163d\u1645\u0001\u0000\u0000\u0000\u163e\u163f\u0005\u00ed\u0000\u0000"+
"\u163f\u1645\u0005\u02cf\u0000\u0000\u1640\u1641\u0005\u0203\u0000\u0000"+
"\u1641\u1645\u0005\u02cf\u0000\u0000\u1642\u1643\u0005\u011b\u0000\u0000"+
"\u1643\u1645\u0005\u02ca\u0000\u0000\u1644\u1632\u0001\u0000\u0000\u0000"+
"\u1644\u1633\u0001\u0000\u0000\u0000\u1644\u1634\u0001\u0000\u0000\u0000"+
"\u1644\u1635\u0001\u0000\u0000\u0000\u1644\u1636\u0001\u0000\u0000\u0000"+
"\u1644\u1637\u0001\u0000\u0000\u0000\u1644\u163e\u0001\u0000\u0000\u0000"+
"\u1644\u1640\u0001\u0000\u0000\u0000\u1644\u1642\u0001\u0000\u0000\u0000"+
"\u1645\u0183\u0001\u0000\u0000\u0000\u1646\u1647\u0005\u0119\u0000\u0000"+
"\u1647\u164b\u0007,\u0000\u0000\u1648\u1649\u0005\u018e\u0000\u0000\u1649"+
"\u164a\u0005\u01e7\u0000\u0000\u164a\u164c\u0005\u015b\u0000\u0000\u164b"+
"\u1648\u0001\u0000\u0000\u0000\u164b\u164c\u0001\u0000\u0000\u0000\u164c"+
"\u164d\u0001\u0000\u0000\u0000\u164d\u164f\u0003\u0250\u0128\u0000\u164e"+
"\u1650\u0003\u0244\u0122\u0000\u164f\u164e\u0001\u0000\u0000\u0000\u164f"+
"\u1650\u0001\u0000\u0000\u0000\u1650\u1759\u0001\u0000\u0000\u0000\u1651"+
"\u1652\u0005\u0119\u0000\u0000\u1652\u1656\u0005\u00f8\u0000\u0000\u1653"+
"\u1654\u0005\u018e\u0000\u0000\u1654\u1655\u0005\u01e7\u0000\u0000\u1655"+
"\u1657\u0005\u015b\u0000\u0000\u1656\u1653\u0001\u0000\u0000\u0000\u1656"+
"\u1657\u0001\u0000\u0000\u0000\u1657\u1658\u0001\u0000\u0000\u0000\u1658"+
"\u165c\u0003\u02ca\u0165\u0000\u1659\u165a\u0005\u02aa\u0000\u0000\u165a"+
"\u165b\u0005\u0231\u0000\u0000\u165b\u165d\u0003\u02ca\u0165\u0000\u165c"+
"\u1659\u0001\u0000\u0000\u0000\u165c\u165d\u0001\u0000\u0000\u0000\u165d"+
"\u1660\u0001\u0000\u0000\u0000\u165e\u165f\u0005\u0107\u0000\u0000\u165f"+
"\u1661\u0005\u02ca\u0000\u0000\u1660\u165e\u0001\u0000\u0000\u0000\u1660"+
"\u1661\u0001\u0000\u0000\u0000\u1661\u1663\u0001\u0000\u0000\u0000\u1662"+
"\u1664\u0003\u0244\u0122\u0000\u1663\u1662\u0001\u0000\u0000\u0000\u1663"+
"\u1664\u0001\u0000\u0000\u0000\u1664\u1759\u0001\u0000\u0000\u0000\u1665"+
"\u1667\u0005\u0119\u0000\u0000\u1666\u1668\u0007\u0011\u0000\u0000\u1667"+
"\u1666\u0001\u0000\u0000\u0000\u1667\u1668\u0001\u0000\u0000\u0000\u1668"+
"\u166a\u0001\u0000\u0000\u0000\u1669\u166b\u00076\u0000\u0000\u166a\u1669"+
"\u0001\u0000\u0000\u0000\u166a\u166b\u0001\u0000\u0000\u0000\u166b\u166c"+
"\u0001\u0000\u0000\u0000\u166c\u1670\u0005\u0176\u0000\u0000\u166d\u166e"+
"\u0005\u018e\u0000\u0000\u166e\u166f\u0005\u01e7\u0000\u0000\u166f\u1671"+
"\u0005\u015b\u0000\u0000\u1670\u166d\u0001\u0000\u0000\u0000\u1670\u1671"+
"\u0001\u0000\u0000\u0000\u1671\u1672\u0001\u0000\u0000\u0000\u1672\u1673"+
"\u0003\u0290\u0148\u0000\u1673\u1675\u0005\u00b6\u0000\u0000\u1674\u1676"+
"\u0003\u0192\u00c9\u0000\u1675\u1674\u0001\u0000\u0000\u0000\u1675\u1676"+
"\u0001\u0000\u0000\u0000\u1676\u1677\u0001\u0000\u0000\u0000\u1677\u1678"+
"\u0005\u00b7\u0000\u0000\u1678\u1679\u0005\u0238\u0000\u0000\u1679\u167c"+
"\u0003\u02ae\u0157\u0000\u167a\u167b\u0005\u019b\u0000\u0000\u167b\u167d"+
"\u0003\u02ae\u0157\u0000\u167c\u167a\u0001\u0000\u0000\u0000\u167c\u167d"+
"\u0001\u0000\u0000\u0000\u167d\u167f\u0001\u0000\u0000\u0000\u167e\u1680"+
"\u0003\u0244\u0122\u0000\u167f\u167e\u0001\u0000\u0000\u0000\u167f\u1680"+
"\u0001\u0000\u0000\u0000\u1680\u1759\u0001\u0000\u0000\u0000\u1681\u1683"+
"\u0005\u0119\u0000\u0000\u1682\u1684\u0007\u0011\u0000\u0000\u1683\u1682"+
"\u0001\u0000\u0000\u0000\u1683\u1684\u0001\u0000\u0000\u0000\u1684\u1685"+
"\u0001\u0000\u0000\u0000\u1685\u1686\u0005\u00c7\u0000\u0000\u1686\u168a"+
"\u0005\u0176\u0000\u0000\u1687\u1688\u0005\u018e\u0000\u0000\u1688\u1689"+
"\u0005\u01e7\u0000\u0000\u1689\u168b\u0005\u015b\u0000\u0000\u168a\u1687"+
"\u0001\u0000\u0000\u0000\u168a\u168b\u0001\u0000\u0000\u0000\u168b\u168c"+
"\u0001\u0000\u0000\u0000\u168c\u168d\u0003\u0290\u0148\u0000\u168d\u168f"+
"\u0005\u00b6\u0000\u0000\u168e\u1690\u0003\u0192\u00c9\u0000\u168f\u168e"+
"\u0001\u0000\u0000\u0000\u168f\u1690\u0001\u0000\u0000\u0000\u1690\u1691"+
"\u0001\u0000\u0000\u0000\u1691\u1692\u0005\u00b7\u0000\u0000\u1692\u1693"+
"\u0005\u02aa\u0000\u0000\u1693\u1694\u0005\u01f7\u0000\u0000\u1694\u1696"+
"\u0005\u00b6\u0000\u0000\u1695\u1697\u0003\u023c\u011e\u0000\u1696\u1695"+
"\u0001\u0000\u0000\u0000\u1696\u1697\u0001\u0000\u0000\u0000\u1697\u1698"+
"\u0001\u0000\u0000\u0000\u1698\u1699\u0005\u00b7\u0000\u0000\u1699\u169a"+
"\u0005\u00d1\u0000\u0000\u169a\u169b\u0003\u027c\u013e\u0000\u169b\u1759"+
"\u0001\u0000\u0000\u0000\u169c\u169d\u0005\u0119\u0000\u0000\u169d\u16a1"+
"\u0005\u0296\u0000\u0000\u169e\u169f\u0005\u018e\u0000\u0000\u169f\u16a0"+
"\u0005\u01e7\u0000\u0000\u16a0\u16a2\u0005\u015b\u0000\u0000\u16a1\u169e"+
"\u0001\u0000\u0000\u0000\u16a1\u16a2\u0001\u0000\u0000\u0000\u16a2\u16a3"+
"\u0001\u0000\u0000\u0000\u16a3\u16a8\u0003\u01cc\u00e6\u0000\u16a4\u16a9"+
"\u0005\u026a\u0000\u0000\u16a5\u16a6\u0005\u0132\u0000\u0000\u16a6\u16a7"+
"\u0005\u023d\u0000\u0000\u16a7\u16a9\u0005\u02ca\u0000\u0000\u16a8\u16a4"+
"\u0001\u0000\u0000\u0000\u16a8\u16a5\u0001\u0000\u0000\u0000\u16a8\u16a9"+
"\u0001\u0000\u0000\u0000\u16a9\u16aa\u0001\u0000\u0000\u0000\u16aa\u16ad"+
"\u0003\u0190\u00c8\u0000\u16ab\u16ac\u0005\u0107\u0000\u0000\u16ac\u16ae"+
"\u0005\u02ca\u0000\u0000\u16ad\u16ab\u0001\u0000\u0000\u0000\u16ad\u16ae"+
"\u0001\u0000\u0000\u0000\u16ae\u1759\u0001\u0000\u0000\u0000\u16af\u16b2"+
"\u0005\u0119\u0000\u0000\u16b0\u16b1\u0005\u021e\u0000\u0000\u16b1\u16b3"+
"\u0005\u01ee\u0000\u0000\u16b2\u16b0\u0001\u0000\u0000\u0000\u16b2\u16b3"+
"\u0001\u0000\u0000\u0000\u16b3\u16b4\u0001\u0000\u0000\u0000\u16b4\u16b5"+
"\u0005\u0230\u0000\u0000\u16b5\u16b6\u0003\u02ca\u0165\u0000\u16b6\u16b7"+
"\u0005\u02aa\u0000\u0000\u16b7\u16b8\u0003\u018e\u00c7\u0000\u16b8\u1759"+
"\u0001\u0000\u0000\u0000\u16b9\u16ba\u0005\u0119\u0000\u0000\u16ba\u16be"+
"\u0005\u023d\u0000\u0000\u16bb\u16bc\u0005\u018e\u0000\u0000\u16bc\u16bd"+
"\u0005\u01e7\u0000\u0000\u16bd\u16bf\u0005\u015b\u0000\u0000\u16be\u16bb"+
"\u0001\u0000\u0000\u0000\u16be\u16bf\u0001\u0000\u0000\u0000\u16bf\u16c0"+
"\u0001\u0000\u0000\u0000\u16c0\u16c3\u0003\u02ca\u0165\u0000\u16c1\u16c2"+
"\u0005\u0107\u0000\u0000\u16c2\u16c4\u0005\u02ca\u0000\u0000\u16c3\u16c1"+
"\u0001\u0000\u0000\u0000\u16c3\u16c4\u0001\u0000\u0000\u0000\u16c4\u1759"+
"\u0001\u0000\u0000\u0000\u16c5\u16c6\u0005\u0119\u0000\u0000\u16c6\u16c7"+
"\u0005\u0167\u0000\u0000\u16c7\u16ca\u0005\u02ca\u0000\u0000\u16c8\u16c9"+
"\u0007(\u0000\u0000\u16c9\u16cb\u0003\u02ca\u0165\u0000\u16ca\u16c8\u0001"+
"\u0000\u0000\u0000\u16ca\u16cb\u0001\u0000\u0000\u0000\u16cb\u16cc\u0001"+
"\u0000\u0000\u0000\u16cc\u1759\u0003\u0244\u0122\u0000\u16cd\u16ce\u0005"+
"\u0119\u0000\u0000\u16ce\u16d2\u0005\u0193\u0000\u0000\u16cf\u16d0\u0005"+
"\u018e\u0000\u0000\u16d0\u16d1\u0005\u01e7\u0000\u0000\u16d1\u16d3\u0005"+
"\u015b\u0000\u0000\u16d2\u16cf\u0001\u0000\u0000\u0000\u16d2\u16d3\u0001"+
"\u0000\u0000\u0000\u16d3\u16d4\u0001\u0000\u0000\u0000\u16d4\u16d5\u0003"+
"\u02ca\u0165\u0000\u16d5\u16d6\u0005\u01ed\u0000\u0000\u16d6\u16d7\u0003"+
"\u0250\u0128\u0000\u16d7\u16da\u0003\u023a\u011d\u0000\u16d8\u16d9\u0005"+
"\u0297\u0000\u0000\u16d9\u16db\u00077\u0000\u0000\u16da\u16d8\u0001\u0000"+
"\u0000\u0000\u16da\u16db\u0001\u0000\u0000\u0000\u16db\u16dd\u0001\u0000"+
"\u0000\u0000\u16dc\u16de\u0003\u0244\u0122\u0000\u16dd\u16dc\u0001\u0000"+
"\u0000\u0000\u16dd\u16de\u0001\u0000\u0000\u0000\u16de\u16e1\u0001\u0000"+
"\u0000\u0000\u16df\u16e0\u0005\u0107\u0000\u0000\u16e0\u16e2\u0005\u02ca"+
"\u0000\u0000\u16e1\u16df\u0001\u0000\u0000\u0000\u16e1\u16e2\u0001\u0000"+
"\u0000\u0000\u16e2\u1759\u0001\u0000\u0000\u0000\u16e3\u16e5\u0005\u0119"+
"\u0000\u0000\u16e4\u16e6\u0005\u0160\u0000\u0000\u16e5\u16e4\u0001\u0000"+
"\u0000\u0000\u16e5\u16e6\u0001\u0000\u0000\u0000\u16e6\u16e7\u0001\u0000"+
"\u0000\u0000\u16e7\u16eb\u0005\u0231\u0000\u0000\u16e8\u16e9\u0005\u018e"+
"\u0000\u0000\u16e9\u16ea\u0005\u01e7\u0000\u0000\u16ea\u16ec\u0005\u015b"+
"\u0000\u0000\u16eb\u16e8\u0001\u0000\u0000\u0000\u16eb\u16ec\u0001\u0000"+
"\u0000\u0000\u16ec\u16ed\u0001\u0000\u0000\u0000\u16ed\u16ef\u0003\u01c2"+
"\u00e1\u0000\u16ee\u16f0\u0003\u0244\u0122\u0000\u16ef\u16ee\u0001\u0000"+
"\u0000\u0000\u16ef\u16f0\u0001\u0000\u0000\u0000\u16f0\u1759\u0001\u0000"+
"\u0000\u0000\u16f1\u16f2\u0005\u0119\u0000\u0000\u16f2\u16f3\u0005\u0264"+
"\u0000\u0000\u16f3\u16f7\u0005\u029e\u0000\u0000\u16f4\u16f5\u0005\u018e"+
"\u0000\u0000\u16f5\u16f6\u0005\u01e7\u0000\u0000\u16f6\u16f8\u0005\u015b"+
"\u0000\u0000\u16f7\u16f4\u0001\u0000\u0000\u0000\u16f7\u16f8\u0001\u0000"+
"\u0000\u0000\u16f8\u16f9\u0001\u0000\u0000\u0000\u16f9\u16fb\u0003\u01c2"+
"\u00e1\u0000\u16fa\u16fc\u0003\u0244\u0122\u0000\u16fb\u16fa\u0001\u0000"+
"\u0000\u0000\u16fb\u16fc\u0001\u0000\u0000\u0000\u16fc\u1759\u0001\u0000"+
"\u0000\u0000\u16fd\u16fe\u0005\u0119\u0000\u0000\u16fe\u16ff\u0005\u02ac"+
"\u0000\u0000\u16ff\u1703\u0005\u017e\u0000\u0000\u1700\u1701\u0005\u018e"+
"\u0000\u0000\u1701\u1702\u0005\u01e7\u0000\u0000\u1702\u1704\u0005\u015b"+
"\u0000\u0000\u1703\u1700\u0001\u0000\u0000\u0000\u1703\u1704\u0001\u0000"+
"\u0000\u0000\u1704\u1705\u0001\u0000\u0000\u0000\u1705\u1707\u0003\u01c2"+
"\u00e1\u0000\u1706\u1708\u0003\u0244\u0122\u0000\u1707\u1706\u0001\u0000"+
"\u0000\u0000\u1707\u1708\u0001\u0000\u0000\u0000\u1708\u1759\u0001\u0000"+
"\u0000\u0000\u1709\u170a\u0005\u0119\u0000\u0000\u170a\u170b\u0005\u02ac"+
"\u0000\u0000\u170b\u170f\u0005\u020e\u0000\u0000\u170c\u170d\u0005\u018e"+
"\u0000\u0000\u170d\u170e\u0005\u01e7\u0000\u0000\u170e\u1710\u0005\u015b"+
"\u0000\u0000\u170f\u170c\u0001\u0000\u0000\u0000\u170f\u1710\u0001\u0000"+
"\u0000\u0000\u1710\u1711\u0001\u0000\u0000\u0000\u1711\u1717\u0003\u01c2"+
"\u00e1\u0000\u1712\u1713\u0005\u010e\u0000\u0000\u1713\u1714\u0005\u00b6"+
"\u0000\u0000\u1714\u1715\u0003\u018a\u00c5\u0000\u1715\u1716\u0005\u00b7"+
"\u0000\u0000\u1716\u1718\u0001\u0000\u0000\u0000\u1717\u1712\u0001\u0000"+
"\u0000\u0000\u1717\u1718\u0001\u0000\u0000\u0000\u1718\u171e\u0001\u0000"+
"\u0000\u0000\u1719\u171a\u0005\u00c1\u0000\u0000\u171a\u171b\u0005\u00b6"+
"\u0000\u0000\u171b\u171c\u0003\u0186\u00c3\u0000\u171c\u171d\u0005\u00b7"+
"\u0000\u0000\u171d\u171f\u0001\u0000\u0000\u0000\u171e\u1719\u0001\u0000"+
"\u0000\u0000\u171e\u171f\u0001\u0000\u0000\u0000\u171f\u1721\u0001\u0000"+
"\u0000\u0000\u1720\u1722\u0003\u0244\u0122\u0000\u1721\u1720\u0001\u0000"+
"\u0000\u0000\u1721\u1722\u0001\u0000\u0000\u0000\u1722\u1759\u0001\u0000"+
"\u0000\u0000\u1723\u1724\u0005\u0119\u0000\u0000\u1724\u1728\u0005\u014d"+
"\u0000\u0000\u1725\u1726\u0005\u018e\u0000\u0000\u1726\u1727\u0005\u01e7"+
"\u0000\u0000\u1727\u1729\u0005\u015b\u0000\u0000\u1728\u1725\u0001\u0000"+
"\u0000\u0000\u1728\u1729\u0001\u0000\u0000\u0000\u1729\u172a\u0001\u0000"+
"\u0000\u0000\u172a\u172b\u0003\u0250\u0128\u0000\u172b\u172c\u0005\u00d1"+
"\u0000\u0000\u172c\u172d\u0005\u02ca\u0000\u0000\u172d\u1759\u0001\u0000"+
"\u0000\u0000\u172e\u172f\u0005\u0119\u0000\u0000\u172f\u1733\u0005\u025c"+
"\u0000\u0000\u1730\u1731\u0005\u018e\u0000\u0000\u1731\u1732\u0005\u01e7"+
"\u0000\u0000\u1732\u1734\u0005\u015b\u0000\u0000\u1733\u1730\u0001\u0000"+
"\u0000\u0000\u1733\u1734\u0001\u0000\u0000\u0000\u1734\u1735\u0001\u0000"+
"\u0000\u0000\u1735\u1737\u0003\u02ca\u0165\u0000\u1736\u1738\u0003\u0244"+
"\u0122\u0000\u1737\u1736\u0001\u0000\u0000\u0000\u1737\u1738\u0001\u0000"+
"\u0000\u0000\u1738\u1759\u0001\u0000\u0000\u0000\u1739\u173a\u0005\u0119"+
"\u0000\u0000\u173a\u173b\u0005\u0264\u0000\u0000\u173b\u173f\u0005\u020e"+
"\u0000\u0000\u173c\u173d\u0005\u018e\u0000\u0000\u173d\u173e\u0005\u01e7"+
"\u0000\u0000\u173e\u1740\u0005\u015b\u0000\u0000\u173f\u173c\u0001\u0000"+
"\u0000\u0000\u173f\u1740\u0001\u0000\u0000\u0000\u1740\u1741\u0001\u0000"+
"\u0000\u0000\u1741\u1743\u0003\u02ca\u0165\u0000\u1742\u1744\u0003\u0244"+
"\u0122\u0000\u1743\u1742\u0001\u0000\u0000\u0000\u1743\u1744\u0001\u0000"+
"\u0000\u0000\u1744\u1759\u0001\u0000\u0000\u0000\u1745\u1746\u0005\u00ee"+
"\u0000\u0000\u1746\u1747\u0005\u0193\u0000\u0000\u1747\u1748\u0003\u02ca"+
"\u0165\u0000\u1748\u1749\u0005\u01ed\u0000\u0000\u1749\u174b\u0003\u0250"+
"\u0128\u0000\u174a\u174c\u0003\u01ae\u00d7\u0000\u174b\u174a\u0001\u0000"+
"\u0000\u0000\u174b\u174c\u0001\u0000\u0000\u0000\u174c\u1759\u0001\u0000"+
"\u0000\u0000\u174d\u174e\u0005\u0119\u0000\u0000\u174e\u1752\u0005\u025d"+
"\u0000\u0000\u174f\u1750\u0005\u018e\u0000\u0000\u1750\u1751\u0005\u01e7"+
"\u0000\u0000\u1751\u1753\u0005\u015b\u0000\u0000\u1752\u174f\u0001\u0000"+
"\u0000\u0000\u1752\u1753\u0001\u0000\u0000\u0000\u1753\u1754\u0001\u0000"+
"\u0000\u0000\u1754\u1756\u0003\u02ca\u0165\u0000\u1755\u1757\u0003\u0244"+
"\u0122\u0000\u1756\u1755\u0001\u0000\u0000\u0000\u1756\u1757\u0001\u0000"+
"\u0000\u0000\u1757\u1759\u0001\u0000\u0000\u0000\u1758\u1646\u0001\u0000"+
"\u0000\u0000\u1758\u1651\u0001\u0000\u0000\u0000\u1758\u1665\u0001\u0000"+
"\u0000\u0000\u1758\u1681\u0001\u0000\u0000\u0000\u1758\u169c\u0001\u0000"+
"\u0000\u0000\u1758\u16af\u0001\u0000\u0000\u0000\u1758\u16b9\u0001\u0000"+
"\u0000\u0000\u1758\u16c5\u0001\u0000\u0000\u0000\u1758\u16cd\u0001\u0000"+
"\u0000\u0000\u1758\u16e3\u0001\u0000\u0000\u0000\u1758\u16f1\u0001\u0000"+
"\u0000\u0000\u1758\u16fd\u0001\u0000\u0000\u0000\u1758\u1709\u0001\u0000"+
"\u0000\u0000\u1758\u1723\u0001\u0000\u0000\u0000\u1758\u172e\u0001\u0000"+
"\u0000\u0000\u1758\u1739\u0001\u0000\u0000\u0000\u1758\u1745\u0001\u0000"+
"\u0000\u0000\u1758\u174d\u0001\u0000\u0000\u0000\u1759\u0185\u0001\u0000"+
"\u0000\u0000\u175a\u175f\u0003\u0188\u00c4\u0000\u175b\u175c\u0005\u00b8"+
"\u0000\u0000\u175c\u175e\u0003\u0188\u00c4\u0000\u175d\u175b\u0001\u0000"+
"\u0000\u0000\u175e\u1761\u0001\u0000\u0000\u0000\u175f\u175d\u0001\u0000"+
"\u0000\u0000\u175f\u1760\u0001\u0000\u0000\u0000\u1760\u0187\u0001\u0000"+
"\u0000\u0000\u1761\u175f\u0001\u0000\u0000\u0000\u1762\u1763\u0005\u0252"+
"\u0000\u0000\u1763\u1769\u0005\u02ca\u0000\u0000\u1764\u1766\u0003\u02ca"+
"\u0165\u0000\u1765\u1767\u0005\u02ca\u0000\u0000\u1766\u1765\u0001\u0000"+
"\u0000\u0000\u1766\u1767\u0001\u0000\u0000\u0000\u1767\u1769\u0001\u0000"+
"\u0000\u0000\u1768\u1762\u0001\u0000\u0000\u0000\u1768\u1764\u0001\u0000"+
"\u0000\u0000\u1769\u0189\u0001\u0000\u0000\u0000\u176a\u176f\u0003\u018c"+
"\u00c6\u0000\u176b\u176c\u0005\u00b8\u0000\u0000\u176c\u176e\u0003\u018c"+
"\u00c6\u0000\u176d\u176b\u0001\u0000\u0000\u0000\u176e\u1771\u0001\u0000"+
"\u0000\u0000\u176f\u176d\u0001\u0000\u0000\u0000\u176f\u1770\u0001\u0000"+
"\u0000\u0000\u1770\u018b\u0001\u0000\u0000\u0000\u1771\u176f\u0001\u0000"+
"\u0000\u0000\u1772\u1773\u0003\u02ca\u0165\u0000\u1773\u1776\u0003\u02a2"+
"\u0151\u0000\u1774\u1777\u0003\u02d0\u0168\u0000\u1775\u1777\u0005\u02ca"+
"\u0000\u0000\u1776\u1774\u0001\u0000\u0000\u0000\u1776\u1775\u0001\u0000"+
"\u0000\u0000\u1777\u018d\u0001\u0000\u0000\u0000\u1778\u177a\u00078\u0000"+
"\u0000\u1779\u177b\u0003\u02ca\u0165\u0000\u177a\u1779\u0001\u0000\u0000"+
"\u0000\u177a\u177b\u0001\u0000\u0000\u0000\u177b\u177c\u0001\u0000\u0000"+
"\u0000\u177c\u177d\u0005\u01ed\u0000\u0000\u177d\u177e\u0005\u01c1\u0000"+
"\u0000\u177e\u1780\u0005\u02ca\u0000\u0000\u177f\u1781\u0003\u0244\u0122"+
"\u0000\u1780\u177f\u0001\u0000\u0000\u0000\u1780\u1781\u0001\u0000\u0000"+
"\u0000\u1781\u018f\u0001\u0000\u0000\u0000\u1782\u1785\u0005\u01fd\u0000"+
"\u0000\u1783\u1786\u0005\u0132\u0000\u0000\u1784\u1786\u0005\u02cf\u0000"+
"\u0000\u1785\u1783\u0001\u0000\u0000\u0000\u1785\u1784\u0001\u0000\u0000"+
"\u0000\u1786\u1788\u0001\u0000\u0000\u0000\u1787\u1782\u0001\u0000\u0000"+
"\u0000\u1787\u1788\u0001\u0000\u0000\u0000\u1788\u1791\u0001\u0000\u0000"+
"\u0000\u1789\u178f\u0005\u01fc\u0000\u0000\u178a\u1790\u0005\u0132\u0000"+
"\u0000\u178b\u1790\u0005\u01e2\u0000\u0000\u178c\u178d\u0005\u019d\u0000"+
"\u0000\u178d\u178e\u0005\u02cf\u0000\u0000\u178e\u1790\u00079\u0000\u0000"+
"\u178f\u178a\u0001\u0000\u0000\u0000\u178f\u178b\u0001\u0000\u0000\u0000"+
"\u178f\u178c\u0001\u0000\u0000\u0000\u1790\u1792\u0001\u0000\u0000\u0000"+
"\u1791\u1789\u0001\u0000\u0000\u0000\u1791\u1792\u0001\u0000\u0000\u0000"+
"\u1792\u179a\u0001\u0000\u0000\u0000\u1793\u1794\u0005\u01ff\u0000\u0000"+
"\u1794\u1798\u0005\u019d\u0000\u0000\u1795\u1799\u0005\u0132\u0000\u0000"+
"\u1796\u1797\u0005\u02cf\u0000\u0000\u1797\u1799\u0005\u012d\u0000\u0000"+
"\u1798\u1795\u0001\u0000\u0000\u0000\u1798\u1796\u0001\u0000\u0000\u0000"+
"\u1799\u179b\u0001\u0000\u0000\u0000\u179a\u1793\u0001\u0000\u0000\u0000"+
"\u179a\u179b\u0001\u0000\u0000\u0000\u179b\u179e\u0001\u0000\u0000\u0000"+
"\u179c\u179d\u0005\u0162\u0000\u0000\u179d\u179f\u0005\u02cf\u0000\u0000"+
"\u179e\u179c\u0001\u0000\u0000\u0000\u179e\u179f\u0001\u0000\u0000\u0000"+
"\u179f\u17a6\u0001\u0000\u0000\u0000\u17a0\u17a4\u0005\u01fe\u0000\u0000"+
"\u17a1\u17a5\u0005\u028b\u0000\u0000\u17a2\u17a3\u0005\u02cf\u0000\u0000"+
"\u17a3\u17a5\u00079\u0000\u0000\u17a4\u17a1\u0001\u0000\u0000\u0000\u17a4"+
"\u17a2\u0001\u0000\u0000\u0000\u17a5\u17a7\u0001\u0000\u0000\u0000\u17a6"+
"\u17a0\u0001\u0000\u0000\u0000\u17a6\u17a7\u0001\u0000\u0000\u0000\u17a7"+
"\u17a9\u0001\u0000\u0000\u0000\u17a8\u17aa\u0007:\u0000\u0000\u17a9\u17a8"+
"\u0001\u0000\u0000\u0000\u17a9\u17aa\u0001\u0000\u0000\u0000\u17aa\u0191"+
"\u0001\u0000\u0000\u0000\u17ab\u17b0\u0003\u0194\u00ca\u0000\u17ac\u17ad"+
"\u0005\u00b8\u0000\u0000\u17ad\u17af\u0003\u0194\u00ca\u0000\u17ae\u17ac"+
"\u0001\u0000\u0000\u0000\u17af\u17b2\u0001\u0000\u0000\u0000\u17b0\u17ae"+
"\u0001\u0000\u0000\u0000\u17b0\u17b1\u0001\u0000\u0000\u0000\u17b1\u0193"+
"\u0001\u0000\u0000\u0000\u17b2\u17b0\u0001\u0000\u0000\u0000\u17b3\u17b6"+
"\u0005\u00ba\u0000\u0000\u17b4\u17b6\u0003\u02ae\u0157\u0000\u17b5\u17b3"+
"\u0001\u0000\u0000\u0000\u17b5\u17b4\u0001\u0000\u0000\u0000\u17b6\u0195"+
"\u0001\u0000\u0000\u0000\u17b7\u17ba\u0005\u0250\u0000\u0000\u17b8\u17bb"+
"\u0003\u0198\u00cc\u0000\u17b9\u17bb\u0003\u019a\u00cd\u0000\u17ba\u17b8"+
"\u0001\u0000\u0000\u0000\u17ba\u17b9\u0001\u0000\u0000\u0000\u17bb\u17c3"+
"\u0001\u0000\u0000\u0000\u17bc\u17bf\u0005\u00b8\u0000\u0000\u17bd\u17c0"+
"\u0003\u0198\u00cc\u0000\u17be\u17c0\u0003\u019a\u00cd\u0000\u17bf\u17bd"+
"\u0001\u0000\u0000\u0000\u17bf\u17be\u0001\u0000\u0000\u0000\u17c0\u17c2"+
"\u0001\u0000\u0000\u0000\u17c1\u17bc\u0001\u0000\u0000\u0000\u17c2\u17c5"+
"\u0001\u0000\u0000\u0000\u17c3\u17c1\u0001\u0000\u0000\u0000\u17c3\u17c4"+
"\u0001\u0000\u0000\u0000\u17c4\u17e6\u0001\u0000\u0000\u0000\u17c5\u17c3"+
"\u0001\u0000\u0000\u0000\u17c6\u17c7\u0005\u0250\u0000\u0000\u17c7\u17c8"+
"\u0003\u02ca\u0165\u0000\u17c8\u17c9\u0005\u00d1\u0000\u0000\u17c9\u17ca"+
"\u0005\u0132\u0000\u0000\u17ca\u17cb\u0005\u0264\u0000\u0000\u17cb\u17cc"+
"\u0005\u029e\u0000\u0000\u17cc\u17e6\u0001\u0000\u0000\u0000\u17cd\u17ce"+
"\u0005\u0250\u0000\u0000\u17ce\u17d1\u0005\u0217\u0000\u0000\u17cf\u17d0"+
"\u0005\u016d\u0000\u0000\u17d0\u17d2\u0003\u01c2\u00e1\u0000\u17d1\u17cf"+
"\u0001\u0000\u0000\u0000\u17d1\u17d2\u0001\u0000\u0000\u0000\u17d2\u17d3"+
"\u0001\u0000\u0000\u0000\u17d3\u17e6\u0003\u0246\u0123\u0000\u17d4\u17d6"+
"\u0005\u0250\u0000\u0000\u17d5\u17d7\u0007\u0011\u0000\u0000\u17d6\u17d5"+
"\u0001\u0000\u0000\u0000\u17d6\u17d7\u0001\u0000\u0000\u0000\u17d7\u17d8"+
"\u0001\u0000\u0000\u0000\u17d8\u17e3\u0005\u0281\u0000\u0000\u17d9\u17e4"+
"\u0003\u019e\u00cf\u0000\u17da\u17e4\u0003\u01a0\u00d0\u0000\u17db\u17dc"+
"\u0003\u019e\u00cf\u0000\u17dc\u17dd\u0005\u00b8\u0000\u0000\u17dd\u17de"+
"\u0003\u01a0\u00d0\u0000\u17de\u17e4\u0001\u0000\u0000\u0000\u17df\u17e0"+
"\u0003\u01a0\u00d0\u0000\u17e0\u17e1\u0005\u00b8\u0000\u0000\u17e1\u17e2"+
"\u0003\u019e\u00cf\u0000\u17e2\u17e4\u0001\u0000\u0000\u0000\u17e3\u17d9"+
"\u0001\u0000\u0000\u0000\u17e3\u17da\u0001\u0000\u0000\u0000\u17e3\u17db"+
"\u0001\u0000\u0000\u0000\u17e3\u17df\u0001\u0000\u0000\u0000\u17e4\u17e6"+
"\u0001\u0000\u0000\u0000\u17e5\u17b7\u0001\u0000\u0000\u0000\u17e5\u17c6"+
"\u0001\u0000\u0000\u0000\u17e5\u17cd\u0001\u0000\u0000\u0000\u17e5\u17d4"+
"\u0001\u0000\u0000\u0000\u17e6\u0197\u0001\u0000\u0000\u0000\u17e7\u17e8"+
"\u0007\u0011\u0000\u0000\u17e8\u17e9\u0003\u02ca\u0165\u0000\u17e9\u17ec"+
"\u0005\u02b0\u0000\u0000\u17ea\u17ed\u0003\u027c\u013e\u0000\u17eb\u17ed"+
"\u0005\u0132\u0000\u0000\u17ec\u17ea\u0001\u0000\u0000\u0000\u17ec\u17eb"+
"\u0001\u0000\u0000\u0000\u17ed\u0199\u0001\u0000\u0000\u0000\u17ee\u17ef"+
"\u0005\u01df\u0000\u0000\u17ef\u17f0\u0005\u02b0\u0000\u0000\u17f0\u181c"+
"\u0003\u027c\u013e\u0000\u17f1\u17f2\u0005\u00fb\u0000\u0000\u17f2\u17f5"+
"\u0005\u0250\u0000\u0000\u17f3\u17f5\u0005\u00fc\u0000\u0000\u17f4\u17f1"+
"\u0001\u0000\u0000\u0000\u17f4\u17f3\u0001\u0000\u0000\u0000\u17f5\u17f8"+
"\u0001\u0000\u0000\u0000\u17f6\u17f9\u0003\u01c2\u00e1\u0000\u17f7\u17f9"+
"\u0005\u0132\u0000\u0000\u17f8\u17f6\u0001\u0000\u0000\u0000\u17f8\u17f7"+
"\u0001\u0000\u0000\u0000\u17f9\u181c\u0001\u0000\u0000\u0000\u17fa\u17fd"+
"\u0005\u01df\u0000\u0000\u17fb\u17fe\u0003\u01c2\u00e1\u0000\u17fc\u17fe"+
"\u0005\u0132\u0000\u0000\u17fd\u17fb\u0001\u0000\u0000\u0000\u17fd\u17fc"+
"\u0001\u0000\u0000\u0000\u17fe\u1802\u0001\u0000\u0000\u0000\u17ff\u1800"+
"\u0005\u0101\u0000\u0000\u1800\u1803\u0003\u01c2\u00e1\u0000\u1801\u1803"+
"\u0005\u0132\u0000\u0000\u1802\u17ff\u0001\u0000\u0000\u0000\u1802\u1801"+
"\u0001\u0000\u0000\u0000\u1802\u1803\u0001\u0000\u0000\u0000\u1803\u181c"+
"\u0001\u0000\u0000\u0000\u1804\u1807\u0005\u01fb\u0000\u0000\u1805\u1806"+
"\u0005\u016d\u0000\u0000\u1806\u1808\u0003\u01ca\u00e5\u0000\u1807\u1805"+
"\u0001\u0000\u0000\u0000\u1807\u1808\u0001\u0000\u0000\u0000\u1808\u1809"+
"\u0001\u0000\u0000\u0000\u1809\u180f\u0005\u02b0\u0000\u0000\u180a\u1810"+
"\u0005\u02ca\u0000\u0000\u180b\u180c\u0005\u01fb\u0000\u0000\u180c\u180d"+
"\u0005\u00b6\u0000\u0000\u180d\u180e\u0005\u02ca\u0000\u0000\u180e\u1810"+
"\u0005\u00b7\u0000\u0000\u180f\u180a\u0001\u0000\u0000\u0000\u180f\u180b"+
"\u0001\u0000\u0000\u0000\u1810\u181c\u0001\u0000\u0000\u0000\u1811\u1812"+
"\u0005\u01b4\u0000\u0000\u1812\u1818\u0005\u02b0\u0000\u0000\u1813\u1819"+
"\u0005\u02ca\u0000\u0000\u1814\u1815\u0005\u01fb\u0000\u0000\u1815\u1816"+
"\u0005\u00b6\u0000\u0000\u1816\u1817\u0005\u02ca\u0000\u0000\u1817\u1819"+
"\u0005\u00b7\u0000\u0000\u1818\u1813\u0001\u0000\u0000\u0000\u1818\u1814"+
"\u0001\u0000\u0000\u0000\u1819\u181c\u0001\u0000\u0000\u0000\u181a\u181c"+
"\u0003\u019c\u00ce\u0000\u181b\u17ee\u0001\u0000\u0000\u0000\u181b\u17f4"+
"\u0001\u0000\u0000\u0000\u181b\u17fa\u0001\u0000\u0000\u0000\u181b\u1804"+
"\u0001\u0000\u0000\u0000\u181b\u1811\u0001\u0000\u0000\u0000\u181b\u181a"+
"\u0001\u0000\u0000\u0000\u181c\u019b\u0001\u0000\u0000\u0000\u181d\u1820"+
"\u0005\u02c9\u0000\u0000\u181e\u181f\u0007\u0011\u0000\u0000\u181f\u1821"+
"\u0005\u00b9\u0000\u0000\u1820\u181e\u0001\u0000\u0000\u0000\u1820\u1821"+
"\u0001\u0000\u0000\u0000\u1821\u1823\u0001\u0000\u0000\u0000\u1822\u181d"+
"\u0001\u0000\u0000\u0000\u1822\u1823\u0001\u0000\u0000\u0000\u1823\u1824"+
"\u0001\u0000\u0000\u0000\u1824\u1825\u0003\u02ca\u0165\u0000\u1825\u1828"+
"\u0005\u02b0\u0000\u0000\u1826\u1829\u0003\u027c\u013e\u0000\u1827\u1829"+
"\u0005\u0132\u0000\u0000\u1828\u1826\u0001\u0000\u0000\u0000\u1828\u1827"+
"\u0001\u0000\u0000\u0000\u1829\u1830\u0001\u0000\u0000\u0000\u182a\u182b"+
"\u0005\u02c8\u0000\u0000\u182b\u182c\u0003\u02ca\u0165\u0000\u182c\u182d"+
"\u0005\u02b0\u0000\u0000\u182d\u182e\u0003\u027c\u013e\u0000\u182e\u1830"+
"\u0001\u0000\u0000\u0000\u182f\u1822\u0001\u0000\u0000\u0000\u182f\u182a"+
"\u0001\u0000\u0000\u0000\u1830\u019d\u0001\u0000\u0000\u0000\u1831\u1832"+
"\u0005\u021e\u0000\u0000\u1832\u1833\u0007;\u0000\u0000\u1833\u019f\u0001"+
"\u0000\u0000\u0000\u1834\u1835\u0005\u01a6\u0000\u0000\u1835\u183d\u0005"+
"\u01b7\u0000\u0000\u1836\u1837\u0005\u021e\u0000\u0000\u1837\u183e\u0005"+
"\u028c\u0000\u0000\u1838\u1839\u0005\u021e\u0000\u0000\u1839\u183e\u0005"+
"\u0109\u0000\u0000\u183a\u183b\u0005\u022a\u0000\u0000\u183b\u183e\u0005"+
"\u021e\u0000\u0000\u183c\u183e\u0005\u024d\u0000\u0000\u183d\u1836\u0001"+
"\u0000\u0000\u0000\u183d\u1838\u0001\u0000\u0000\u0000\u183d\u183a\u0001"+
"\u0000\u0000\u0000\u183d\u183c\u0001\u0000\u0000\u0000\u183e\u01a1\u0001"+
"\u0000\u0000\u0000\u183f\u1841\u0005\u0291\u0000\u0000\u1840\u1842\u0007"+
"\u0011\u0000\u0000\u1841\u1840\u0001\u0000\u0000\u0000\u1841\u1842\u0001"+
"\u0000\u0000\u0000\u1842\u1843\u0001\u0000\u0000\u0000\u1843\u1846\u0005"+
"\u029b\u0000\u0000\u1844\u1847\u0005\u00c8\u0000\u0000\u1845\u1847\u0003"+
"\u02ca\u0165\u0000\u1846\u1844\u0001\u0000\u0000\u0000\u1846\u1845\u0001"+
"\u0000\u0000\u0000\u1847\u184d\u0001\u0000\u0000\u0000\u1848\u1849\u0005"+
"\u0291\u0000\u0000\u1849\u184a\u0005\u0132\u0000\u0000\u184a\u184b\u0005"+
"\u0264\u0000\u0000\u184b\u184d\u0005\u029e\u0000\u0000\u184c\u183f\u0001"+
"\u0000\u0000\u0000\u184c\u1848\u0001\u0000\u0000\u0000\u184d\u01a3\u0001"+
"\u0000\u0000\u0000\u184e\u1852\u0005\u0295\u0000\u0000\u184f\u1850\u0003"+
"\u02ca\u0165\u0000\u1850\u1851\u0005\u00b9\u0000\u0000\u1851\u1853\u0001"+
"\u0000\u0000\u0000\u1852\u184f\u0001\u0000\u0000\u0000\u1852\u1853\u0001"+
"\u0000\u0000\u0000\u1853\u1854\u0001\u0000\u0000\u0000\u1854\u1863\u0003"+
"\u02ca\u0165\u0000\u1855\u185c\u0005\u0295\u0000\u0000\u1856\u1857\u0003"+
"\u02ca\u0165\u0000\u1857\u1858\u0005\u00b9\u0000\u0000\u1858\u185a\u0001"+
"\u0000\u0000\u0000\u1859\u1856\u0001\u0000\u0000\u0000\u1859\u185a\u0001"+
"\u0000\u0000\u0000\u185a\u185b\u0001\u0000\u0000\u0000\u185b\u185d\u0003"+
"\u02ca\u0165\u0000\u185c\u1859\u0001\u0000\u0000\u0000\u185c\u185d\u0001"+
"\u0000\u0000\u0000\u185d\u185e\u0001\u0000\u0000\u0000\u185e\u185f\u0005"+
"\u02c8\u0000\u0000\u185f\u1863\u0003\u02ca\u0165\u0000\u1860\u1861\u0005"+
"\u026b\u0000\u0000\u1861\u1863\u0003\u02ca\u0165\u0000\u1862\u184e\u0001"+
"\u0000\u0000\u0000\u1862\u1855\u0001\u0000\u0000\u0000\u1862\u1860\u0001"+
"\u0000\u0000\u0000\u1863\u01a5\u0001\u0000\u0000\u0000\u1864\u1865\u0005"+
"\u0287\u0000\u0000\u1865\u1866\u0005\u026e\u0000\u0000\u1866\u1868\u0003"+
"\u0250\u0128\u0000\u1867\u1869\u0003\u029e\u014f\u0000\u1868\u1867\u0001"+
"\u0000\u0000\u0000\u1868\u1869\u0001\u0000\u0000\u0000\u1869\u1882\u0001"+
"\u0000\u0000\u0000\u186a\u186b\u0005\u0117\u0000\u0000\u186b\u186c\u0005"+
"\u019e\u0000\u0000\u186c\u186e\u0003\u0250\u0128\u0000\u186d\u186f\u0003"+
"\u023a\u011d\u0000\u186e\u186d\u0001\u0000\u0000\u0000\u186e\u186f\u0001"+
"\u0000\u0000\u0000\u186f\u1870\u0001\u0000\u0000\u0000\u1870\u187c\u0005"+
"\u0172\u0000\u0000\u1871\u187d\u0003\u01a8\u00d4\u0000\u1872\u1873\u0005"+
"\u00b6\u0000\u0000\u1873\u1874\u0005\u024b\u0000\u0000\u1874\u1875\u0003"+
"\u0202\u0101\u0000\u1875\u1876\u0005\u0172\u0000\u0000\u1876\u1878\u0003"+
"\u01a8\u00d4\u0000\u1877\u1879\u0003\u0204\u0102\u0000\u1878\u1877\u0001"+
"\u0000\u0000\u0000\u1878\u1879\u0001\u0000\u0000\u0000\u1879\u187a\u0001"+
"\u0000\u0000\u0000\u187a\u187b\u0005\u00b7\u0000\u0000\u187b\u187d\u0001"+
"\u0000\u0000\u0000\u187c\u1871\u0001\u0000\u0000\u0000\u187c\u1872\u0001"+
"\u0000\u0000\u0000\u187d\u187f\u0001\u0000\u0000\u0000\u187e\u1880\u0003"+
"\u0244\u0122\u0000\u187f\u187e\u0001\u0000\u0000\u0000\u187f\u1880\u0001"+
"\u0000\u0000\u0000\u1880\u1882\u0001\u0000\u0000\u0000\u1881\u1864\u0001"+
"\u0000\u0000\u0000\u1881\u186a\u0001\u0000\u0000\u0000\u1882\u01a7\u0001"+
"\u0000\u0000\u0000\u1883\u1886\u0005\u02c8\u0000\u0000\u1884\u1887\u0003"+
"\u02ca\u0165\u0000\u1885\u1887\u0005\u02bc\u0000\u0000\u1886\u1884\u0001"+
"\u0000\u0000\u0000\u1886\u1885\u0001\u0000\u0000\u0000\u1887\u188b\u0001"+
"\u0000\u0000\u0000\u1888\u1889\u0005\u00b6\u0000\u0000\u1889\u188a\u0005"+
"\u02ca\u0000\u0000\u188a\u188c\u0005\u00b7\u0000\u0000\u188b\u1888\u0001"+
"\u0000\u0000\u0000\u188b\u188c\u0001\u0000\u0000\u0000\u188c\u01a9\u0001"+
"\u0000\u0000\u0000\u188d\u188e\u0003\u01d0\u00e8\u0000\u188e\u188f\u0005"+
"\u0176\u0000\u0000\u188f\u1890\u0003\u02ca\u0165\u0000\u1890\u1892\u0005"+
"\u00b6\u0000\u0000\u1891\u1893\u0003\u0246\u0123\u0000\u1892\u1891\u0001"+
"\u0000\u0000\u0000\u1892\u1893\u0001\u0000\u0000\u0000\u1893\u1894\u0001"+
"\u0000\u0000\u0000\u1894\u1895\u0005\u00b7\u0000\u0000\u1895\u1896\u0003"+
"\u024e\u0127\u0000\u1896\u18a1\u0001\u0000\u0000\u0000\u1897\u1898\u0003"+
"\u01d0\u00e8\u0000\u1898\u1899\u0003\u0250\u0128\u0000\u1899\u189a\u0005"+
"\u00c8\u0000\u0000\u189a\u18a1\u0001\u0000\u0000\u0000\u189b\u189c\u0003"+
"\u01d0\u00e8\u0000\u189c\u189e\u0003\u0250\u0128\u0000\u189d\u189f\u0003"+
"\u029e\u014f\u0000\u189e\u189d\u0001\u0000\u0000\u0000\u189e\u189f\u0001"+
"\u0000\u0000\u0000\u189f\u18a1\u0001\u0000\u0000\u0000\u18a0\u188d\u0001"+
"\u0000\u0000\u0000\u18a0\u1897\u0001\u0000\u0000\u0000\u18a0\u189b\u0001"+
"\u0000\u0000\u0000\u18a1\u01ab\u0001\u0000\u0000\u0000\u18a2\u18a3\u0005"+
"\u0211\u0000\u0000\u18a3\u18a4\u0005\u01ac\u0000\u0000\u18a4\u18af\u0003"+
"\u023a\u011d\u0000\u18a5\u18a6\u0005\u028f\u0000\u0000\u18a6\u18af\u0003"+
"\u023a\u011d\u0000\u18a7\u18a8\u0005\u016e\u0000\u0000\u18a8\u18a9\u0005"+
"\u01ac\u0000\u0000\u18a9\u18aa\u0003\u023a\u011d\u0000\u18aa\u18ab\u0005"+
"\u0225\u0000\u0000\u18ab\u18ac\u0003\u0250\u0128\u0000\u18ac\u18ad\u0003"+
"\u023a\u011d\u0000\u18ad\u18af\u0001\u0000\u0000\u0000\u18ae\u18a2\u0001"+
"\u0000\u0000\u0000\u18ae\u18a5\u0001\u0000\u0000\u0000\u18ae\u18a7\u0001"+
"\u0000\u0000\u0000\u18af\u01ad\u0001\u0000\u0000\u0000\u18b0\u18b2\u0005"+
"\u0276\u0000\u0000\u18b1\u18b0\u0001\u0000\u0000\u0000\u18b1\u18b2\u0001"+
"\u0000\u0000\u0000\u18b2\u18b3\u0001\u0000\u0000\u0000\u18b3\u18b4\u0007"+
"<\u0000\u0000\u18b4\u18bf\u0003\u023a\u011d\u0000\u18b5\u18b7\u0005\u0276"+
"\u0000\u0000\u18b6\u18b5\u0001\u0000\u0000\u0000\u18b6\u18b7\u0001\u0000"+
"\u0000\u0000\u18b7\u18b8\u0001\u0000\u0000\u0000\u18b8\u18b9\u0005\u01f9"+
"\u0000\u0000\u18b9\u18bf\u0003\u02c6\u0163\u0000\u18ba\u18bb\u0007<\u0000"+
"\u0000\u18bb\u18bc\u0005\u00b6\u0000\u0000\u18bc\u18bd\u0005\u02b9\u0000"+
"\u0000\u18bd\u18bf\u0005\u00b7\u0000\u0000\u18be\u18b1\u0001\u0000\u0000"+
"\u0000\u18be\u18b6\u0001\u0000\u0000\u0000\u18be\u18ba\u0001\u0000\u0000"+
"\u0000\u18bf\u01af\u0001\u0000\u0000\u0000\u18c0\u18c2\u0005\u00d5\u0000"+
"\u0000\u18c1\u18c0\u0001\u0000\u0000\u0000\u18c1\u18c2\u0001\u0000\u0000"+
"\u0000\u18c2\u18c3\u0001\u0000\u0000\u0000\u18c3\u18c4\u0005\u01f9\u0000"+
"\u0000\u18c4\u18c6\u0005\u00f1\u0000\u0000\u18c5\u18c7\u0007=\u0000\u0000"+
"\u18c6\u18c5\u0001\u0000\u0000\u0000\u18c6\u18c7\u0001\u0000\u0000\u0000"+
"\u18c7\u18c8\u0001\u0000\u0000\u0000\u18c8\u18c9\u0003\u01b2\u00d9\u0000"+
"\u18c9\u18cb\u0005\u00b6\u0000\u0000\u18ca\u18cc\u0003\u025e\u012f\u0000"+
"\u18cb\u18ca\u0001\u0000\u0000\u0000\u18cb\u18cc\u0001\u0000\u0000\u0000"+
"\u18cc\u18cd\u0001\u0000\u0000\u0000\u18cd\u18ce\u0005\u00b7\u0000\u0000"+
"\u18ce\u01b1\u0001\u0000\u0000\u0000\u18cf\u18d0\u0005\u00b6\u0000\u0000"+
"\u18d0\u18d5\u0003\u01b4\u00da\u0000\u18d1\u18d2\u0005\u00b8\u0000\u0000"+
"\u18d2\u18d4\u0003\u01b4\u00da\u0000\u18d3\u18d1\u0001\u0000\u0000\u0000"+
"\u18d4\u18d7\u0001\u0000\u0000\u0000\u18d5\u18d3\u0001\u0000\u0000\u0000"+
"\u18d5\u18d6\u0001\u0000\u0000\u0000\u18d6\u18d8\u0001\u0000\u0000\u0000"+
"\u18d7\u18d5\u0001\u0000\u0000\u0000\u18d8\u18d9\u0005\u00b7\u0000\u0000"+
"\u18d9\u01b3\u0001\u0000\u0000\u0000\u18da\u18dd\u0003\u02ca\u0165\u0000"+
"\u18db\u18dd\u0003\u028e\u0147\u0000\u18dc\u18da\u0001\u0000\u0000\u0000"+
"\u18dc\u18db\u0001\u0000\u0000\u0000\u18dd\u01b5\u0001\u0000\u0000\u0000"+
"\u18de\u18e0\u0005\u02aa\u0000\u0000\u18df\u18de\u0001\u0000\u0000\u0000"+
"\u18df\u18e0\u0001\u0000\u0000\u0000\u18e0\u18e1\u0001\u0000\u0000\u0000"+
"\u18e1\u18e3\u0003\u01d8\u00ec\u0000\u18e2\u18df\u0001\u0000\u0000\u0000"+
"\u18e2\u18e3\u0001\u0000\u0000\u0000\u18e3\u18e4\u0001\u0000\u0000\u0000"+
"\u18e4\u18e5\u0005\u0124\u0000\u0000\u18e5\u18e6\u0005\u0195\u0000\u0000"+
"\u18e6\u18e7\u0005\u00b6\u0000\u0000\u18e7\u18ec\u0005\u02ca\u0000\u0000"+
"\u18e8\u18e9\u0005\u00b8\u0000\u0000\u18e9\u18eb\u0005\u02ca\u0000\u0000"+
"\u18ea\u18e8\u0001\u0000\u0000\u0000\u18eb\u18ee\u0001\u0000\u0000\u0000"+
"\u18ec\u18ea\u0001\u0000\u0000\u0000\u18ec\u18ed\u0001\u0000\u0000\u0000"+
"\u18ed\u18ef\u0001\u0000\u0000\u0000\u18ee\u18ec\u0001\u0000\u0000\u0000"+
"\u18ef\u18f0\u0005\u00b7\u0000\u0000\u18f0\u18f1\u0005\u019e\u0000\u0000"+
"\u18f1\u18f2\u0005\u026e\u0000\u0000\u18f2\u18f4\u0003\u02ca\u0165\u0000"+
"\u18f3\u18f5\u0003\u01ae\u00d7\u0000\u18f4\u18f3\u0001\u0000\u0000\u0000"+
"\u18f4\u18f5\u0001\u0000\u0000\u0000\u18f5\u18fa\u0001\u0000\u0000\u0000"+
"\u18f6\u18f7\u0005\u0106\u0000\u0000\u18f7\u18f8\u0005\u0277\u0000\u0000"+
"\u18f8\u18f9\u0005\u00f1\u0000\u0000\u18f9\u18fb\u0005\u02ca\u0000\u0000"+
"\u18fa\u18f6\u0001\u0000\u0000\u0000\u18fa\u18fb\u0001\u0000\u0000\u0000"+
"\u18fb\u1900\u0001\u0000\u0000\u0000\u18fc\u18fd\u0005\u01ba\u0000\u0000"+
"\u18fd\u18fe\u0005\u0277\u0000\u0000\u18fe\u18ff\u0005\u00f1\u0000\u0000"+
"\u18ff\u1901\u0005\u02ca\u0000\u0000\u1900\u18fc\u0001\u0000\u0000\u0000"+
"\u1900\u1901\u0001\u0000\u0000\u0000\u1901\u1905\u0001\u0000\u0000\u0000"+
"\u1902\u1903\u0005\u0170\u0000\u0000\u1903\u1904\u0005\u00d1\u0000\u0000"+
"\u1904\u1906\u0003\u01c2\u00e1\u0000\u1905\u1902\u0001\u0000\u0000\u0000"+
"\u1905\u1906\u0001\u0000\u0000\u0000\u1906\u190a\u0001\u0000\u0000\u0000"+
"\u1907\u1908\u0005\u010c\u0000\u0000\u1908\u1909\u0005\u00d1\u0000\u0000"+
"\u1909\u190b\u0003\u01c2\u00e1\u0000\u190a\u1907\u0001\u0000\u0000\u0000"+
"\u190a\u190b\u0001\u0000\u0000\u0000\u190b\u190d\u0001\u0000\u0000\u0000"+
"\u190c\u190e\u0003\u023a\u011d\u0000\u190d\u190c\u0001\u0000\u0000\u0000"+
"\u190d\u190e\u0001\u0000\u0000\u0000\u190e\u1910\u0001\u0000\u0000\u0000"+
"\u190f\u1911\u0003\u01e0\u00f0\u0000\u1910\u190f\u0001\u0000\u0000\u0000"+
"\u1910\u1911\u0001\u0000\u0000\u0000\u1911\u1913\u0001\u0000\u0000\u0000"+
"\u1912\u1914\u0003\u01e2\u00f1\u0000\u1913\u1912\u0001\u0000\u0000\u0000"+
"\u1913\u1914\u0001\u0000\u0000\u0000\u1914\u1916\u0001\u0000\u0000\u0000"+
"\u1915\u1917\u0003\u01da\u00ed\u0000\u1916\u1915\u0001\u0000\u0000\u0000"+
"\u1916\u1917\u0001\u0000\u0000\u0000\u1917\u1919\u0001\u0000\u0000\u0000"+
"\u1918\u191a\u0003\u0204\u0102\u0000\u1919\u1918\u0001\u0000\u0000\u0000"+
"\u1919\u191a\u0001\u0000\u0000\u0000\u191a\u191c\u0001\u0000\u0000\u0000"+
"\u191b\u191d\u0003\u01dc\u00ee\u0000\u191c\u191b\u0001\u0000\u0000\u0000"+
"\u191c\u191d\u0001\u0000\u0000\u0000\u191d\u191f\u0001\u0000\u0000\u0000"+
"\u191e\u1920\u0003\u01de\u00ef\u0000\u191f\u191e\u0001\u0000\u0000\u0000"+
"\u191f\u1920\u0001\u0000\u0000\u0000\u1920\u1922\u0001\u0000\u0000\u0000"+
"\u1921\u1923\u0003\u0244\u0122\u0000\u1922\u1921\u0001\u0000\u0000\u0000"+
"\u1922\u1923\u0001\u0000\u0000\u0000\u1923\u1942\u0001\u0000\u0000\u0000"+
"\u1924\u1926\u0005\u02aa\u0000\u0000\u1925\u1924\u0001\u0000\u0000\u0000"+
"\u1925\u1926\u0001\u0000\u0000\u0000\u1926\u1927\u0001\u0000\u0000\u0000"+
"\u1927\u1929\u0003\u01d8\u00ec\u0000\u1928\u1925\u0001\u0000\u0000\u0000"+
"\u1928\u1929\u0001\u0000\u0000\u0000\u1929\u192a\u0001\u0000\u0000\u0000"+
"\u192a\u192b\u0005\u0124\u0000\u0000\u192b\u192c\u0005\u0172\u0000\u0000"+
"\u192c\u192d\u0005\u026e\u0000\u0000\u192d\u192e\u0003\u02ca\u0165\u0000"+
"\u192e\u192f\u0005\u019e\u0000\u0000\u192f\u1930\u0005\u026e\u0000\u0000"+
"\u1930\u1933\u0003\u02ca\u0165\u0000\u1931\u1932\u0005\u01f9\u0000\u0000"+
"\u1932\u1934\u0003\u023a\u011d\u0000\u1933\u1931\u0001\u0000\u0000\u0000"+
"\u1933\u1934\u0001\u0000\u0000\u0000\u1934\u1936\u0001\u0000\u0000\u0000"+
"\u1935\u1937\u0003\u01e2\u00f1\u0000\u1936\u1935\u0001\u0000\u0000\u0000"+
"\u1936\u1937\u0001\u0000\u0000\u0000\u1937\u1939\u0001\u0000\u0000\u0000"+
"\u1938\u193a\u0003\u0204\u0102\u0000\u1939\u1938\u0001\u0000\u0000\u0000"+
"\u1939\u193a\u0001\u0000\u0000\u0000\u193a\u193c\u0001\u0000\u0000\u0000"+
"\u193b\u193d\u0003\u01dc\u00ee\u0000\u193c\u193b\u0001\u0000\u0000\u0000"+
"\u193c\u193d\u0001\u0000\u0000\u0000\u193d\u193f\u0001\u0000\u0000\u0000"+
"\u193e\u1940\u0003\u0244\u0122\u0000\u193f\u193e\u0001\u0000\u0000\u0000"+
"\u193f\u1940\u0001\u0000\u0000\u0000\u1940\u1942\u0001\u0000\u0000\u0000"+
"\u1941\u18e2\u0001\u0000\u0000\u0000\u1941\u1928\u0001\u0000\u0000\u0000"+
"\u1942\u01b7\u0001\u0000\u0000\u0000\u1943\u1944\u0005\u00ee\u0000\u0000"+
"\u1944\u1945\u0007>\u0000\u0000\u1945\u01b9\u0001\u0000\u0000\u0000\u1946"+
"\u1947\u0005\u01ed\u0000\u0000\u1947\u194e\u0005\u01c5\u0000\u0000\u1948"+
"\u1949\u0005\u01ed\u0000\u0000\u1949\u194a\u0005\u0246\u0000\u0000\u194a"+
"\u194e\u0003\u01bc\u00de\u0000\u194b\u194c\u0005\u01ed\u0000\u0000\u194c"+
"\u194e\u0005\u0108\u0000\u0000\u194d\u1946\u0001\u0000\u0000\u0000\u194d"+
"\u1948\u0001\u0000\u0000\u0000\u194d\u194b\u0001\u0000\u0000\u0000\u194e"+
"\u01bb\u0001\u0000\u0000\u0000\u194f\u1950\u0005\u0157\u0000\u0000\u1950"+
"\u1951\u0005\u02cf\u0000\u0000\u1951\u1954\u0003\u02ca\u0165\u0000\u1952"+
"\u1953\u0005\u0260\u0000\u0000\u1953\u1955\u0005\u02ca\u0000\u0000\u1954"+
"\u1952\u0001\u0000\u0000\u0000\u1954\u1955\u0001\u0000\u0000\u0000\u1955"+
"\u01bd\u0001\u0000\u0000\u0000\u1956\u1957\u0007?\u0000\u0000\u1957\u01bf"+
"\u0001\u0000\u0000\u0000\u1958\u195b\u0003\u02ca\u0165\u0000\u1959\u195b"+
"\u0003\u028e\u0147\u0000\u195a\u1958\u0001\u0000\u0000\u0000\u195a\u1959"+
"\u0001\u0000\u0000\u0000\u195b\u01c1\u0001\u0000\u0000\u0000\u195c\u195f"+
"\u0003\u02ca\u0165\u0000\u195d\u195f\u0005\u02ca\u0000\u0000\u195e\u195c"+
"\u0001\u0000\u0000\u0000\u195e\u195d\u0001\u0000\u0000\u0000\u195f\u01c3"+
"\u0001\u0000\u0000\u0000\u1960\u1964\u0003\u02ca\u0165\u0000\u1961\u1964"+
"\u0005\u02ca\u0000\u0000\u1962\u1964\u0005\u02b9\u0000\u0000\u1963\u1960"+
"\u0001\u0000\u0000\u0000\u1963\u1961\u0001\u0000\u0000\u0000\u1963\u1962"+
"\u0001\u0000\u0000\u0000\u1964\u01c5\u0001\u0000\u0000\u0000\u1965\u196a"+
"\u0003\u01c8\u00e4\u0000\u1966\u1967\u0005\u00b9\u0000\u0000\u1967\u1969"+
"\u0003\u01c8\u00e4\u0000\u1968\u1966\u0001\u0000\u0000\u0000\u1969\u196c"+
"\u0001\u0000\u0000\u0000\u196a\u1968\u0001\u0000\u0000\u0000\u196a\u196b"+
"\u0001\u0000\u0000\u0000\u196b\u01c7\u0001\u0000\u0000\u0000\u196c\u196a"+
"\u0001\u0000\u0000\u0000\u196d\u1970\u0003\u01c2\u00e1\u0000\u196e\u1970"+
"\u0005\u02b9\u0000\u0000\u196f\u196d\u0001\u0000\u0000\u0000\u196f\u196e"+
"\u0001\u0000\u0000\u0000\u1970\u01c9\u0001\u0000\u0000\u0000\u1971\u197a"+
"\u0003\u01c2\u00e1\u0000\u1972\u1978\u0005\u02c8\u0000\u0000\u1973\u1979"+
"\u0003\u01c2\u00e1\u0000\u1974\u1975\u0005\u00b6\u0000\u0000\u1975\u1976"+
"\u0003\u01c2\u00e1\u0000\u1976\u1977\u0005\u00b7\u0000\u0000\u1977\u1979"+
"\u0001\u0000\u0000\u0000\u1978\u1973\u0001\u0000\u0000\u0000\u1978\u1974"+
"\u0001\u0000\u0000\u0000\u1979\u197b\u0001\u0000\u0000\u0000\u197a\u1972"+
"\u0001\u0000\u0000\u0000\u197a\u197b\u0001\u0000\u0000\u0000\u197b\u01cb"+
"\u0001\u0000\u0000\u0000\u197c\u1983\u0003\u01ca\u00e5\u0000\u197d\u197e"+
"\u0005\u018d\u0000\u0000\u197e\u1980\u0005\u00f1\u0000\u0000\u197f\u1981"+
"\u0005\u01fb\u0000\u0000\u1980\u197f\u0001\u0000\u0000\u0000\u1980\u1981"+
"\u0001\u0000\u0000\u0000\u1981\u1982\u0001\u0000\u0000\u0000\u1982\u1984"+
"\u0005\u02ca\u0000\u0000\u1983\u197d\u0001\u0000\u0000\u0000\u1983\u1984"+
"\u0001\u0000\u0000\u0000\u1984\u01cd\u0001\u0000\u0000\u0000\u1985\u1987"+
"\u0003\u01d0\u00e8\u0000\u1986\u1988\u0003\u01d2\u00e9\u0000\u1987\u1986"+
"\u0001\u0000\u0000\u0000\u1987\u1988\u0001\u0000\u0000\u0000\u1988\u198a"+
"\u0001\u0000\u0000\u0000\u1989\u198b\u0007@\u0000\u0000\u198a\u1989\u0001"+
"\u0000\u0000\u0000\u198a\u198b\u0001\u0000\u0000\u0000\u198b\u198d\u0001"+
"\u0000\u0000\u0000\u198c\u198e\u0005\u020b\u0000\u0000\u198d\u198c\u0001"+
"\u0000\u0000\u0000\u198d\u198e\u0001\u0000\u0000\u0000\u198e\u01cf\u0001"+
"\u0000\u0000\u0000\u198f\u1990\u0007A\u0000\u0000\u1990\u01d1\u0001\u0000"+
"\u0000\u0000\u1991\u1992\u0007B\u0000\u0000\u1992\u01d3\u0001\u0000\u0000"+
"\u0000\u1993\u1994\u0005\u0208\u0000\u0000\u1994\u1995\u0005\u022d\u0000"+
"\u0000\u1995\u1996\u0003\u01d6\u00eb\u0000\u1996\u01d5\u0001\u0000\u0000"+
"\u0000\u1997\u1998\u0005\u0147\u0000\u0000\u1998\u199c\u0003\u01f0\u00f8"+
"\u0000\u1999\u199a\u0005\u0209\u0000\u0000\u199a\u199c\u0005\u02ca\u0000"+
"\u0000\u199b\u1997\u0001\u0000\u0000\u0000\u199b\u1999\u0001\u0000\u0000"+
"\u0000\u199c\u01d7\u0001\u0000\u0000\u0000\u199d\u199e\u00071\u0000\u0000"+
"\u199e\u01d9\u0001\u0000\u0000\u0000\u199f\u19a0\u0005\u020f\u0000\u0000"+
"\u19a0\u19a1\u0005\u0168\u0000\u0000\u19a1\u19a2\u0003\u027c\u013e\u0000"+
"\u19a2\u01db\u0001\u0000\u0000\u0000\u19a3\u19a4\u0005\u0134\u0000\u0000"+
"\u19a4\u19a5\u0005\u01ed\u0000\u0000\u19a5\u19a6\u0003\u027c\u013e\u0000"+
"\u19a6\u01dd\u0001\u0000\u0000\u0000\u19a7\u19a8\u0005\u01f2\u0000\u0000"+
"\u19a8\u19a9\u0005\u00f1\u0000\u0000\u19a9\u19aa\u0003\u02ca\u0165\u0000"+
"\u19aa\u01df\u0001\u0000\u0000\u0000\u19ab\u19ac\u0005\u0106\u0000\u0000"+
"\u19ac\u19ad\u0005\u0172\u0000\u0000\u19ad\u19ae\u0005\u0200\u0000\u0000"+
"\u19ae\u19af\u0005\u00d1\u0000\u0000\u19af\u19b0\u0003\u023a\u011d\u0000"+
"\u19b0\u01e1\u0001\u0000\u0000\u0000\u19b1\u19b2\u0005\u0250\u0000\u0000"+
"\u19b2\u19b3\u0005\u00b6\u0000\u0000\u19b3\u19b8\u0003\u01e4\u00f2\u0000"+
"\u19b4\u19b5\u0005\u00b8\u0000\u0000\u19b5\u19b7\u0003\u01e4\u00f2\u0000"+
"\u19b6\u19b4\u0001\u0000\u0000\u0000\u19b7\u19ba\u0001\u0000\u0000\u0000"+
"\u19b8\u19b6\u0001\u0000\u0000\u0000\u19b8\u19b9\u0001\u0000\u0000\u0000"+
"\u19b9\u19bb\u0001\u0000\u0000\u0000\u19ba\u19b8\u0001\u0000\u0000\u0000"+
"\u19bb\u19bc\u0005\u00b7\u0000\u0000\u19bc\u01e3\u0001\u0000\u0000\u0000"+
"\u19bd\u19be\u0003\u02ca\u0165\u0000\u19be\u19bf\u0005\u02b0\u0000\u0000"+
"\u19bf\u19c0\u0003\u027c\u013e\u0000\u19c0\u01e5\u0001\u0000\u0000\u0000"+
"\u19c1\u19de\u0003\u01e8\u00f4\u0000\u19c2\u19c3\u0005\u02aa\u0000\u0000"+
"\u19c3\u19c4\u0005\u0244\u0000\u0000\u19c4\u19c5\u0005\u00b6\u0000\u0000"+
"\u19c5\u19c6\u0003\u0246\u0123\u0000\u19c6\u19c7\u0005\u00b7\u0000\u0000"+
"\u19c7\u19de\u0001\u0000\u0000\u0000\u19c8\u19c9\u0005\u02aa\u0000\u0000"+
"\u19c9\u19ca\u0005\u0183\u0000\u0000\u19ca\u19cb\u0005\u00b6\u0000\u0000"+
"\u19cb\u19cc\u0003\u0246\u0123\u0000\u19cc\u19cd\u0005\u00b7\u0000\u0000"+
"\u19cd\u19de\u0001\u0000\u0000\u0000\u19ce\u19cf\u0005\u02aa\u0000\u0000"+
"\u19cf\u19d0\u0005\u01be\u0000\u0000\u19d0\u19d1\u0005\u00b6\u0000\u0000"+
"\u19d1\u19d2\u0003\u0246\u0123\u0000\u19d2\u19d3\u0005\u00b7\u0000\u0000"+
"\u19d3\u19de\u0001\u0000\u0000\u0000\u19d4\u19d5\u0005\u02aa\u0000\u0000"+
"\u19d5\u19d6\u0005\u00ec\u0000\u0000\u19d6\u19db\u0003\u01c2\u00e1\u0000"+
"\u19d7\u19d8\u0005\u00b6\u0000\u0000\u19d8\u19d9\u0003\u0246\u0123\u0000"+
"\u19d9\u19da\u0005\u00b7\u0000\u0000\u19da\u19dc\u0001\u0000\u0000\u0000"+
"\u19db\u19d7\u0001\u0000\u0000\u0000\u19db\u19dc\u0001\u0000\u0000\u0000"+
"\u19dc\u19de\u0001\u0000\u0000\u0000\u19dd\u19c1\u0001\u0000\u0000\u0000"+
"\u19dd\u19c2\u0001\u0000\u0000\u0000\u19dd\u19c8\u0001\u0000\u0000\u0000"+
"\u19dd\u19ce\u0001\u0000\u0000\u0000\u19dd\u19d4\u0001\u0000\u0000\u0000"+
"\u19de\u01e7\u0001\u0000\u0000\u0000\u19df\u19e0\u0005\u02aa\u0000\u0000"+
"\u19e0\u19e1\u0005\u0231\u0000\u0000\u19e1\u19e6\u0003\u01c2\u00e1\u0000"+
"\u19e2\u19e3\u0005\u00b6\u0000\u0000\u19e3\u19e4\u0003\u0246\u0123\u0000"+
"\u19e4\u19e5\u0005\u00b7\u0000\u0000\u19e5\u19e7\u0001\u0000\u0000\u0000"+
"\u19e6\u19e2\u0001\u0000\u0000\u0000\u19e6\u19e7\u0001\u0000\u0000\u0000"+
"\u19e7\u01e9\u0001\u0000\u0000\u0000\u19e8\u19ea\u0005\u0124\u0000\u0000"+
"\u19e9\u19eb\u0005\u01be\u0000\u0000\u19ea\u19e9\u0001\u0000\u0000\u0000"+
"\u19ea\u19eb\u0001\u0000\u0000\u0000\u19eb\u19ec\u0001\u0000\u0000\u0000"+
"\u19ec\u19ed\u0005\u0195\u0000\u0000\u19ed\u19ee\u0005\u02ca\u0000\u0000"+
"\u19ee\u19ef\u0005\u019e\u0000\u0000\u19ef\u19f0\u0005\u026e\u0000\u0000"+
"\u19f0\u19f3\u0003\u0250\u0128\u0000\u19f1\u19f2\u0005\u01f9\u0000\u0000"+
"\u19f2\u19f4\u0003\u023a\u011d\u0000\u19f3\u19f1\u0001\u0000\u0000\u0000"+
"\u19f3\u19f4\u0001\u0000\u0000\u0000\u19f4\u19f9\u0001\u0000\u0000\u0000"+
"\u19f5\u19f6\u0005\u0106\u0000\u0000\u19f6\u19f7\u0005\u0277\u0000\u0000"+
"\u19f7\u19f8\u0005\u00f1\u0000\u0000\u19f8\u19fa\u0005\u02ca\u0000\u0000"+
"\u19f9\u19f5\u0001\u0000\u0000\u0000\u19f9\u19fa\u0001\u0000\u0000\u0000"+
"\u19fa\u19ff\u0001\u0000\u0000\u0000\u19fb\u19fc\u0005\u01ba\u0000\u0000"+
"\u19fc\u19fd\u0005\u0277\u0000\u0000\u19fd\u19fe\u0005\u00f1\u0000\u0000"+
"\u19fe\u1a00\u0005\u02ca\u0000\u0000\u19ff\u19fb\u0001\u0000\u0000\u0000"+
"\u19ff\u1a00\u0001\u0000\u0000\u0000\u1a00\u1a02\u0001\u0000\u0000\u0000"+
"\u1a01\u1a03\u0003\u01ec\u00f6\u0000\u1a02\u1a01\u0001\u0000\u0000\u0000"+
"\u1a02\u1a03\u0001\u0000\u0000\u0000\u1a03\u1a05\u0001\u0000\u0000\u0000"+
"\u1a04\u1a06\u0003\u023a\u011d\u0000\u1a05\u1a04\u0001\u0000\u0000\u0000"+
"\u1a05\u1a06\u0001\u0000\u0000\u0000\u1a06\u1a08\u0001\u0000\u0000\u0000"+
"\u1a07\u1a09\u0003\u01e2\u00f1\u0000\u1a08\u1a07\u0001\u0000\u0000\u0000"+
"\u1a08\u1a09\u0001\u0000\u0000\u0000\u1a09\u1a0b\u0001\u0000\u0000\u0000"+
"\u1a0a\u1a0c\u0003\u0244\u0122\u0000\u1a0b\u1a0a\u0001\u0000\u0000\u0000"+
"\u1a0b\u1a0c\u0001\u0000\u0000\u0000\u1a0c\u01eb\u0001\u0000\u0000\u0000"+
"\u1a0d\u1a0e\u0005\u018f\u0000\u0000\u1a0e\u1a0f\u0005\u02cf\u0000\u0000"+
"\u1a0f\u1a14\u0005\u01ba\u0000\u0000\u1a10\u1a11\u0005\u018f\u0000\u0000"+
"\u1a11\u1a12\u0005\u02cf\u0000\u0000\u1a12\u1a14\u0005\u0243\u0000\u0000"+
"\u1a13\u1a0d\u0001\u0000\u0000\u0000\u1a13\u1a10\u0001\u0000\u0000\u0000"+
"\u1a14\u01ed\u0001\u0000\u0000\u0000\u1a15\u1a16\u0005\u019e\u0000\u0000"+
"\u1a16\u1a17\u0005\u01f4\u0000\u0000\u1a17\u1a1b\u0003\u02a0\u0150\u0000"+
"\u1a18\u1a19\u0005\u0170\u0000\u0000\u1a19\u1a1a\u0005\u00d1\u0000\u0000"+
"\u1a1a\u1a1c\u0003\u02ca\u0165\u0000\u1a1b\u1a18\u0001\u0000\u0000\u0000"+
"\u1a1b\u1a1c\u0001\u0000\u0000\u0000\u1a1c\u1a1e\u0001\u0000\u0000\u0000"+
"\u1a1d\u1a1f\u0003\u0244\u0122\u0000\u1a1e\u1a1d\u0001\u0000\u0000\u0000"+
"\u1a1e\u1a1f\u0001\u0000\u0000\u0000\u1a1f\u01ef\u0001\u0000\u0000\u0000"+
"\u1a20\u1a22\u0003\u01fa\u00fd\u0000\u1a21\u1a20\u0001\u0000\u0000\u0000"+
"\u1a21\u1a22\u0001\u0000\u0000\u0000\u1a22\u1a23\u0001\u0000\u0000\u0000"+
"\u1a23\u1a24\u0003\u01f2\u00f9\u0000\u1a24\u1a25";
private static final String _serializedATNSegment3 =
"\u0003\u022c\u0116\u0000\u1a25\u01f1\u0001\u0000\u0000\u0000\u1a26\u1a27"+
"\u0006\u00f9\uffff\uffff\u0000\u1a27\u1a28\u0003\u01f6\u00fb\u0000\u1a28"+
"\u1a37\u0001\u0000\u0000\u0000\u1a29\u1a2a\n\u0002\u0000\u0000\u1a2a\u1a2c"+
"\u0005\u019c\u0000\u0000\u1a2b\u1a2d\u0003\u01f4\u00fa\u0000\u1a2c\u1a2b"+
"\u0001\u0000\u0000\u0000\u1a2c\u1a2d\u0001\u0000\u0000\u0000\u1a2d\u1a2e"+
"\u0001\u0000\u0000\u0000\u1a2e\u1a36\u0003\u01f2\u00f9\u0003\u1a2f\u1a30"+
"\n\u0001\u0000\u0000\u1a30\u1a32\u0007C\u0000\u0000\u1a31\u1a33\u0003"+
"\u01f4\u00fa\u0000\u1a32\u1a31\u0001\u0000\u0000\u0000\u1a32\u1a33\u0001"+
"\u0000\u0000\u0000\u1a33\u1a34\u0001\u0000\u0000\u0000\u1a34\u1a36\u0003"+
"\u01f2\u00f9\u0002\u1a35\u1a29\u0001\u0000\u0000\u0000\u1a35\u1a2f\u0001"+
"\u0000\u0000\u0000\u1a36\u1a39\u0001\u0000\u0000\u0000\u1a37\u1a35\u0001"+
"\u0000\u0000\u0000\u1a37\u1a38\u0001\u0000\u0000\u0000\u1a38\u01f3\u0001"+
"\u0000\u0000\u0000\u1a39\u1a37\u0001\u0000\u0000\u0000\u1a3a\u1a3b\u0007"+
"\u001f\u0000\u0000\u1a3b\u01f5\u0001\u0000\u0000\u0000\u1a3c\u1a43\u0003"+
"\u01f8\u00fc\u0000\u1a3d\u1a3e\u0005\u00b6\u0000\u0000\u1a3e\u1a3f\u0003"+
"\u01f0\u00f8\u0000\u1a3f\u1a40\u0005\u00b7\u0000\u0000\u1a40\u1a43\u0001"+
"\u0000\u0000\u0000\u1a41\u1a43\u0003\u0276\u013b\u0000\u1a42\u1a3c\u0001"+
"\u0000\u0000\u0000\u1a42\u1a3d\u0001\u0000\u0000\u0000\u1a42\u1a41\u0001"+
"\u0000\u0000\u0000\u1a43\u01f7\u0001\u0000\u0000\u0000\u1a44\u1a46\u0003"+
"\u0200\u0100\u0000\u1a45\u1a47\u0003\u0208\u0104\u0000\u1a46\u1a45\u0001"+
"\u0000\u0000\u0000\u1a46\u1a47\u0001\u0000\u0000\u0000\u1a47\u1a49\u0001"+
"\u0000\u0000\u0000\u1a48\u1a4a\u0003\u0206\u0103\u0000\u1a49\u1a48\u0001"+
"\u0000\u0000\u0000\u1a49\u1a4a\u0001\u0000\u0000\u0000\u1a4a\u1a4c\u0001"+
"\u0000\u0000\u0000\u1a4b\u1a4d\u0003\u0204\u0102\u0000\u1a4c\u1a4b\u0001"+
"\u0000\u0000\u0000\u1a4c\u1a4d\u0001\u0000\u0000\u0000\u1a4d\u1a4f\u0001"+
"\u0000\u0000\u0000\u1a4e\u1a50\u0003\u0218\u010c\u0000\u1a4f\u1a4e\u0001"+
"\u0000\u0000\u0000\u1a4f\u1a50\u0001\u0000\u0000\u0000\u1a50\u1a52\u0001"+
"\u0000\u0000\u0000\u1a51\u1a53\u0003\u021e\u010f\u0000\u1a52\u1a51\u0001"+
"\u0000\u0000\u0000\u1a52\u1a53\u0001\u0000\u0000\u0000\u1a53\u1a54\u0001"+
"\u0000\u0000\u0000\u1a54\u1a55\u0004\u00fc\n\u0000\u1a55\u1a56\u0003\u022c"+
"\u0116\u0000\u1a56\u01f9\u0001\u0000\u0000\u0000\u1a57\u1a58\u0005\u02aa"+
"\u0000\u0000\u1a58\u1a5d\u0003\u01fc\u00fe\u0000\u1a59\u1a5a\u0005\u00b8"+
"\u0000\u0000\u1a5a\u1a5c\u0003\u01fc\u00fe\u0000\u1a5b\u1a59\u0001\u0000"+
"\u0000\u0000\u1a5c\u1a5f\u0001\u0000\u0000\u0000\u1a5d\u1a5b\u0001\u0000"+
"\u0000\u0000\u1a5d\u1a5e\u0001\u0000\u0000\u0000\u1a5e\u01fb\u0001\u0000"+
"\u0000\u0000\u1a5f\u1a5d\u0001\u0000\u0000\u0000\u1a60\u1a62\u0003\u02ca"+
"\u0165\u0000\u1a61\u1a63\u0003\u01fe\u00ff\u0000\u1a62\u1a61\u0001\u0000"+
"\u0000\u0000\u1a62\u1a63\u0001\u0000\u0000\u0000\u1a63\u1a64\u0001\u0000"+
"\u0000\u0000\u1a64\u1a65\u0005\u00d1\u0000\u0000\u1a65\u1a66\u0005\u00b6"+
"\u0000\u0000\u1a66\u1a67\u0003\u01f0\u00f8\u0000\u1a67\u1a68\u0005\u00b7"+
"\u0000\u0000\u1a68\u01fd\u0001\u0000\u0000\u0000\u1a69\u1a6a\u0005\u00b6"+
"\u0000\u0000\u1a6a\u1a6f\u0003\u02ca\u0165\u0000\u1a6b\u1a6c\u0005\u00b8"+
"\u0000\u0000\u1a6c\u1a6e\u0003\u02ca\u0165\u0000\u1a6d\u1a6b\u0001\u0000"+
"\u0000\u0000\u1a6e\u1a71\u0001\u0000\u0000\u0000\u1a6f\u1a6d\u0001\u0000"+
"\u0000\u0000\u1a6f\u1a70\u0001\u0000\u0000\u0000\u1a70\u1a72\u0001\u0000"+
"\u0000\u0000\u1a71\u1a6f\u0001\u0000\u0000\u0000\u1a72\u1a73\u0005\u00b7"+
"\u0000\u0000\u1a73\u01ff\u0001\u0000\u0000\u0000\u1a74\u1a76\u0005\u024b"+
"\u0000\u0000\u1a75\u1a77\u0007\u001f\u0000\u0000\u1a76\u1a75\u0001\u0000"+
"\u0000\u0000\u1a76\u1a77\u0001\u0000\u0000\u0000\u1a77\u1a78\u0001\u0000"+
"\u0000\u0000\u1a78\u1a79\u0003\u0202\u0101\u0000\u1a79\u0201\u0001\u0000"+
"\u0000\u0000\u1a7a\u1a82\u0003\u027a\u013d\u0000\u1a7b\u1a7c\u0005\u02b9"+
"\u0000\u0000\u1a7c\u1a7d\u0005\u0158\u0000\u0000\u1a7d\u1a7e\u0005\u00b6"+
"\u0000\u0000\u1a7e\u1a7f\u0003\u027a\u013d\u0000\u1a7f\u1a80\u0005\u00b7"+
"\u0000\u0000\u1a80\u1a82\u0001\u0000\u0000\u0000\u1a81\u1a7a\u0001\u0000"+
"\u0000\u0000\u1a81\u1a7b\u0001\u0000\u0000\u0000\u1a82\u0203\u0001\u0000"+
"\u0000\u0000\u1a83\u1a84\u0005\u02a8\u0000\u0000\u1a84\u1a85\u0003\u0280"+
"\u0140\u0000\u1a85\u0205\u0001\u0000\u0000\u0000\u1a86\u1a87\u0005\u0172"+
"\u0000\u0000\u1a87\u1a88\u0003\u020e\u0107\u0000\u1a88\u0207\u0001\u0000"+
"\u0000\u0000\u1a89\u1a8b\u0003\u020a\u0105\u0000\u1a8a\u1a89\u0001\u0000"+
"\u0000\u0000\u1a8a\u1a8b\u0001\u0000\u0000\u0000\u1a8b\u1a8c\u0001\u0000"+
"\u0000\u0000\u1a8c\u1a8f\u0005\u019e\u0000\u0000\u1a8d\u1a90\u0003\u020c"+
"\u0106\u0000\u1a8e\u1a90\u0003\u02ca\u0165\u0000\u1a8f\u1a8d\u0001\u0000"+
"\u0000\u0000\u1a8f\u1a8e\u0001\u0000\u0000\u0000\u1a90\u1a98\u0001\u0000"+
"\u0000\u0000\u1a91\u1a94\u0005\u00b8\u0000\u0000\u1a92\u1a95\u0003\u020c"+
"\u0106\u0000\u1a93\u1a95\u0003\u02ca\u0165\u0000\u1a94\u1a92\u0001\u0000"+
"\u0000\u0000\u1a94\u1a93\u0001\u0000\u0000\u0000\u1a95\u1a97\u0001\u0000"+
"\u0000\u0000\u1a96\u1a91\u0001\u0000\u0000\u0000\u1a97\u1a9a\u0001\u0000"+
"\u0000\u0000\u1a98\u1a96\u0001\u0000\u0000\u0000\u1a98\u1a99\u0001\u0000"+
"\u0000\u0000\u1a99\u0209\u0001\u0000\u0000\u0000\u1a9a\u1a98\u0001\u0000"+
"\u0000\u0000\u1a9b\u1a9c\u0005\u00f0\u0000\u0000\u1a9c\u1a9d\u0005\u0103"+
"\u0000\u0000\u1a9d\u020b\u0001\u0000\u0000\u0000\u1a9e\u1a9f\u0003\u02ca"+
"\u0165\u0000\u1a9f\u1aa0\u0005\u00b6\u0000\u0000\u1aa0\u1aa1\u0005\u02cf"+
"\u0000\u0000\u1aa1\u1aa2\u0005\u00b7\u0000\u0000\u1aa2\u020d\u0001\u0000"+
"\u0000\u0000\u1aa3\u1aa8\u0003\u0210\u0108\u0000\u1aa4\u1aa5\u0005\u00b8"+
"\u0000\u0000\u1aa5\u1aa7\u0003\u0210\u0108\u0000\u1aa6\u1aa4\u0001\u0000"+
"\u0000\u0000\u1aa7\u1aaa\u0001\u0000\u0000\u0000\u1aa8\u1aa6\u0001\u0000"+
"\u0000\u0000\u1aa8\u1aa9\u0001\u0000\u0000\u0000\u1aa9\u020f\u0001\u0000"+
"\u0000\u0000\u1aaa\u1aa8\u0001\u0000\u0000\u0000\u1aab\u1aaf\u0003\u0240"+
"\u0120\u0000\u1aac\u1aae\u0003\u0212\u0109\u0000\u1aad\u1aac\u0001\u0000"+
"\u0000\u0000\u1aae\u1ab1\u0001\u0000\u0000\u0000\u1aaf\u1aad\u0001\u0000"+
"\u0000\u0000\u1aaf\u1ab0\u0001\u0000\u0000\u0000\u1ab0\u0211\u0001\u0000"+
"\u0000\u0000\u1ab1\u1aaf\u0001\u0000\u0000\u0000\u1ab2\u1ab3\u0003\u0236"+
"\u011b\u0000\u1ab3\u1ab5\u0005\u01a9\u0000\u0000\u1ab4\u1ab6\u0003\u0214"+
"\u010a\u0000\u1ab5\u1ab4\u0001\u0000\u0000\u0000\u1ab5\u1ab6\u0001\u0000"+
"\u0000\u0000\u1ab6\u1ab7\u0001\u0000\u0000\u0000\u1ab7\u1ab9\u0003\u0240"+
"\u0120\u0000\u1ab8\u1aba\u0003\u0238\u011c\u0000\u1ab9\u1ab8\u0001\u0000"+
"\u0000\u0000\u1ab9\u1aba\u0001\u0000\u0000\u0000\u1aba\u0213\u0001\u0000"+
"\u0000\u0000\u1abb\u1abc\u0005\u00bb\u0000\u0000\u1abc\u1abd\u0003\u02ca"+
"\u0165\u0000\u1abd\u1abe\u0005\u00bc\u0000\u0000\u1abe\u1ac4\u0001\u0000"+
"\u0000\u0000\u1abf\u1ac0\u0005\u02c5\u0000\u0000\u1ac0\u1ac1\u0003\u02ca"+
"\u0165\u0000\u1ac1\u1ac2\u0005\u02c6\u0000\u0000\u1ac2\u1ac4\u0001\u0000"+
"\u0000\u0000\u1ac3\u1abb\u0001\u0000\u0000\u0000\u1ac3\u1abf\u0001\u0000"+
"\u0000\u0000\u1ac4\u0215\u0001\u0000\u0000\u0000\u1ac5\u1ac6\u0005\u00bb"+
"\u0000\u0000\u1ac6\u1acb\u0003\u02ca\u0165\u0000\u1ac7\u1ac8\u0005\u00b8"+
"\u0000\u0000\u1ac8\u1aca\u0003\u02ca\u0165\u0000\u1ac9\u1ac7\u0001\u0000"+
"\u0000\u0000\u1aca\u1acd\u0001\u0000\u0000\u0000\u1acb\u1ac9\u0001\u0000"+
"\u0000\u0000\u1acb\u1acc\u0001\u0000\u0000\u0000\u1acc\u1ace\u0001\u0000"+
"\u0000\u0000\u1acd\u1acb\u0001\u0000\u0000\u0000\u1ace\u1acf\u0005\u00bc"+
"\u0000\u0000\u1acf\u1adc\u0001\u0000\u0000\u0000\u1ad0\u1ad1\u0005\u02c5"+
"\u0000\u0000\u1ad1\u1ad6\u0003\u02ca\u0165\u0000\u1ad2\u1ad3\u0005\u00b8"+
"\u0000\u0000\u1ad3\u1ad5\u0003\u02ca\u0165\u0000\u1ad4\u1ad2\u0001\u0000"+
"\u0000\u0000\u1ad5\u1ad8\u0001\u0000\u0000\u0000\u1ad6\u1ad4\u0001\u0000"+
"\u0000\u0000\u1ad6\u1ad7\u0001\u0000\u0000\u0000\u1ad7\u1ad9\u0001\u0000"+
"\u0000\u0000\u1ad8\u1ad6\u0001\u0000\u0000\u0000\u1ad9\u1ada\u0005\u02c6"+
"\u0000\u0000\u1ada\u1adc\u0001\u0000\u0000\u0000\u1adb\u1ac5\u0001\u0000"+
"\u0000\u0000\u1adb\u1ad0\u0001\u0000\u0000\u0000\u1adc\u0217\u0001\u0000"+
"\u0000\u0000\u1add\u1ade\u0005\u017e\u0000\u0000\u1ade\u1adf\u0005\u00f1"+
"\u0000\u0000\u1adf\u1ae0\u0003\u021a\u010d\u0000\u1ae0\u0219\u0001\u0000"+
"\u0000\u0000\u1ae1\u1ae2\u0005\u0240\u0000\u0000\u1ae2\u1aeb\u0005\u00b6"+
"\u0000\u0000\u1ae3\u1ae8\u0003\u027c\u013e\u0000\u1ae4\u1ae5\u0005\u00b8"+
"\u0000\u0000\u1ae5\u1ae7\u0003\u027c\u013e\u0000\u1ae6\u1ae4\u0001\u0000"+
"\u0000\u0000\u1ae7\u1aea\u0001\u0000\u0000\u0000\u1ae8\u1ae6\u0001\u0000"+
"\u0000\u0000\u1ae8\u1ae9\u0001\u0000\u0000\u0000\u1ae9\u1aec\u0001\u0000"+
"\u0000\u0000\u1aea\u1ae8\u0001\u0000\u0000\u0000\u1aeb\u1ae3\u0001\u0000"+
"\u0000\u0000\u1aeb\u1aec\u0001\u0000\u0000\u0000\u1aec\u1aed\u0001\u0000"+
"\u0000\u0000\u1aed\u1b15\u0005\u00b7\u0000\u0000\u1aee\u1aef\u0005\u011d"+
"\u0000\u0000\u1aef\u1af8\u0005\u00b6\u0000\u0000\u1af0\u1af5\u0003\u027c"+
"\u013e\u0000\u1af1\u1af2\u0005\u00b8\u0000\u0000\u1af2\u1af4\u0003\u027c"+
"\u013e\u0000\u1af3\u1af1\u0001\u0000\u0000\u0000\u1af4\u1af7\u0001\u0000"+
"\u0000\u0000\u1af5\u1af3\u0001\u0000\u0000\u0000\u1af5\u1af6\u0001\u0000"+
"\u0000\u0000\u1af6\u1af9\u0001\u0000\u0000\u0000\u1af7\u1af5\u0001\u0000"+
"\u0000\u0000\u1af8\u1af0\u0001\u0000\u0000\u0000\u1af8\u1af9\u0001\u0000"+
"\u0000\u0000\u1af9\u1afa\u0001\u0000\u0000\u0000\u1afa\u1b15\u0005\u00b7"+
"\u0000\u0000\u1afb\u1afc\u0005\u017f\u0000\u0000\u1afc\u1afd\u0005\u0251"+
"\u0000\u0000\u1afd\u1afe\u0005\u00b6\u0000\u0000\u1afe\u1b03\u0003\u021c"+
"\u010e\u0000\u1aff\u1b00\u0005\u00b8\u0000\u0000\u1b00\u1b02\u0003\u021c"+
"\u010e\u0000\u1b01\u1aff\u0001\u0000\u0000\u0000\u1b02\u1b05\u0001\u0000"+
"\u0000\u0000\u1b03\u1b01\u0001\u0000\u0000\u0000\u1b03\u1b04\u0001\u0000"+
"\u0000\u0000\u1b04\u1b06\u0001\u0000\u0000\u0000\u1b05\u1b03\u0001\u0000"+
"\u0000\u0000\u1b06\u1b07\u0005\u00b7\u0000\u0000\u1b07\u1b15\u0001\u0000"+
"\u0000\u0000\u1b08\u1b0d\u0003\u027c\u013e\u0000\u1b09\u1b0a\u0005\u00b8"+
"\u0000\u0000\u1b0a\u1b0c\u0003\u027c\u013e\u0000\u1b0b\u1b09\u0001\u0000"+
"\u0000\u0000\u1b0c\u1b0f\u0001\u0000\u0000\u0000\u1b0d\u1b0b\u0001\u0000"+
"\u0000\u0000\u1b0d\u1b0e\u0001\u0000\u0000\u0000\u1b0e\u1b12\u0001\u0000"+
"\u0000\u0000\u1b0f\u1b0d\u0001\u0000\u0000\u0000\u1b10\u1b11\u0005\u02aa"+
"\u0000\u0000\u1b11\u1b13\u0005\u0240\u0000\u0000\u1b12\u1b10\u0001\u0000"+
"\u0000\u0000\u1b12\u1b13\u0001\u0000\u0000\u0000\u1b13\u1b15\u0001\u0000"+
"\u0000\u0000\u1b14\u1ae1\u0001\u0000\u0000\u0000\u1b14\u1aee\u0001\u0000"+
"\u0000\u0000\u1b14\u1afb\u0001\u0000\u0000\u0000\u1b14\u1b08\u0001\u0000"+
"\u0000\u0000\u1b15\u021b\u0001\u0000\u0000\u0000\u1b16\u1b1f\u0005\u00b6"+
"\u0000\u0000\u1b17\u1b1c\u0003\u027c\u013e\u0000\u1b18\u1b19\u0005\u00b8"+
"\u0000\u0000\u1b19\u1b1b\u0003\u027c\u013e\u0000\u1b1a\u1b18\u0001\u0000"+
"\u0000\u0000\u1b1b\u1b1e\u0001\u0000\u0000\u0000\u1b1c\u1b1a\u0001\u0000"+
"\u0000\u0000\u1b1c\u1b1d\u0001\u0000\u0000\u0000\u1b1d\u1b20\u0001\u0000"+
"\u0000\u0000\u1b1e\u1b1c\u0001\u0000\u0000\u0000\u1b1f\u1b17\u0001\u0000"+
"\u0000\u0000\u1b1f\u1b20\u0001\u0000\u0000\u0000\u1b20\u1b21\u0001\u0000"+
"\u0000\u0000\u1b21\u1b22\u0005\u00b7\u0000\u0000\u1b22\u021d\u0001\u0000"+
"\u0000\u0000\u1b23\u1b24\u0005\u0182\u0000\u0000\u1b24\u1b25\u0003\u0280"+
"\u0140\u0000\u1b25\u021f\u0001\u0000\u0000\u0000\u1b26\u1b2d\u0003\u0222"+
"\u0111\u0000\u1b27\u1b29\u0005\u00b8\u0000\u0000\u1b28\u1b27\u0001\u0000"+
"\u0000\u0000\u1b28\u1b29\u0001\u0000\u0000\u0000\u1b29\u1b2a\u0001\u0000"+
"\u0000\u0000\u1b2a\u1b2c\u0003\u0222\u0111\u0000\u1b2b\u1b28\u0001\u0000"+
"\u0000\u0000\u1b2c\u1b2f\u0001\u0000\u0000\u0000\u1b2d\u1b2b\u0001\u0000"+
"\u0000\u0000\u1b2d\u1b2e\u0001\u0000\u0000\u0000\u1b2e\u1b30\u0001\u0000"+
"\u0000\u0000\u1b2f\u1b2d\u0001\u0000\u0000\u0000\u1b30\u1b31\u0005\u02c6"+
"\u0000\u0000\u1b31\u0221\u0001\u0000\u0000\u0000\u1b32\u1b40\u0003\u02ca"+
"\u0165\u0000\u1b33\u1b34\u0005\u00b6\u0000\u0000\u1b34\u1b3b\u0003\u0224"+
"\u0112\u0000\u1b35\u1b37\u0005\u00b8\u0000\u0000\u1b36\u1b35\u0001\u0000"+
"\u0000\u0000\u1b36\u1b37\u0001\u0000\u0000\u0000\u1b37\u1b38\u0001\u0000"+
"\u0000\u0000\u1b38\u1b3a\u0003\u0224\u0112\u0000\u1b39\u1b36\u0001\u0000"+
"\u0000\u0000\u1b3a\u1b3d\u0001\u0000\u0000\u0000\u1b3b\u1b39\u0001\u0000"+
"\u0000\u0000\u1b3b\u1b3c\u0001\u0000\u0000\u0000\u1b3c\u1b3e\u0001\u0000"+
"\u0000\u0000\u1b3d\u1b3b\u0001\u0000\u0000\u0000\u1b3e\u1b3f\u0005\u00b7"+
"\u0000\u0000\u1b3f\u1b41\u0001\u0000\u0000\u0000\u1b40\u1b33\u0001\u0000"+
"\u0000\u0000\u1b40\u1b41\u0001\u0000\u0000\u0000\u1b41\u0223\u0001\u0000"+
"\u0000\u0000\u1b42\u1b48\u0003\u01c2\u00e1\u0000\u1b43\u1b46\u0005\u02b0"+
"\u0000\u0000\u1b44\u1b47\u0003\u02a0\u0150\u0000\u1b45\u1b47\u0003\u02ca"+
"\u0165\u0000\u1b46\u1b44\u0001\u0000\u0000\u0000\u1b46\u1b45\u0001\u0000"+
"\u0000\u0000\u1b47\u1b49\u0001\u0000\u0000\u0000\u1b48\u1b43\u0001\u0000"+
"\u0000\u0000\u1b48\u1b49\u0001\u0000\u0000\u0000\u1b49\u1b4c\u0001\u0000"+
"\u0000\u0000\u1b4a\u1b4c\u0003\u02a0\u0150\u0000\u1b4b\u1b42\u0001\u0000"+
"\u0000\u0000\u1b4b\u1b4a\u0001\u0000\u0000\u0000\u1b4c\u0225\u0001\u0000"+
"\u0000\u0000\u1b4d\u1b4e\u0003\u0250\u0128\u0000\u1b4e\u1b51\u0005\u02b0"+
"\u0000\u0000\u1b4f\u1b52\u0003\u027c\u013e\u0000\u1b50\u1b52\u0005\u0132"+
"\u0000\u0000\u1b51\u1b4f\u0001\u0000\u0000\u0000\u1b51\u1b50\u0001\u0000"+
"\u0000\u0000\u1b52\u0227\u0001\u0000\u0000\u0000\u1b53\u1b58\u0003\u0226"+
"\u0113\u0000\u1b54\u1b55\u0005\u00b8\u0000\u0000\u1b55\u1b57\u0003\u0226"+
"\u0113\u0000\u1b56\u1b54\u0001\u0000\u0000\u0000\u1b57\u1b5a\u0001\u0000"+
"\u0000\u0000\u1b58\u1b56\u0001\u0000\u0000\u0000\u1b58\u1b59\u0001\u0000"+
"\u0000\u0000\u1b59\u0229\u0001\u0000\u0000\u0000\u1b5a\u1b58\u0001\u0000"+
"\u0000\u0000\u1b5b\u1b5c\u0005\u01b2\u0000\u0000\u1b5c\u1b5d\u0005\u02a2"+
"\u0000\u0000\u1b5d\u1b5e\u0003\u02ca\u0165\u0000\u1b5e\u1b67\u0005\u00b6"+
"\u0000\u0000\u1b5f\u1b64\u0003\u027c\u013e\u0000\u1b60\u1b61\u0005\u00b8"+
"\u0000\u0000\u1b61\u1b63\u0003\u027c\u013e\u0000\u1b62\u1b60\u0001\u0000"+
"\u0000\u0000\u1b63\u1b66\u0001\u0000\u0000\u0000\u1b64\u1b62\u0001\u0000"+
"\u0000\u0000\u1b64\u1b65\u0001\u0000\u0000\u0000\u1b65\u1b68\u0001\u0000"+
"\u0000\u0000\u1b66\u1b64\u0001\u0000\u0000\u0000\u1b67\u1b5f\u0001\u0000"+
"\u0000\u0000\u1b67\u1b68\u0001\u0000\u0000\u0000\u1b68\u1b69\u0001\u0000"+
"\u0000\u0000\u1b69\u1b6a\u0005\u00b7\u0000\u0000\u1b6a\u1b6b\u0003\u02ca"+
"\u0165\u0000\u1b6b\u1b6c\u0005\u00d1\u0000\u0000\u1b6c\u1b71\u0003\u02ca"+
"\u0165\u0000\u1b6d\u1b6e\u0005\u00b8\u0000\u0000\u1b6e\u1b70\u0003\u02ca"+
"\u0165\u0000\u1b6f\u1b6d\u0001\u0000\u0000\u0000\u1b70\u1b73\u0001\u0000"+
"\u0000\u0000\u1b71\u1b6f\u0001\u0000\u0000\u0000\u1b71\u1b72\u0001\u0000"+
"\u0000\u0000\u1b72\u022b\u0001\u0000\u0000\u0000\u1b73\u1b71\u0001\u0000"+
"\u0000\u0000\u1b74\u1b76\u0003\u022e\u0117\u0000\u1b75\u1b74\u0001\u0000"+
"\u0000\u0000\u1b75\u1b76\u0001\u0000\u0000\u0000\u1b76\u1b78\u0001\u0000"+
"\u0000\u0000\u1b77\u1b79\u0003\u0232\u0119\u0000\u1b78\u1b77\u0001\u0000"+
"\u0000\u0000\u1b78\u1b79\u0001\u0000\u0000\u0000\u1b79\u022d\u0001\u0000"+
"\u0000\u0000\u1b7a\u1b7b\u0005\u01f2\u0000\u0000\u1b7b\u1b7c\u0005\u00f1"+
"\u0000\u0000\u1b7c\u1b81\u0003\u0230\u0118\u0000\u1b7d\u1b7e\u0005\u00b8"+
"\u0000\u0000\u1b7e\u1b80\u0003\u0230\u0118\u0000\u1b7f\u1b7d\u0001\u0000"+
"\u0000\u0000\u1b80\u1b83\u0001\u0000\u0000\u0000\u1b81\u1b7f\u0001\u0000"+
"\u0000\u0000\u1b81\u1b82\u0001\u0000\u0000\u0000\u1b82\u022f\u0001\u0000"+
"\u0000\u0000\u1b83\u1b81\u0001\u0000\u0000\u0000\u1b84\u1b86\u0003\u027c"+
"\u013e\u0000\u1b85\u1b87\u0007 \u0000\u0000\u1b86\u1b85\u0001\u0000\u0000"+
"\u0000\u1b86\u1b87\u0001\u0000\u0000\u0000\u1b87\u1b8a\u0001\u0000\u0000"+
"\u0000\u1b88\u1b89\u0005\u01e9\u0000\u0000\u1b89\u1b8b\u0007D\u0000\u0000"+
"\u1b8a\u1b88\u0001\u0000\u0000\u0000\u1b8a\u1b8b\u0001\u0000\u0000\u0000"+
"\u1b8b\u0231\u0001\u0000\u0000\u0000\u1b8c\u1b8d\u0005\u01b9\u0000\u0000"+
"\u1b8d\u1b97\u0005\u02cf\u0000\u0000\u1b8e\u1b8f\u0005\u01b9\u0000\u0000"+
"\u1b8f\u1b90\u0005\u02cf\u0000\u0000\u1b90\u1b91\u0005\u01ec\u0000\u0000"+
"\u1b91\u1b97\u0005\u02cf\u0000\u0000\u1b92\u1b93\u0005\u01b9\u0000\u0000"+
"\u1b93\u1b94\u0005\u02cf\u0000\u0000\u1b94\u1b95\u0005\u00b8\u0000\u0000"+
"\u1b95\u1b97\u0005\u02cf\u0000\u0000\u1b96\u1b8c\u0001\u0000\u0000\u0000"+
"\u1b96\u1b8e\u0001\u0000\u0000\u0000\u1b96\u1b92\u0001\u0000\u0000\u0000"+
"\u1b97\u0233\u0001\u0000\u0000\u0000\u1b98\u1b99\u0005\u01f9\u0000\u0000"+
"\u1b99\u1b9a\u0005\u00f1\u0000\u0000\u1b9a\u1b9f\u0003\u027c\u013e\u0000"+
"\u1b9b\u1b9c\u0005\u00b8\u0000\u0000\u1b9c\u1b9e\u0003\u027c\u013e\u0000"+
"\u1b9d\u1b9b\u0001\u0000\u0000\u0000\u1b9e\u1ba1\u0001\u0000\u0000\u0000"+
"\u1b9f\u1b9d\u0001\u0000\u0000\u0000\u1b9f\u1ba0\u0001\u0000\u0000\u0000"+
"\u1ba0\u0235\u0001\u0000\u0000\u0000\u1ba1\u1b9f\u0001\u0000\u0000\u0000"+
"\u1ba2\u1ba4\u0005\u0196\u0000\u0000\u1ba3\u1ba2\u0001\u0000\u0000\u0000"+
"\u1ba3\u1ba4\u0001\u0000\u0000\u0000\u1ba4\u1bbb\u0001\u0000\u0000\u0000"+
"\u1ba5\u1bbb\u0005\u011c\u0000\u0000\u1ba6\u1ba8\u0005\u01b5\u0000\u0000"+
"\u1ba7\u1ba9\u0005\u01f3\u0000\u0000\u1ba8\u1ba7\u0001\u0000\u0000\u0000"+
"\u1ba8\u1ba9\u0001\u0000\u0000\u0000\u1ba9\u1bbb\u0001\u0000\u0000\u0000"+
"\u1baa\u1bac\u0005\u023b\u0000\u0000\u1bab\u1bad\u0005\u01f3\u0000\u0000"+
"\u1bac\u1bab\u0001\u0000\u0000\u0000\u1bac\u1bad\u0001\u0000\u0000\u0000"+
"\u1bad\u1bbb\u0001\u0000\u0000\u0000\u1bae\u1bb0\u0005\u0175\u0000\u0000"+
"\u1baf\u1bb1\u0005\u01f3\u0000\u0000\u1bb0\u1baf\u0001\u0000\u0000\u0000"+
"\u1bb0\u1bb1\u0001\u0000\u0000\u0000\u1bb1\u1bbb\u0001\u0000\u0000\u0000"+
"\u1bb2\u1bb3\u0005\u01b5\u0000\u0000\u1bb3\u1bbb\u0005\u024c\u0000\u0000"+
"\u1bb4\u1bb5\u0005\u023b\u0000\u0000\u1bb5\u1bbb\u0005\u024c\u0000\u0000"+
"\u1bb6\u1bb7\u0005\u01b5\u0000\u0000\u1bb7\u1bbb\u0005\u00ce\u0000\u0000"+
"\u1bb8\u1bb9\u0005\u023b\u0000\u0000\u1bb9\u1bbb\u0005\u00ce\u0000\u0000"+
"\u1bba\u1ba3\u0001\u0000\u0000\u0000\u1bba\u1ba5\u0001\u0000\u0000\u0000"+
"\u1bba\u1ba6\u0001\u0000\u0000\u0000\u1bba\u1baa\u0001\u0000\u0000\u0000"+
"\u1bba\u1bae\u0001\u0000\u0000\u0000\u1bba\u1bb2\u0001\u0000\u0000\u0000"+
"\u1bba\u1bb4\u0001\u0000\u0000\u0000\u1bba\u1bb6\u0001\u0000\u0000\u0000"+
"\u1bba\u1bb8\u0001\u0000\u0000\u0000\u1bbb\u0237\u0001\u0000\u0000\u0000"+
"\u1bbc\u1bbd\u0005\u01ed\u0000\u0000\u1bbd\u1bc1\u0003\u0280\u0140\u0000"+
"\u1bbe\u1bbf\u0005\u0297\u0000\u0000\u1bbf\u1bc1\u0003\u023a\u011d\u0000"+
"\u1bc0\u1bbc\u0001\u0000\u0000\u0000\u1bc0\u1bbe\u0001\u0000\u0000\u0000"+
"\u1bc1\u0239\u0001\u0000\u0000\u0000\u1bc2\u1bc3\u0005\u00b6\u0000\u0000"+
"\u1bc3\u1bc4\u0003\u023c\u011e\u0000\u1bc4\u1bc5\u0005\u00b7\u0000\u0000"+
"\u1bc5\u023b\u0001\u0000\u0000\u0000\u1bc6\u1bcb\u0003\u02c6\u0163\u0000"+
"\u1bc7\u1bc8\u0005\u00b8\u0000\u0000\u1bc8\u1bca\u0003\u02c6\u0163\u0000"+
"\u1bc9\u1bc7\u0001\u0000\u0000\u0000\u1bca\u1bcd\u0001\u0000\u0000\u0000"+
"\u1bcb\u1bc9\u0001\u0000\u0000\u0000\u1bcb\u1bcc\u0001\u0000\u0000\u0000"+
"\u1bcc\u023d\u0001\u0000\u0000\u0000\u1bcd\u1bcb\u0001\u0000\u0000\u0000"+
"\u1bce\u1bcf\u0005\u02c8\u0000\u0000\u1bcf\u1bd0\u0003\u02ca\u0165\u0000"+
"\u1bd0\u1bd3\u0005\u00b6\u0000\u0000\u1bd1\u1bd4\u0003\u0246\u0123\u0000"+
"\u1bd2\u1bd4\u0003\u023c\u011e\u0000\u1bd3\u1bd1\u0001\u0000\u0000\u0000"+
"\u1bd3\u1bd2\u0001\u0000\u0000\u0000\u1bd3\u1bd4\u0001\u0000\u0000\u0000"+
"\u1bd4\u1bd5\u0001\u0000\u0000\u0000\u1bd5\u1bd6\u0005\u00b7\u0000\u0000"+
"\u1bd6\u023f\u0001\u0000\u0000\u0000\u1bd7\u1bd9\u0003\u0250\u0128\u0000"+
"\u1bd8\u1bda\u0003\u023e\u011f\u0000\u1bd9\u1bd8\u0001\u0000\u0000\u0000"+
"\u1bd9\u1bda\u0001\u0000\u0000\u0000\u1bda\u1bdc\u0001\u0000\u0000\u0000"+
"\u1bdb\u1bdd\u0003\u0242\u0121\u0000\u1bdc\u1bdb\u0001\u0000\u0000\u0000"+
"\u1bdc\u1bdd\u0001\u0000\u0000\u0000\u1bdd\u1bdf\u0001\u0000\u0000\u0000"+
"\u1bde\u1be0\u0003\u02c4\u0162\u0000\u1bdf\u1bde\u0001\u0000\u0000\u0000"+
"\u1bdf\u1be0\u0001\u0000\u0000\u0000\u1be0\u1be2\u0001\u0000\u0000\u0000"+
"\u1be1\u1be3\u0003\u029e\u014f\u0000\u1be2\u1be1\u0001\u0000\u0000\u0000"+
"\u1be2\u1be3\u0001\u0000\u0000\u0000\u1be3\u1be5\u0001\u0000\u0000\u0000"+
"\u1be4\u1be6\u0003\u0274\u013a\u0000\u1be5\u1be4\u0001\u0000\u0000\u0000"+
"\u1be5\u1be6\u0001\u0000\u0000\u0000\u1be6\u1be7\u0001\u0000\u0000\u0000"+
"\u1be7\u1be9\u0003\u024e\u0127\u0000\u1be8\u1bea\u0003\u02c0\u0160\u0000"+
"\u1be9\u1be8\u0001\u0000\u0000\u0000\u1be9\u1bea\u0001\u0000\u0000\u0000"+
"\u1bea\u1bec\u0001\u0000\u0000\u0000\u1beb\u1bed\u0003\u0216\u010b\u0000"+
"\u1bec\u1beb\u0001\u0000\u0000\u0000\u1bec\u1bed\u0001\u0000\u0000\u0000"+
"\u1bed\u1bf1\u0001\u0000\u0000\u0000\u1bee\u1bf0\u0003\u022a\u0115\u0000"+
"\u1bef\u1bee\u0001\u0000\u0000\u0000\u1bf0\u1bf3\u0001\u0000\u0000\u0000"+
"\u1bf1\u1bef\u0001\u0000\u0000\u0000\u1bf1\u1bf2\u0001\u0000\u0000\u0000"+
"\u1bf2\u1c0b\u0001\u0000\u0000\u0000\u1bf3\u1bf1\u0001\u0000\u0000\u0000"+
"\u1bf4\u1bf5\u0005\u00b6\u0000\u0000\u1bf5\u1bf6\u0003\u01f0\u00f8\u0000"+
"\u1bf6\u1bf7\u0005\u00b7\u0000\u0000\u1bf7\u1bfb\u0003\u024e\u0127\u0000"+
"\u1bf8\u1bfa\u0003\u022a\u0115\u0000\u1bf9\u1bf8\u0001\u0000\u0000\u0000"+
"\u1bfa\u1bfd\u0001\u0000\u0000\u0000\u1bfb\u1bf9\u0001\u0000\u0000\u0000"+
"\u1bfb\u1bfc\u0001\u0000\u0000\u0000\u1bfc\u1c0b\u0001\u0000\u0000\u0000"+
"\u1bfd\u1bfb\u0001\u0000\u0000\u0000\u1bfe\u1bff\u0003\u02ca\u0165\u0000"+
"\u1bff\u1c01\u0005\u00b6\u0000\u0000\u1c00\u1c02\u0003\u0246\u0123\u0000"+
"\u1c01\u1c00\u0001\u0000\u0000\u0000\u1c01\u1c02\u0001\u0000\u0000\u0000"+
"\u1c02\u1c03\u0001\u0000\u0000\u0000\u1c03\u1c04\u0005\u00b7\u0000\u0000"+
"\u1c04\u1c05\u0003\u024e\u0127\u0000\u1c05\u1c0b\u0001\u0000\u0000\u0000"+
"\u1c06\u1c07\u0005\u00b6\u0000\u0000\u1c07\u1c08\u0003\u020e\u0107\u0000"+
"\u1c08\u1c09\u0005\u00b7\u0000\u0000\u1c09\u1c0b\u0001\u0000\u0000\u0000"+
"\u1c0a\u1bd7\u0001\u0000\u0000\u0000\u1c0a\u1bf4\u0001\u0000\u0000\u0000"+
"\u1c0a\u1bfe\u0001\u0000\u0000\u0000\u1c0a\u1c06\u0001\u0000\u0000\u0000"+
"\u1c0b\u0241\u0001\u0000\u0000\u0000\u1c0c\u1c0d\u0005\u0193\u0000\u0000"+
"\u1c0d\u1c0e\u0003\u02ca\u0165\u0000\u1c0e\u0243\u0001\u0000\u0000\u0000"+
"\u1c0f\u1c10\u0005\u0216\u0000\u0000\u1c10\u1c11\u0005\u00b6\u0000\u0000"+
"\u1c11\u1c12\u0003\u0246\u0123\u0000\u1c12\u1c13\u0005\u00b7\u0000\u0000"+
"\u1c13\u0245\u0001\u0000\u0000\u0000\u1c14\u1c19\u0003\u0248\u0124\u0000"+
"\u1c15\u1c16\u0005\u00b8\u0000\u0000\u1c16\u1c18\u0003\u0248\u0124\u0000"+
"\u1c17\u1c15\u0001\u0000\u0000\u0000\u1c18\u1c1b\u0001\u0000\u0000\u0000"+
"\u1c19\u1c17\u0001\u0000\u0000\u0000\u1c19\u1c1a\u0001\u0000\u0000\u0000"+
"\u1c1a\u0247\u0001\u0000\u0000\u0000\u1c1b\u1c19\u0001\u0000\u0000\u0000"+
"\u1c1c\u1c1d\u0003\u024a\u0125\u0000\u1c1d\u1c1e\u0005\u02b0\u0000\u0000"+
"\u1c1e\u1c1f\u0003\u024c\u0126\u0000\u1c1f\u0249\u0001\u0000\u0000\u0000"+
"\u1c20\u1c23\u0003\u02ca\u0165\u0000\u1c21\u1c23\u0003\u02a0\u0150\u0000"+
"\u1c22\u1c20\u0001\u0000\u0000\u0000\u1c22\u1c21\u0001\u0000\u0000\u0000"+
"\u1c23\u024b\u0001\u0000\u0000\u0000\u1c24\u1c27\u0003\u02ca\u0165\u0000"+
"\u1c25\u1c27\u0003\u02a0\u0150\u0000\u1c26\u1c24\u0001\u0000\u0000\u0000"+
"\u1c26\u1c25\u0001\u0000\u0000\u0000\u1c27\u024d\u0001\u0000\u0000\u0000"+
"\u1c28\u1c2a\u0005\u00d1\u0000\u0000\u1c29\u1c28\u0001\u0000\u0000\u0000"+
"\u1c29\u1c2a\u0001\u0000\u0000\u0000\u1c2a\u1c2b\u0001\u0000\u0000\u0000"+
"\u1c2b\u1c2d\u0003\u02cc\u0166\u0000\u1c2c\u1c2e\u0003\u023a\u011d\u0000"+
"\u1c2d\u1c2c\u0001\u0000\u0000\u0000\u1c2d\u1c2e\u0001\u0000\u0000\u0000"+
"\u1c2e\u1c30\u0001\u0000\u0000\u0000\u1c2f\u1c29\u0001\u0000\u0000\u0000"+
"\u1c2f\u1c30\u0001\u0000\u0000\u0000\u1c30\u024f\u0001\u0000\u0000\u0000"+
"\u1c31\u1c36\u0003\u02c6\u0163\u0000\u1c32\u1c33\u0005\u00b9\u0000\u0000"+
"\u1c33\u1c35\u0003\u02c6\u0163\u0000\u1c34\u1c32\u0001\u0000\u0000\u0000"+
"\u1c35\u1c38\u0001\u0000\u0000\u0000\u1c36\u1c34\u0001\u0000\u0000\u0000"+
"\u1c36\u1c37\u0001\u0000\u0000\u0000\u1c37\u0251\u0001\u0000\u0000\u0000"+
"\u1c38\u1c36\u0001\u0000\u0000\u0000\u1c39\u1c3e\u0003\u0254\u012a\u0000"+
"\u1c3a\u1c3b\u0005\u00b8\u0000\u0000\u1c3b\u1c3d\u0003\u0254\u012a\u0000"+
"\u1c3c\u1c3a\u0001\u0000\u0000\u0000\u1c3d\u1c40\u0001\u0000\u0000\u0000"+
"\u1c3e\u1c3c\u0001\u0000\u0000\u0000\u1c3e\u1c3f\u0001\u0000\u0000\u0000"+
"\u1c3f\u0253\u0001\u0000\u0000\u0000\u1c40\u1c3e\u0001\u0000\u0000\u0000"+
"\u1c41\u1c44\u0003\u02ca\u0165\u0000\u1c42\u1c43\u0005\u0107\u0000\u0000"+
"\u1c43\u1c45\u0005\u02ca\u0000\u0000\u1c44\u1c42\u0001\u0000\u0000\u0000"+
"\u1c44\u1c45\u0001\u0000\u0000\u0000\u1c45\u0255\u0001\u0000\u0000\u0000"+
"\u1c46\u1c4b\u0003\u0258\u012c\u0000\u1c47\u1c48\u0005\u00b8\u0000\u0000"+
"\u1c48\u1c4a\u0003\u0258\u012c\u0000\u1c49\u1c47\u0001\u0000\u0000\u0000"+
"\u1c4a\u1c4d\u0001\u0000\u0000\u0000\u1c4b\u1c49\u0001\u0000\u0000\u0000"+
"\u1c4b\u1c4c\u0001\u0000\u0000\u0000\u1c4c\u0257\u0001\u0000\u0000\u0000"+
"\u1c4d\u1c4b\u0001\u0000\u0000\u0000\u1c4e\u1c4f\u0003\u02ca\u0165\u0000"+
"\u1c4f\u1c51\u0003\u02ae\u0157\u0000\u1c50\u1c52\u0005\u01ac\u0000\u0000"+
"\u1c51\u1c50\u0001\u0000\u0000\u0000\u1c51\u1c52\u0001\u0000\u0000\u0000"+
"\u1c52\u1c54\u0001\u0000\u0000\u0000\u1c53\u1c55\u0003\u0272\u0139\u0000"+
"\u1c54\u1c53\u0001\u0000\u0000\u0000\u1c54\u1c55\u0001\u0000\u0000\u0000"+
"\u1c55\u1c5f\u0001\u0000\u0000\u0000\u1c56\u1c57\u0005\u0178\u0000\u0000"+
"\u1c57\u1c59\u0005\u00d7\u0000\u0000\u1c58\u1c56\u0001\u0000\u0000\u0000"+
"\u1c58\u1c59\u0001\u0000\u0000\u0000\u1c59\u1c5a\u0001\u0000\u0000\u0000"+
"\u1c5a\u1c5b\u0005\u00d1\u0000\u0000\u1c5b\u1c5c\u0005\u00b6\u0000\u0000"+
"\u1c5c\u1c5d\u0003\u027c\u013e\u0000\u1c5d\u1c5e\u0005\u00b7\u0000\u0000"+
"\u1c5e\u1c60\u0001\u0000\u0000\u0000\u1c5f\u1c58\u0001\u0000\u0000\u0000"+
"\u1c5f\u1c60\u0001\u0000\u0000\u0000\u1c60\u1c65\u0001\u0000\u0000\u0000"+
"\u1c61\u1c63\u0005\u01e7\u0000\u0000\u1c62\u1c61\u0001\u0000\u0000\u0000"+
"\u1c62\u1c63\u0001\u0000\u0000\u0000\u1c63\u1c64\u0001\u0000\u0000\u0000"+
"\u1c64\u1c66\u0005\u01e8\u0000\u0000\u1c65\u1c62\u0001\u0000\u0000\u0000"+
"\u1c65\u1c66\u0001\u0000\u0000\u0000\u1c66\u1c6e\u0001\u0000\u0000\u0000"+
"\u1c67\u1c6c\u0005\u00d6\u0000\u0000\u1c68\u1c69\u0005\u00b6\u0000\u0000"+
"\u1c69\u1c6a\u0003\u02d0\u0168\u0000\u1c6a\u1c6b\u0005\u00b7\u0000\u0000"+
"\u1c6b\u1c6d\u0001\u0000\u0000\u0000\u1c6c\u1c68\u0001\u0000\u0000\u0000"+
"\u1c6c\u1c6d\u0001\u0000\u0000\u0000\u1c6d\u1c6f\u0001\u0000\u0000\u0000"+
"\u1c6e\u1c67\u0001\u0000\u0000\u0000\u1c6e\u1c6f\u0001\u0000\u0000\u0000"+
"\u1c6f\u1c88\u0001\u0000\u0000\u0000\u1c70\u1c86\u0005\u0132\u0000\u0000"+
"\u1c71\u1c87\u0005\u01e8\u0000\u0000\u1c72\u1c74\u0005\u02b8\u0000\u0000"+
"\u1c73\u1c72\u0001\u0000\u0000\u0000\u1c73\u1c74\u0001\u0000\u0000\u0000"+
"\u1c74\u1c75\u0001\u0000\u0000\u0000\u1c75\u1c87\u0005\u02cf\u0000\u0000"+
"\u1c76\u1c78\u0005\u02b8\u0000\u0000\u1c77\u1c76\u0001\u0000\u0000\u0000"+
"\u1c77\u1c78\u0001\u0000\u0000\u0000\u1c78\u1c79\u0001\u0000\u0000\u0000"+
"\u1c79\u1c87\u0005\u02d1\u0000\u0000\u1c7a\u1c87\u0005\u0206\u0000\u0000"+
"\u1c7b\u1c87\u0005\u014a\u0000\u0000\u1c7c\u1c87\u0005\u00e4\u0000\u0000"+
"\u1c7d\u1c87\u0005\u02ca\u0000\u0000\u1c7e\u1c87\u0005\u0120\u0000\u0000"+
"\u1c7f\u1c84\u0005\u0122\u0000\u0000\u1c80\u1c81\u0005\u00b6\u0000\u0000"+
"\u1c81\u1c82\u0003\u02d0\u0168\u0000\u1c82\u1c83\u0005\u00b7\u0000\u0000"+
"\u1c83\u1c85\u0001\u0000\u0000\u0000\u1c84\u1c80\u0001\u0000\u0000\u0000"+
"\u1c84\u1c85\u0001\u0000\u0000\u0000\u1c85\u1c87\u0001\u0000\u0000\u0000"+
"\u1c86\u1c71\u0001\u0000\u0000\u0000\u1c86\u1c73\u0001\u0000\u0000\u0000"+
"\u1c86\u1c77\u0001\u0000\u0000\u0000\u1c86\u1c7a\u0001\u0000\u0000\u0000"+
"\u1c86\u1c7b\u0001\u0000\u0000\u0000\u1c86\u1c7c\u0001\u0000\u0000\u0000"+
"\u1c86\u1c7d\u0001\u0000\u0000\u0000\u1c86\u1c7e\u0001\u0000\u0000\u0000"+
"\u1c86\u1c7f\u0001\u0000\u0000\u0000\u1c87\u1c89\u0001\u0000\u0000\u0000"+
"\u1c88\u1c70\u0001\u0000\u0000\u0000\u1c88\u1c89\u0001\u0000\u0000\u0000"+
"\u1c89\u1c93\u0001\u0000\u0000\u0000\u1c8a\u1c8b\u0005\u01ed\u0000\u0000"+
"\u1c8b\u1c8c\u0005\u0294\u0000\u0000\u1c8c\u1c91\u0005\u0122\u0000\u0000"+
"\u1c8d\u1c8e\u0005\u00b6\u0000\u0000\u1c8e\u1c8f\u0003\u02d0\u0168\u0000"+
"\u1c8f\u1c90\u0005\u00b7\u0000\u0000\u1c90\u1c92\u0001\u0000\u0000\u0000"+
"\u1c91\u1c8d\u0001\u0000\u0000\u0000\u1c91\u1c92\u0001\u0000\u0000\u0000"+
"\u1c92\u1c94\u0001\u0000\u0000\u0000\u1c93\u1c8a\u0001\u0000\u0000\u0000"+
"\u1c93\u1c94\u0001\u0000\u0000\u0000\u1c94\u1c97\u0001\u0000\u0000\u0000"+
"\u1c95\u1c96\u0005\u0107\u0000\u0000\u1c96\u1c98\u0005\u02ca\u0000\u0000"+
"\u1c97\u1c95\u0001\u0000\u0000\u0000\u1c97\u1c98\u0001\u0000\u0000\u0000"+
"\u1c98\u0259\u0001\u0000\u0000\u0000\u1c99\u1c9e\u0003\u025c\u012e\u0000"+
"\u1c9a\u1c9b\u0005\u00b8\u0000\u0000\u1c9b\u1c9d\u0003\u025c\u012e\u0000"+
"\u1c9c\u1c9a\u0001\u0000\u0000\u0000\u1c9d\u1ca0\u0001\u0000\u0000\u0000"+
"\u1c9e\u1c9c\u0001\u0000\u0000\u0000\u1c9e\u1c9f\u0001\u0000\u0000\u0000"+
"\u1c9f\u025b\u0001\u0000\u0000\u0000\u1ca0\u1c9e\u0001\u0000\u0000\u0000"+
"\u1ca1\u1ca5\u0005\u0193\u0000\u0000\u1ca2\u1ca3\u0005\u018e\u0000\u0000"+
"\u1ca3\u1ca4\u0005\u01e7\u0000\u0000\u1ca4\u1ca6\u0005\u015b\u0000\u0000"+
"\u1ca5\u1ca2\u0001\u0000\u0000\u0000\u1ca5\u1ca6\u0001\u0000\u0000\u0000"+
"\u1ca6\u1ca7\u0001\u0000\u0000\u0000\u1ca7\u1ca8\u0003\u02ca\u0165\u0000"+
"\u1ca8\u1cab\u0003\u023a\u011d\u0000\u1ca9\u1caa\u0005\u0297\u0000\u0000"+
"\u1caa\u1cac\u00077\u0000\u0000\u1cab\u1ca9\u0001\u0000\u0000\u0000\u1cab"+
"\u1cac\u0001\u0000\u0000\u0000\u1cac\u1cb2\u0001\u0000\u0000\u0000\u1cad"+
"\u1cae\u0005\u0216\u0000\u0000\u1cae\u1caf\u0005\u00b6\u0000\u0000\u1caf"+
"\u1cb0\u0003\u0246\u0123\u0000\u1cb0\u1cb1\u0005\u00b7\u0000\u0000\u1cb1"+
"\u1cb3\u0001\u0000\u0000\u0000\u1cb2\u1cad\u0001\u0000\u0000\u0000\u1cb2"+
"\u1cb3\u0001\u0000\u0000\u0000\u1cb3\u1cb6\u0001\u0000\u0000\u0000\u1cb4"+
"\u1cb5\u0005\u0107\u0000\u0000\u1cb5\u1cb7\u0005\u02ca\u0000\u0000\u1cb6"+
"\u1cb4\u0001\u0000\u0000\u0000\u1cb6\u1cb7\u0001\u0000\u0000\u0000\u1cb7"+
"\u025d\u0001\u0000\u0000\u0000\u1cb8\u1cbd\u0003\u0260\u0130\u0000\u1cb9"+
"\u1cba\u0005\u00b8\u0000\u0000\u1cba\u1cbc\u0003\u0260\u0130\u0000\u1cbb"+
"\u1cb9\u0001\u0000\u0000\u0000\u1cbc\u1cbf\u0001\u0000\u0000\u0000\u1cbd"+
"\u1cbb\u0001\u0000\u0000\u0000\u1cbd\u1cbe\u0001\u0000\u0000\u0000\u1cbe"+
"\u025f\u0001\u0000\u0000\u0000\u1cbf\u1cbd\u0001\u0000\u0000\u0000\u1cc0"+
"\u1cc5\u0003\u0262\u0131\u0000\u1cc1\u1cc5\u0003\u0264\u0132\u0000\u1cc2"+
"\u1cc5\u0003\u0266\u0133\u0000\u1cc3\u1cc5\u0003\u0268\u0134\u0000\u1cc4"+
"\u1cc0\u0001\u0000\u0000\u0000\u1cc4\u1cc1\u0001\u0000\u0000\u0000\u1cc4"+
"\u1cc2\u0001\u0000\u0000\u0000\u1cc4\u1cc3\u0001\u0000\u0000\u0000\u1cc5"+
"\u1cca\u0001\u0000\u0000\u0000\u1cc6\u1cc7\u0005\u00b6\u0000\u0000\u1cc7"+
"\u1cc8\u0003\u0246\u0123\u0000\u1cc8\u1cc9\u0005\u00b7\u0000\u0000\u1cc9"+
"\u1ccb\u0001\u0000\u0000\u0000\u1cca\u1cc6\u0001\u0000\u0000\u0000\u1cca"+
"\u1ccb\u0001\u0000\u0000\u0000\u1ccb\u0261\u0001\u0000\u0000\u0000\u1ccc"+
"\u1cd0\u0005\u01f9\u0000\u0000\u1ccd\u1cce\u0005\u018e\u0000\u0000\u1cce"+
"\u1ccf\u0005\u01e7\u0000\u0000\u1ccf\u1cd1\u0005\u015b\u0000\u0000\u1cd0"+
"\u1ccd\u0001\u0000\u0000\u0000\u1cd0\u1cd1\u0001\u0000\u0000\u0000\u1cd1"+
"\u1cd2\u0001\u0000\u0000\u0000\u1cd2\u1cd3\u0003\u02ca\u0165\u0000\u1cd3"+
"\u1cd4\u0005\u0299\u0000\u0000\u1cd4\u1cd5\u0005\u01b6\u0000\u0000\u1cd5"+
"\u1cd8\u0005\u0279\u0000\u0000\u1cd6\u1cd9\u0005\u01d2\u0000\u0000\u1cd7"+
"\u1cd9\u0003\u026a\u0135\u0000\u1cd8\u1cd6\u0001\u0000\u0000\u0000\u1cd8"+
"\u1cd7\u0001\u0000\u0000\u0000\u1cd9\u0263\u0001\u0000\u0000\u0000\u1cda"+
"\u1cde\u0005\u01f9\u0000\u0000\u1cdb\u1cdc\u0005\u018e\u0000\u0000\u1cdc"+
"\u1cdd\u0005\u01e7\u0000\u0000\u1cdd\u1cdf\u0005\u015b\u0000\u0000\u1cde"+
"\u1cdb\u0001\u0000\u0000\u0000\u1cde\u1cdf\u0001\u0000\u0000\u0000\u1cdf"+
"\u1ce0\u0001\u0000\u0000\u0000\u1ce0\u1ce1\u0003\u02ca\u0165\u0000\u1ce1"+
"\u1ce2\u0005\u0299\u0000\u0000\u1ce2\u1ce3\u0005\u00bb\u0000\u0000\u1ce3"+
"\u1ce4\u0003\u026a\u0135\u0000\u1ce4\u1ce5\u0005\u00b8\u0000\u0000\u1ce5"+
"\u1ce6\u0003\u026a\u0135\u0000\u1ce6\u1ce7\u0005\u00b7\u0000\u0000\u1ce7"+
"\u0265\u0001\u0000\u0000\u0000\u1ce8\u1ce9\u0005\u0172\u0000\u0000\u1ce9"+
"\u1cea\u0003\u026a\u0135\u0000\u1cea\u1ceb\u0005\u027e\u0000\u0000\u1ceb"+
"\u1cec\u0003\u026a\u0135\u0000\u1cec\u1ced\u0005\u019d\u0000\u0000\u1ced"+
"\u1cef\u0005\u02cf\u0000\u0000\u1cee\u1cf0\u0003\u02aa\u0155\u0000\u1cef"+
"\u1cee\u0001\u0000\u0000\u0000\u1cef\u1cf0\u0001\u0000\u0000\u0000\u1cf0"+
"\u0267\u0001\u0000\u0000\u0000\u1cf1\u1cf5\u0005\u01f9\u0000\u0000\u1cf2"+
"\u1cf3\u0005\u018e\u0000\u0000\u1cf3\u1cf4\u0005\u01e7\u0000\u0000\u1cf4"+
"\u1cf6\u0005\u015b\u0000\u0000\u1cf5\u1cf2\u0001\u0000\u0000\u0000\u1cf5"+
"\u1cf6\u0001\u0000\u0000\u0000\u1cf6\u1cf7\u0001\u0000\u0000\u0000\u1cf7"+
"\u1d0a\u0003\u02ca\u0165\u0000\u1cf8\u1cf9\u0005\u0299\u0000\u0000\u1cf9"+
"\u1cfb\u0005\u0191\u0000\u0000\u1cfa\u1cf8\u0001\u0000\u0000\u0000\u1cfa"+
"\u1cfb\u0001\u0000\u0000\u0000\u1cfb\u1d08\u0001\u0000\u0000\u0000\u1cfc"+
"\u1cfd\u0005\u00b6\u0000\u0000\u1cfd\u1d02\u0003\u026a\u0135\u0000\u1cfe"+
"\u1cff\u0005\u00b8\u0000\u0000\u1cff\u1d01\u0003\u026a\u0135\u0000\u1d00"+
"\u1cfe\u0001\u0000\u0000\u0000\u1d01\u1d04\u0001\u0000\u0000\u0000\u1d02"+
"\u1d00\u0001\u0000\u0000\u0000\u1d02\u1d03\u0001\u0000\u0000\u0000\u1d03"+
"\u1d05\u0001\u0000\u0000\u0000\u1d04\u1d02\u0001\u0000\u0000\u0000\u1d05"+
"\u1d06\u0005\u00b7\u0000\u0000\u1d06\u1d09\u0001\u0000\u0000\u0000\u1d07"+
"\u1d09\u0003\u026a\u0135\u0000\u1d08\u1cfc\u0001\u0000\u0000\u0000\u1d08"+
"\u1d07\u0001\u0000\u0000\u0000\u1d09\u1d0b\u0001\u0000\u0000\u0000\u1d0a"+
"\u1cfa\u0001\u0000\u0000\u0000\u1d0a\u1d0b\u0001\u0000\u0000\u0000\u1d0b"+
"\u0269\u0001\u0000\u0000\u0000\u1d0c\u1d0d\u0005\u00b6\u0000\u0000\u1d0d"+
"\u1d12\u0003\u026c\u0136\u0000\u1d0e\u1d0f\u0005\u00b8\u0000\u0000\u1d0f"+
"\u1d11\u0003\u026c\u0136\u0000\u1d10\u1d0e\u0001\u0000\u0000\u0000\u1d11"+
"\u1d14\u0001\u0000\u0000\u0000\u1d12\u1d10\u0001\u0000\u0000\u0000\u1d12"+
"\u1d13\u0001\u0000\u0000\u0000\u1d13\u1d15\u0001\u0000\u0000\u0000\u1d14"+
"\u1d12\u0001\u0000\u0000\u0000\u1d15\u1d16\u0005\u00b7\u0000\u0000\u1d16"+
"\u026b\u0001\u0000\u0000\u0000\u1d17\u1d19\u0005\u02b8\u0000\u0000\u1d18"+
"\u1d17\u0001\u0000\u0000\u0000\u1d18\u1d19\u0001\u0000\u0000\u0000\u1d19"+
"\u1d1a\u0001\u0000\u0000\u0000\u1d1a\u1d1f\u0005\u02cf\u0000\u0000\u1d1b"+
"\u1d1f\u0005\u02ca\u0000\u0000\u1d1c\u1d1f\u0005\u01d2\u0000\u0000\u1d1d"+
"\u1d1f\u0005\u01e8\u0000\u0000\u1d1e\u1d18\u0001\u0000\u0000\u0000\u1d1e"+
"\u1d1b\u0001\u0000\u0000\u0000\u1d1e\u1d1c\u0001\u0000\u0000\u0000\u1d1e"+
"\u1d1d\u0001\u0000\u0000\u0000\u1d1f\u026d\u0001\u0000\u0000\u0000\u1d20"+
"\u1d25\u0003\u0270\u0138\u0000\u1d21\u1d22\u0005\u00b8\u0000\u0000\u1d22"+
"\u1d24\u0003\u0270\u0138\u0000\u1d23\u1d21\u0001\u0000\u0000\u0000\u1d24"+
"\u1d27\u0001\u0000\u0000\u0000\u1d25\u1d23\u0001\u0000\u0000\u0000\u1d25"+
"\u1d26\u0001\u0000\u0000\u0000\u1d26\u026f\u0001\u0000\u0000\u0000\u1d27"+
"\u1d25\u0001\u0000\u0000\u0000\u1d28\u1d29\u0003\u02ca\u0165\u0000\u1d29"+
"\u1d2d\u0003\u023a\u011d\u0000\u1d2a\u1d2b\u0005\u0148\u0000\u0000\u1d2b"+
"\u1d2c\u0005\u01ac\u0000\u0000\u1d2c\u1d2e\u0003\u023a\u011d\u0000\u1d2d"+
"\u1d2a\u0001\u0000\u0000\u0000\u1d2d\u1d2e\u0001\u0000\u0000\u0000\u1d2e"+
"\u1d30\u0001\u0000\u0000\u0000\u1d2f\u1d31\u0003\u0244\u0122\u0000\u1d30"+
"\u1d2f\u0001\u0000\u0000\u0000\u1d30\u1d31\u0001\u0000\u0000\u0000\u1d31"+
"\u0271\u0001\u0000\u0000\u0000\u1d32\u1d33\u0007E\u0000\u0000\u1d33\u0273"+
"\u0001\u0000\u0000\u0000\u1d34\u1d35\u0005\u0271\u0000\u0000\u1d35\u1d36"+
"\u0005\u00b6\u0000\u0000\u1d36\u1d3b\u0005\u02cf\u0000\u0000\u1d37\u1d38"+
"\u0005\u00b8\u0000\u0000\u1d38\u1d3a\u0005\u02cf\u0000\u0000\u1d39\u1d37"+
"\u0001\u0000\u0000\u0000\u1d3a\u1d3d\u0001\u0000\u0000\u0000\u1d3b\u1d39"+
"\u0001\u0000\u0000\u0000\u1d3b\u1d3c\u0001\u0000\u0000\u0000\u1d3c\u1d3e"+
"\u0001\u0000\u0000\u0000\u1d3d\u1d3b\u0001\u0000\u0000\u0000\u1d3e\u1d3f"+
"\u0005\u00b7\u0000\u0000\u1d3f\u0275\u0001\u0000\u0000\u0000\u1d40\u1d41"+
"\u0005\u0299\u0000\u0000\u1d41\u1d46\u0003\u0282\u0141\u0000\u1d42\u1d43"+
"\u0005\u00b8\u0000\u0000\u1d43\u1d45\u0003\u0282\u0141\u0000\u1d44\u1d42"+
"\u0001\u0000\u0000\u0000\u1d45\u1d48\u0001\u0000\u0000\u0000\u1d46\u1d44"+
"\u0001\u0000\u0000\u0000\u1d46\u1d47\u0001\u0000\u0000\u0000\u1d47\u0277"+
"\u0001\u0000\u0000\u0000\u1d48\u1d46\u0001\u0000\u0000\u0000\u1d49\u1d4e"+
"\u0003\u027c\u013e\u0000\u1d4a\u1d4c\u0005\u00d1\u0000\u0000\u1d4b\u1d4a"+
"\u0001\u0000\u0000\u0000\u1d4b\u1d4c\u0001\u0000\u0000\u0000\u1d4c\u1d4d"+
"\u0001\u0000\u0000\u0000\u1d4d\u1d4f\u0003\u01c2\u00e1\u0000\u1d4e\u1d4b"+
"\u0001\u0000\u0000\u0000\u1d4e\u1d4f\u0001\u0000\u0000\u0000\u1d4f\u0279"+
"\u0001\u0000\u0000\u0000\u1d50\u1d55\u0003\u0278\u013c\u0000\u1d51\u1d52"+
"\u0005\u00b8\u0000\u0000\u1d52\u1d54\u0003\u0278\u013c\u0000\u1d53\u1d51"+
"\u0001\u0000\u0000\u0000\u1d54\u1d57\u0001\u0000\u0000\u0000\u1d55\u1d53"+
"\u0001\u0000\u0000\u0000\u1d55\u1d56\u0001\u0000\u0000\u0000\u1d56\u027b"+
"\u0001\u0000\u0000\u0000\u1d57\u1d55\u0001\u0000\u0000\u0000\u1d58\u1d5b"+
"\u0003\u0280\u0140\u0000\u1d59\u1d5b\u0003\u027e\u013f\u0000\u1d5a\u1d58"+
"\u0001\u0000\u0000\u0000\u1d5a\u1d59\u0001\u0000\u0000\u0000\u1d5b\u027d"+
"\u0001\u0000\u0000\u0000\u1d5c\u1d5d\u0003\u02c6\u0163\u0000\u1d5d\u1d5e"+
"\u0005\u02c4\u0000\u0000\u1d5e\u1d5f\u0003\u0280\u0140\u0000\u1d5f\u1d6d"+
"\u0001\u0000\u0000\u0000\u1d60\u1d61\u0005\u00b6\u0000\u0000\u1d61\u1d64"+
"\u0003\u02c6\u0163\u0000\u1d62\u1d63\u0005\u00b8\u0000\u0000\u1d63\u1d65"+
"\u0003\u02c6\u0163\u0000\u1d64\u1d62\u0001\u0000\u0000\u0000\u1d65\u1d66"+
"\u0001\u0000\u0000\u0000\u1d66\u1d64\u0001\u0000\u0000\u0000\u1d66\u1d67"+
"\u0001\u0000\u0000\u0000\u1d67\u1d68\u0001\u0000\u0000\u0000\u1d68\u1d69"+
"\u0005\u00b7\u0000\u0000\u1d69\u1d6a\u0005\u02c4\u0000\u0000\u1d6a\u1d6b"+
"\u0003\u0280\u0140\u0000\u1d6b\u1d6d\u0001\u0000\u0000\u0000\u1d6c\u1d5c"+
"\u0001\u0000\u0000\u0000\u1d6c\u1d60\u0001\u0000\u0000\u0000\u1d6d\u027f"+
"\u0001\u0000\u0000\u0000\u1d6e\u1d6f\u0006\u0140\uffff\uffff\u0000\u1d6f"+
"\u1d70\u0007F\u0000\u0000\u1d70\u1d85\u0003\u0280\u0140\t\u1d71\u1d72"+
"\u0005\u015b\u0000\u0000\u1d72\u1d73\u0005\u00b6\u0000\u0000\u1d73\u1d74"+
"\u0003\u01f0\u00f8\u0000\u1d74\u1d75\u0005\u00b7\u0000\u0000\u1d75\u1d85"+
"\u0001\u0000\u0000\u0000\u1d76\u1d77\u0007G\u0000\u0000\u1d77\u1d78\u0005"+
"\u00b6\u0000\u0000\u1d78\u1d79\u0003\u0288\u0144\u0000\u1d79\u1d7a\u0005"+
"\u00b7\u0000\u0000\u1d7a\u1d85\u0001\u0000\u0000\u0000\u1d7b\u1d7c\u0005"+
"\u01a3\u0000\u0000\u1d7c\u1d7d\u0005\u00b6\u0000\u0000\u1d7d\u1d7e\u0003"+
"\u0288\u0144\u0000\u1d7e\u1d7f\u0005\u00b7\u0000\u0000\u1d7f\u1d85\u0001"+
"\u0000\u0000\u0000\u1d80\u1d82\u0003\u0288\u0144\u0000\u1d81\u1d83\u0003"+
"\u0286\u0143\u0000\u1d82\u1d81\u0001\u0000\u0000\u0000\u1d82\u1d83\u0001"+
"\u0000\u0000\u0000\u1d83\u1d85\u0001\u0000\u0000\u0000\u1d84\u1d6e\u0001"+
"\u0000\u0000\u0000\u1d84\u1d71\u0001\u0000\u0000\u0000\u1d84\u1d76\u0001"+
"\u0000\u0000\u0000\u1d84\u1d7b\u0001\u0000\u0000\u0000\u1d84\u1d80\u0001"+
"\u0000\u0000\u0000\u1d85\u1d94\u0001\u0000\u0000\u0000\u1d86\u1d87\n\u0004"+
"\u0000\u0000\u1d87\u1d88\u0007H\u0000\u0000\u1d88\u1d93\u0003\u0280\u0140"+
"\u0005\u1d89\u1d8a\n\u0003\u0000\u0000\u1d8a\u1d8b\u0005\u02ae\u0000\u0000"+
"\u1d8b\u1d93\u0003\u0280\u0140\u0004\u1d8c\u1d8d\n\u0002\u0000\u0000\u1d8d"+
"\u1d8e\u0005\u01f1\u0000\u0000\u1d8e\u1d93\u0003\u0280\u0140\u0003\u1d8f"+
"\u1d90\n\u0001\u0000\u0000\u1d90\u1d91\u0005\u02c1\u0000\u0000\u1d91\u1d93"+
"\u0003\u0280\u0140\u0002\u1d92\u1d86\u0001\u0000\u0000\u0000\u1d92\u1d89"+
"\u0001\u0000\u0000\u0000\u1d92\u1d8c\u0001\u0000\u0000\u0000\u1d92\u1d8f"+
"\u0001\u0000\u0000\u0000\u1d93\u1d96\u0001\u0000\u0000\u0000\u1d94\u1d92"+
"\u0001\u0000\u0000\u0000\u1d94\u1d95\u0001\u0000\u0000\u0000\u1d95\u0281"+
"\u0001\u0000\u0000\u0000\u1d96\u1d94\u0001\u0000\u0000\u0000\u1d97\u1da0"+
"\u0005\u00b6\u0000\u0000\u1d98\u1d9d\u0003\u0284\u0142\u0000\u1d99\u1d9a"+
"\u0005\u00b8\u0000\u0000\u1d9a\u1d9c\u0003\u0284\u0142\u0000\u1d9b\u1d99"+
"\u0001\u0000\u0000\u0000\u1d9c\u1d9f\u0001\u0000\u0000\u0000\u1d9d\u1d9b"+
"\u0001\u0000\u0000\u0000\u1d9d\u1d9e\u0001\u0000\u0000\u0000\u1d9e\u1da1"+
"\u0001\u0000\u0000\u0000\u1d9f\u1d9d\u0001\u0000\u0000\u0000\u1da0\u1d98"+
"\u0001\u0000\u0000\u0000\u1da0\u1da1\u0001\u0000\u0000\u0000\u1da1\u1da2"+
"\u0001\u0000\u0000\u0000\u1da2\u1da3\u0005\u00b7\u0000\u0000\u1da3\u0283"+
"\u0001\u0000\u0000\u0000\u1da4\u1da8\u0003\u02a0\u0150\u0000\u1da5\u1da8"+
"\u0005\u0132\u0000\u0000\u1da6\u1da8\u0003\u0278\u013c\u0000\u1da7\u1da4"+
"\u0001\u0000\u0000\u0000\u1da7\u1da5\u0001\u0000\u0000\u0000\u1da7\u1da6"+
"\u0001\u0000\u0000\u0000\u1da8\u0285\u0001\u0000\u0000\u0000\u1da9\u1dab"+
"\u0005\u01e7\u0000\u0000\u1daa\u1da9\u0001\u0000\u0000\u0000\u1daa\u1dab"+
"\u0001\u0000\u0000\u0000\u1dab\u1dac\u0001\u0000\u0000\u0000\u1dac\u1dad"+
"\u0005\u00dd\u0000\u0000\u1dad\u1dae\u0003\u0288\u0144\u0000\u1dae\u1daf"+
"\u0005\u00cd\u0000\u0000\u1daf\u1db0\u0003\u0288\u0144\u0000\u1db0\u1de6"+
"\u0001\u0000\u0000\u0000\u1db1\u1db3\u0005\u01e7\u0000\u0000\u1db2\u1db1"+
"\u0001\u0000\u0000\u0000\u1db2\u1db3\u0001\u0000\u0000\u0000\u1db3\u1db4"+
"\u0001\u0000\u0000\u0000\u1db4\u1db5\u0007I\u0000\u0000\u1db5\u1de6\u0003"+
"\u0288\u0144\u0000\u1db6\u1db8\u0005\u01e7\u0000\u0000\u1db7\u1db6\u0001"+
"\u0000\u0000\u0000\u1db7\u1db8\u0001\u0000\u0000\u0000\u1db8\u1db9\u0001"+
"\u0000\u0000\u0000\u1db9\u1dba\u0005\u01b8\u0000\u0000\u1dba\u1dbd\u0003"+
"\u0288\u0144\u0000\u1dbb\u1dbc\u0005\u0155\u0000\u0000\u1dbc\u1dbe\u0003"+
"\u0288\u0144\u0000\u1dbd\u1dbb\u0001\u0000\u0000\u0000\u1dbd\u1dbe\u0001"+
"\u0000\u0000\u0000\u1dbe\u1de6\u0001\u0000\u0000\u0000\u1dbf\u1dc1\u0005"+
"\u01e7\u0000\u0000\u1dc0\u1dbf\u0001\u0000\u0000\u0000\u1dc0\u1dc1\u0001"+
"\u0000\u0000\u0000\u1dc1\u1dc2\u0001\u0000\u0000\u0000\u1dc2\u1dc3\u0007"+
"J\u0000\u0000\u1dc3\u1de6\u0003\u0288\u0144\u0000\u1dc4\u1dc6\u0005\u01e7"+
"\u0000\u0000\u1dc5\u1dc4\u0001\u0000\u0000\u0000\u1dc5\u1dc6\u0001\u0000"+
"\u0000\u0000\u1dc6\u1dc7\u0001\u0000\u0000\u0000\u1dc7\u1dc8\u0005\u0191"+
"\u0000\u0000\u1dc8\u1dc9\u0005\u00b6\u0000\u0000\u1dc9\u1dca\u0003\u01f0"+
"\u00f8\u0000\u1dca\u1dcb\u0005\u00b7\u0000\u0000\u1dcb\u1de6\u0001\u0000"+
"\u0000\u0000\u1dcc\u1dce\u0005\u01e7\u0000\u0000\u1dcd\u1dcc\u0001\u0000"+
"\u0000\u0000\u1dcd\u1dce\u0001\u0000\u0000\u0000\u1dce\u1dcf\u0001\u0000"+
"\u0000\u0000\u1dcf\u1dd0\u0005\u0191\u0000\u0000\u1dd0\u1dd1\u0005\u00b6"+
"\u0000\u0000\u1dd1\u1dd6\u0003\u027c\u013e\u0000\u1dd2\u1dd3\u0005\u00b8"+
"\u0000\u0000\u1dd3\u1dd5\u0003\u027c\u013e\u0000\u1dd4\u1dd2\u0001\u0000"+
"\u0000\u0000\u1dd5\u1dd8\u0001\u0000\u0000\u0000\u1dd6\u1dd4\u0001\u0000"+
"\u0000\u0000\u1dd6\u1dd7\u0001\u0000\u0000\u0000\u1dd7\u1dd9\u0001\u0000"+
"\u0000\u0000\u1dd8\u1dd6\u0001\u0000\u0000\u0000\u1dd9\u1dda\u0005\u00b7"+
"\u0000\u0000\u1dda\u1de6\u0001\u0000\u0000\u0000\u1ddb\u1ddd\u0005\u01a2"+
"\u0000\u0000\u1ddc\u1dde\u0005\u01e7\u0000\u0000\u1ddd\u1ddc\u0001\u0000"+
"\u0000\u0000\u1ddd\u1dde\u0001\u0000\u0000\u0000\u1dde\u1ddf\u0001\u0000"+
"\u0000\u0000\u1ddf\u1de6\u0005\u01e8\u0000\u0000\u1de0\u1de2\u0005\u01a2"+
"\u0000\u0000\u1de1\u1de3\u0005\u01e7\u0000\u0000\u1de2\u1de1\u0001\u0000"+
"\u0000\u0000\u1de2\u1de3\u0001\u0000\u0000\u0000\u1de3\u1de4\u0001\u0000"+
"\u0000\u0000\u1de4\u1de6\u0007!\u0000\u0000\u1de5\u1daa\u0001\u0000\u0000"+
"\u0000\u1de5\u1db2\u0001\u0000\u0000\u0000\u1de5\u1db7\u0001\u0000\u0000"+
"\u0000\u1de5\u1dc0\u0001\u0000\u0000\u0000\u1de5\u1dc5\u0001\u0000\u0000"+
"\u0000\u1de5\u1dcd\u0001\u0000\u0000\u0000\u1de5\u1ddb\u0001\u0000\u0000"+
"\u0000\u1de5\u1de0\u0001\u0000\u0000\u0000\u1de6\u0287\u0001\u0000\u0000"+
"\u0000\u1de7\u1de8\u0006\u0144\uffff\uffff\u0000\u1de8\u1dec\u0003\u028a"+
"\u0145\u0000\u1de9\u1dea\u0007K\u0000\u0000\u1dea\u1dec\u0003\u0288\u0144"+
"\u0004\u1deb\u1de7\u0001\u0000\u0000\u0000\u1deb\u1de9\u0001\u0000\u0000"+
"\u0000\u1dec\u1df9\u0001\u0000\u0000\u0000\u1ded\u1dee\n\u0003\u0000\u0000"+
"\u1dee\u1def\u0007L\u0000\u0000\u1def\u1df8\u0003\u0288\u0144\u0004\u1df0"+
"\u1df1\n\u0002\u0000\u0000\u1df1\u1df2\u0007M\u0000\u0000\u1df2\u1df8"+
"\u0003\u0288\u0144\u0003\u1df3\u1df4\n\u0001\u0000\u0000\u1df4\u1df5\u0003"+
"\u02a2\u0151\u0000\u1df5\u1df6\u0003\u0288\u0144\u0002\u1df6\u1df8\u0001"+
"\u0000\u0000\u0000\u1df7\u1ded\u0001\u0000\u0000\u0000\u1df7\u1df0\u0001"+
"\u0000\u0000\u0000\u1df7\u1df3\u0001\u0000\u0000\u0000\u1df8\u1dfb\u0001"+
"\u0000\u0000\u0000\u1df9\u1df7\u0001\u0000\u0000\u0000\u1df9\u1dfa\u0001"+
"\u0000\u0000\u0000\u1dfa\u0289\u0001\u0000\u0000\u0000\u1dfb\u1df9\u0001"+
"\u0000\u0000\u0000\u1dfc\u1dfd\u0006\u0145\uffff\uffff\u0000\u1dfd\u1e70"+
"\u0005\u0120\u0000\u0000\u1dfe\u1e70\u0005\u0121\u0000\u0000\u1dff\u1e70"+
"\u0005\u0122\u0000\u0000\u1e00\u1e70\u0005\u01bf\u0000\u0000\u1e01\u1e70"+
"\u0005\u01c0\u0000\u0000\u1e02\u1e70\u0005\u0123\u0000\u0000\u1e03\u1e70"+
"\u0005\u024f\u0000\u0000\u1e04\u1e06\u0005\u00f6\u0000\u0000\u1e05\u1e07"+
"\u0003\u02a6\u0153\u0000\u1e06\u1e05\u0001\u0000\u0000\u0000\u1e07\u1e08"+
"\u0001\u0000\u0000\u0000\u1e08\u1e06\u0001\u0000\u0000\u0000\u1e08\u1e09"+
"\u0001\u0000\u0000\u0000\u1e09\u1e0c\u0001\u0000\u0000\u0000\u1e0a\u1e0b"+
"\u0005\u014b\u0000\u0000\u1e0b\u1e0d\u0003\u027c\u013e\u0000\u1e0c\u1e0a"+
"\u0001\u0000\u0000\u0000\u1e0c\u1e0d\u0001\u0000\u0000\u0000\u1e0d\u1e0e"+
"\u0001\u0000\u0000\u0000\u1e0e\u1e0f\u0005\u014f\u0000\u0000\u1e0f\u1e70"+
"\u0001\u0000\u0000\u0000\u1e10\u1e11\u0005\u00f6\u0000\u0000\u1e11\u1e13"+
"\u0003\u027c\u013e\u0000\u1e12\u1e14\u0003\u02a6\u0153\u0000\u1e13\u1e12"+
"\u0001\u0000\u0000\u0000\u1e14\u1e15\u0001\u0000\u0000\u0000\u1e15\u1e13"+
"\u0001\u0000\u0000\u0000\u1e15\u1e16\u0001\u0000\u0000\u0000\u1e16\u1e19"+
"\u0001\u0000\u0000\u0000\u1e17\u1e18\u0005\u014b\u0000\u0000\u1e18\u1e1a"+
"\u0003\u027c\u013e\u0000\u1e19\u1e17\u0001\u0000\u0000\u0000\u1e19\u1e1a"+
"\u0001\u0000\u0000\u0000\u1e1a\u1e1b\u0001\u0000\u0000\u0000\u1e1b\u1e1c"+
"\u0005\u014f\u0000\u0000\u1e1c\u1e70\u0001\u0000\u0000\u0000\u1e1d\u1e1e"+
"\u0005\u00f7\u0000\u0000\u1e1e\u1e1f\u0005\u00b6\u0000\u0000\u1e1f\u1e20"+
"\u0003\u027c\u013e\u0000\u1e20\u1e21\u0005\u00d1\u0000\u0000\u1e21\u1e22"+
"\u0003\u028c\u0146\u0000\u1e22\u1e23\u0005\u00b7\u0000\u0000\u1e23\u1e70"+
"\u0001\u0000\u0000\u0000\u1e24\u1e70\u0003\u02a0\u0150\u0000\u1e25\u1e70"+
"\u0003\u02a8\u0154\u0000\u1e26\u1e70\u0005\u02b9\u0000\u0000\u1e27\u1e28"+
"\u0003\u029c\u014e\u0000\u1e28\u1e29\u0005\u00b9\u0000\u0000\u1e29\u1e2a"+
"\u0005\u02b9\u0000\u0000\u1e2a\u1e70\u0001\u0000\u0000\u0000\u1e2b\u1e2c"+
"\u0005\u00fb\u0000\u0000\u1e2c\u1e2d\u0005\u00b6\u0000\u0000\u1e2d\u1e32"+
"\u0003\u027c\u013e\u0000\u1e2e\u1e2f\u0005\u00b8\u0000\u0000\u1e2f\u1e31"+
"\u0003\u027c\u013e\u0000\u1e30\u1e2e\u0001\u0000\u0000\u0000\u1e31\u1e34"+
"\u0001\u0000\u0000\u0000\u1e32\u1e30\u0001\u0000\u0000\u0000\u1e32\u1e33"+
"\u0001\u0000\u0000\u0000\u1e33\u1e37\u0001\u0000\u0000\u0000\u1e34\u1e32"+
"\u0001\u0000\u0000\u0000\u1e35\u1e36\u0005\u0297\u0000\u0000\u1e36\u1e38"+
"\u0003\u01c2\u00e1\u0000\u1e37\u1e35\u0001\u0000\u0000\u0000\u1e37\u1e38"+
"\u0001\u0000\u0000\u0000\u1e38\u1e39\u0001\u0000\u0000\u0000\u1e39\u1e3a"+
"\u0005\u00b7\u0000\u0000\u1e3a\u1e70\u0001\u0000\u0000\u0000\u1e3b\u1e3c"+
"\u0005\u0115\u0000\u0000\u1e3c\u1e3d\u0005\u00b6\u0000\u0000\u1e3d\u1e3e"+
"\u0003\u027c\u013e\u0000\u1e3e\u1e3f\u0005\u0297\u0000\u0000\u1e3f\u1e40"+
"\u0003\u01c2\u00e1\u0000\u1e40\u1e41\u0005\u00b7\u0000\u0000\u1e41\u1e70"+
"\u0001\u0000\u0000\u0000\u1e42\u1e43\u0005\u0115\u0000\u0000\u1e43\u1e44"+
"\u0005\u00b6\u0000\u0000\u1e44\u1e45\u0003\u027c\u013e\u0000\u1e45\u1e46"+
"\u0005\u00b8\u0000\u0000\u1e46\u1e47\u0003\u028c\u0146\u0000\u1e47\u1e48"+
"\u0005\u00b7\u0000\u0000\u1e48\u1e70\u0001\u0000\u0000\u0000\u1e49\u1e70"+
"\u0003\u028e\u0147\u0000\u1e4a\u1e4b\u0005\u00b6\u0000\u0000\u1e4b\u1e4c"+
"\u0003\u01f0\u00f8\u0000\u1e4c\u1e4d\u0005\u00b7\u0000\u0000\u1e4d\u1e70"+
"\u0001\u0000\u0000\u0000\u1e4e\u1e4f\u0005\u02c8\u0000\u0000\u1e4f\u1e70"+
"\u0003\u01c2\u00e1\u0000\u1e50\u1e53\u0005\u02c9\u0000\u0000\u1e51\u1e52"+
"\u0007N\u0000\u0000\u1e52\u1e54\u0005\u00b9\u0000\u0000\u1e53\u1e51\u0001"+
"\u0000\u0000\u0000\u1e53\u1e54\u0001\u0000\u0000\u0000\u1e54\u1e55\u0001"+
"\u0000\u0000\u0000\u1e55\u1e70\u0003\u02ca\u0165\u0000\u1e56\u1e58\u0005"+
"\u00e0\u0000\u0000\u1e57\u1e56\u0001\u0000\u0000\u0000\u1e57\u1e58\u0001"+
"\u0000\u0000\u0000\u1e58\u1e59\u0001\u0000\u0000\u0000\u1e59\u1e70\u0003"+
"\u02ca\u0165\u0000\u1e5a\u1e5b\u0005\u00b6\u0000\u0000\u1e5b\u1e5c\u0003"+
"\u027c\u013e\u0000\u1e5c\u1e5d\u0005\u00b7\u0000\u0000\u1e5d\u1e70\u0001"+
"\u0000\u0000\u0000\u1e5e\u1e62\u0005\u01ac\u0000\u0000\u1e5f\u1e60\u0003"+
"\u02ca\u0165\u0000\u1e60\u1e61\u0005\u00b9\u0000\u0000\u1e61\u1e63\u0001"+
"\u0000\u0000\u0000\u1e62\u1e5f\u0001\u0000\u0000\u0000\u1e62\u1e63\u0001"+
"\u0000\u0000\u0000\u1e63\u1e64\u0001\u0000\u0000\u0000\u1e64\u1e70\u0003"+
"\u02ca\u0165\u0000\u1e65\u1e66\u0005\u0161\u0000\u0000\u1e66\u1e67\u0005"+
"\u00b6\u0000\u0000\u1e67\u1e68\u0003\u02ca\u0165\u0000\u1e68\u1e6a\u0005"+
"\u0172\u0000\u0000\u1e69\u1e6b\u0007O\u0000\u0000\u1e6a\u1e69\u0001\u0000"+
"\u0000\u0000\u1e6a\u1e6b\u0001\u0000\u0000\u0000\u1e6b\u1e6c\u0001\u0000"+
"\u0000\u0000\u1e6c\u1e6d\u0003\u0288\u0144\u0000\u1e6d\u1e6e\u0005\u00b7"+
"\u0000\u0000\u1e6e\u1e70\u0001\u0000\u0000\u0000\u1e6f\u1dfc\u0001\u0000"+
"\u0000\u0000\u1e6f\u1dfe\u0001\u0000\u0000\u0000\u1e6f\u1dff\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e00\u0001\u0000\u0000\u0000\u1e6f\u1e01\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e02\u0001\u0000\u0000\u0000\u1e6f\u1e03\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e04\u0001\u0000\u0000\u0000\u1e6f\u1e10\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e1d\u0001\u0000\u0000\u0000\u1e6f\u1e24\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e25\u0001\u0000\u0000\u0000\u1e6f\u1e26\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e27\u0001\u0000\u0000\u0000\u1e6f\u1e2b\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e3b\u0001\u0000\u0000\u0000\u1e6f\u1e42\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e49\u0001\u0000\u0000\u0000\u1e6f\u1e4a\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e4e\u0001\u0000\u0000\u0000\u1e6f\u1e50\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e57\u0001\u0000\u0000\u0000\u1e6f\u1e5a\u0001\u0000"+
"\u0000\u0000\u1e6f\u1e5e\u0001\u0000\u0000\u0000\u1e6f\u1e65\u0001\u0000"+
"\u0000\u0000\u1e70\u1e8b\u0001\u0000\u0000\u0000\u1e71\u1e72\n\u000b\u0000"+
"\u0000\u1e72\u1e73\u0005\u00bb\u0000\u0000\u1e73\u1e74\u0003\u0288\u0144"+
"\u0000\u1e74\u1e75\u0005\u00bc\u0000\u0000\u1e75\u1e8a\u0001\u0000\u0000"+
"\u0000\u1e76\u1e77\n\n\u0000\u0000\u1e77\u1e78\u0005\u00bb\u0000\u0000"+
"\u1e78\u1e79\u0003\u0288\u0144\u0000\u1e79\u1e7b\u0005\u02c3\u0000\u0000"+
"\u1e7a\u1e7c\u0003\u0288\u0144\u0000\u1e7b\u1e7a\u0001\u0000\u0000\u0000"+
"\u1e7b\u1e7c\u0001\u0000\u0000\u0000\u1e7c\u1e7d\u0001\u0000\u0000\u0000"+
"\u1e7d\u1e7e\u0005\u00bc\u0000\u0000\u1e7e\u1e8a\u0001\u0000\u0000\u0000"+
"\u1e7f\u1e80\n\u0005\u0000\u0000\u1e80\u1e81\u0005\u00b9\u0000\u0000\u1e81"+
"\u1e8a\u0003\u02ca\u0165\u0000\u1e82\u1e83\n\u0001\u0000\u0000\u1e83\u1e87"+
"\u0005\u0101\u0000\u0000\u1e84\u1e88\u0003\u02ca\u0165\u0000\u1e85\u1e88"+
"\u0005\u02ca\u0000\u0000\u1e86\u1e88\u0005\u0132\u0000\u0000\u1e87\u1e84"+
"\u0001\u0000\u0000\u0000\u1e87\u1e85\u0001\u0000\u0000\u0000\u1e87\u1e86"+
"\u0001\u0000\u0000\u0000\u1e88\u1e8a\u0001\u0000\u0000\u0000\u1e89\u1e71"+
"\u0001\u0000\u0000\u0000\u1e89\u1e76\u0001\u0000\u0000\u0000\u1e89\u1e7f"+
"\u0001\u0000\u0000\u0000\u1e89\u1e82\u0001\u0000\u0000\u0000\u1e8a\u1e8d"+
"\u0001\u0000\u0000\u0000\u1e8b\u1e89\u0001\u0000\u0000\u0000\u1e8b\u1e8c"+
"\u0001\u0000\u0000\u0000\u1e8c\u028b\u0001\u0000\u0000\u0000\u1e8d\u1e8b"+
"\u0001\u0000\u0000\u0000\u1e8e\u1e94\u0003\u02ae\u0157\u0000\u1e8f\u1e91"+
"\u0007P\u0000\u0000\u1e90\u1e92\u0007Q\u0000\u0000\u1e91\u1e90\u0001\u0000"+
"\u0000\u0000\u1e91\u1e92\u0001\u0000\u0000\u0000\u1e92\u1e94\u0001\u0000"+
"\u0000\u0000\u1e93\u1e8e\u0001\u0000\u0000\u0000\u1e93\u1e8f\u0001\u0000"+
"\u0000\u0000\u1e94\u028d\u0001\u0000\u0000\u0000\u1e95\u1e96\u0003\u0290"+
"\u0148\u0000\u1e96\u1eae\u0005\u00b6\u0000\u0000\u1e97\u1e99\u0007\u001f"+
"\u0000\u0000\u1e98\u1e97\u0001\u0000\u0000\u0000\u1e98\u1e99\u0001\u0000"+
"\u0000\u0000\u1e99\u1e9a\u0001\u0000\u0000\u0000\u1e9a\u1e9f\u0003\u027c"+
"\u013e\u0000\u1e9b\u1e9c\u0005\u00b8\u0000\u0000\u1e9c\u1e9e\u0003\u027c"+
"\u013e\u0000\u1e9d\u1e9b\u0001\u0000\u0000\u0000\u1e9e\u1ea1\u0001\u0000"+
"\u0000\u0000\u1e9f\u1e9d\u0001\u0000\u0000\u0000\u1e9f\u1ea0\u0001\u0000"+
"\u0000\u0000\u1ea0\u1eac\u0001\u0000\u0000\u0000\u1ea1\u1e9f\u0001\u0000"+
"\u0000\u0000\u1ea2\u1ea3\u0005\u01f2\u0000\u0000\u1ea3\u1ea4\u0005\u00f1"+
"\u0000\u0000\u1ea4\u1ea9\u0003\u0230\u0118\u0000\u1ea5\u1ea6\u0005\u00b8"+
"\u0000\u0000\u1ea6\u1ea8\u0003\u0230\u0118\u0000\u1ea7\u1ea5\u0001\u0000"+
"\u0000\u0000\u1ea8\u1eab\u0001\u0000\u0000\u0000\u1ea9\u1ea7\u0001\u0000"+
"\u0000\u0000\u1ea9\u1eaa\u0001\u0000\u0000\u0000\u1eaa\u1ead\u0001\u0000"+
"\u0000\u0000\u1eab\u1ea9\u0001\u0000\u0000\u0000\u1eac\u1ea2\u0001\u0000"+
"\u0000\u0000\u1eac\u1ead\u0001\u0000\u0000\u0000\u1ead\u1eaf\u0001\u0000"+
"\u0000\u0000\u1eae\u1e98\u0001\u0000\u0000\u0000\u1eae\u1eaf\u0001\u0000"+
"\u0000\u0000\u1eaf\u1eb0\u0001\u0000\u0000\u0000\u1eb0\u1eb3\u0005\u00b7"+
"\u0000\u0000\u1eb1\u1eb2\u0005\u01f5\u0000\u0000\u1eb2\u1eb4\u0003\u0294"+
"\u014a\u0000\u1eb3\u1eb1\u0001\u0000\u0000\u0000\u1eb3\u1eb4\u0001\u0000"+
"\u0000\u0000\u1eb4\u028f\u0001\u0000\u0000\u0000\u1eb5\u1eb6\u0003\u02ca"+
"\u0165\u0000\u1eb6\u1eb7\u0005\u00b9\u0000\u0000\u1eb7\u1eb9\u0001\u0000"+
"\u0000\u0000\u1eb8\u1eb5\u0001\u0000\u0000\u0000\u1eb8\u1eb9\u0001\u0000"+
"\u0000\u0000\u1eb9\u1eba\u0001\u0000\u0000\u0000\u1eba\u1ebb\u0003\u0292"+
"\u0149\u0000\u1ebb\u0291\u0001\u0000\u0000\u0000\u1ebc\u1ecd\u0003\u02ca"+
"\u0165\u0000\u1ebd\u1ecd\u0005\u00c2\u0000\u0000\u1ebe\u1ecd\u0005\u0111"+
"\u0000\u0000\u1ebf\u1ecd\u0005\u011f\u0000\u0000\u1ec0\u1ecd\u0005\u0123"+
"\u0000\u0000\u1ec1\u1ecd\u0005\u0125\u0000\u0000\u1ec2\u1ecd\u0005\u018e"+
"\u0000\u0000\u1ec3\u1ecd\u0005\u01b5\u0000\u0000\u1ec4\u1ecd\u0005\u01b8"+
"\u0000\u0000\u1ec5\u1ecd\u0005\u01fb\u0000\u0000\u1ec6\u1ecd\u0005\u0226"+
"\u0000\u0000\u1ec7\u1ecd\u0005\u023b\u0000\u0000\u1ec8\u1ecd\u0005\u0248"+
"\u0000\u0000\u1ec9\u1ecd\u0005\u024f\u0000\u0000\u1eca\u1ecd\u0005\u0285"+
"\u0000\u0000\u1ecb\u1ecd\u0005\u0296\u0000\u0000\u1ecc\u1ebc\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ebd\u0001\u0000\u0000\u0000\u1ecc\u1ebe\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ebf\u0001\u0000\u0000\u0000\u1ecc\u1ec0\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ec1\u0001\u0000\u0000\u0000\u1ecc\u1ec2\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ec3\u0001\u0000\u0000\u0000\u1ecc\u1ec4\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ec5\u0001\u0000\u0000\u0000\u1ecc\u1ec6\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ec7\u0001\u0000\u0000\u0000\u1ecc\u1ec8\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ec9\u0001\u0000\u0000\u0000\u1ecc\u1eca\u0001\u0000"+
"\u0000\u0000\u1ecc\u1ecb\u0001\u0000\u0000\u0000\u1ecd\u0293\u0001\u0000"+
"\u0000\u0000\u1ece\u1ed0\u0005\u00b6\u0000\u0000\u1ecf\u1ed1\u0003\u0234"+
"\u011a\u0000\u1ed0\u1ecf\u0001\u0000\u0000\u0000\u1ed0\u1ed1\u0001\u0000"+
"\u0000\u0000\u1ed1\u1ed3\u0001\u0000\u0000\u0000\u1ed2\u1ed4\u0003\u022e"+
"\u0117\u0000\u1ed3\u1ed2\u0001\u0000\u0000\u0000\u1ed3\u1ed4\u0001\u0000"+
"\u0000\u0000\u1ed4\u1ed6\u0001\u0000\u0000\u0000\u1ed5\u1ed7\u0003\u0296"+
"\u014b\u0000\u1ed6\u1ed5\u0001\u0000\u0000\u0000\u1ed6\u1ed7\u0001\u0000"+
"\u0000\u0000\u1ed7\u1ed8\u0001\u0000\u0000\u0000\u1ed8\u1ed9\u0005\u00b7"+
"\u0000\u0000\u1ed9\u0295\u0001\u0000\u0000\u0000\u1eda\u1edb\u0003\u0298"+
"\u014c\u0000\u1edb\u1edc\u0003\u029a\u014d\u0000\u1edc\u1ee4\u0001\u0000"+
"\u0000\u0000\u1edd\u1ede\u0003\u0298\u014c\u0000\u1ede\u1edf\u0005\u00dd"+
"\u0000\u0000\u1edf\u1ee0\u0003\u029a\u014d\u0000\u1ee0\u1ee1\u0005\u00cd"+
"\u0000\u0000\u1ee1\u1ee2\u0003\u029a\u014d\u0000\u1ee2\u1ee4\u0001\u0000"+
"\u0000\u0000\u1ee3\u1eda\u0001\u0000\u0000\u0000\u1ee3\u1edd\u0001\u0000"+
"\u0000\u0000\u1ee4\u0297\u0001\u0000\u0000\u0000\u1ee5\u1ee6\u0007R\u0000"+
"\u0000\u1ee6\u0299\u0001\u0000\u0000\u0000\u1ee7\u1ee8\u0005\u028b\u0000"+
"\u0000\u1ee8\u1eef\u0007S\u0000\u0000\u1ee9\u1eea\u0005\u011e\u0000\u0000"+
"\u1eea\u1eef\u0005\u0242\u0000\u0000\u1eeb\u1eec\u0003\u027c\u013e\u0000"+
"\u1eec\u1eed\u0007S\u0000\u0000\u1eed\u1eef\u0001\u0000\u0000\u0000\u1eee"+
"\u1ee7\u0001\u0000\u0000\u0000\u1eee\u1ee9\u0001\u0000\u0000\u0000\u1eee"+
"\u1eeb\u0001\u0000\u0000\u0000\u1eef\u029b\u0001\u0000\u0000\u0000\u1ef0"+
"\u1ef5\u0003\u02ca\u0165\u0000\u1ef1\u1ef2\u0005\u00b9\u0000\u0000\u1ef2"+
"\u1ef4\u0003\u02ca\u0165\u0000\u1ef3\u1ef1\u0001\u0000\u0000\u0000\u1ef4"+
"\u1ef7\u0001\u0000\u0000\u0000\u1ef5\u1ef3\u0001\u0000\u0000\u0000\u1ef5"+
"\u1ef6\u0001\u0000\u0000\u0000\u1ef6\u029d\u0001\u0000\u0000\u0000\u1ef7"+
"\u1ef5\u0001\u0000\u0000\u0000\u1ef8\u1efa\u0005\u0276\u0000\u0000\u1ef9"+
"\u1ef8\u0001\u0000\u0000\u0000\u1ef9\u1efa\u0001\u0000\u0000\u0000\u1efa"+
"\u1efb\u0001\u0000\u0000\u0000\u1efb\u1efe\u0005\u01f9\u0000\u0000\u1efc"+
"\u1eff\u0003\u02ca\u0165\u0000\u1efd\u1eff\u0003\u023a\u011d\u0000\u1efe"+
"\u1efc\u0001\u0000\u0000\u0000\u1efe\u1efd\u0001\u0000\u0000\u0000\u1eff"+
"\u1f06\u0001\u0000\u0000\u0000\u1f00\u1f02\u0005\u0276\u0000\u0000\u1f01"+
"\u1f00\u0001\u0000\u0000\u0000\u1f01\u1f02\u0001\u0000\u0000\u0000\u1f02"+
"\u1f03\u0001\u0000\u0000\u0000\u1f03\u1f04\u0005\u01fa\u0000\u0000\u1f04"+
"\u1f06\u0003\u023a\u011d\u0000\u1f05\u1ef9\u0001\u0000\u0000\u0000\u1f05"+
"\u1f01\u0001\u0000\u0000\u0000\u1f06\u029f\u0001\u0000\u0000\u0000\u1f07"+
"\u1f3b\u0005\u01e8\u0000\u0000\u1f08\u1f09\u0007T\u0000\u0000\u1f09\u1f3b"+
"\u0005\u02ca\u0000\u0000\u1f0a\u1f3b\u0003\u02d0\u0168\u0000\u1f0b\u1f3b"+
"\u0003\u02a4\u0152\u0000\u1f0c\u1f0e\u0005\u00e0\u0000\u0000\u1f0d\u1f0c"+
"\u0001\u0000\u0000\u0000\u1f0d\u1f0e\u0001\u0000\u0000\u0000\u1f0e\u1f0f"+
"\u0001\u0000\u0000\u0000\u1f0f\u1f3b\u0005\u02ca\u0000\u0000\u1f10\u1f12"+
"\u0005\u00bb\u0000\u0000\u1f11\u1f13\u0003\u02a0\u0150\u0000\u1f12\u1f11"+
"\u0001\u0000\u0000\u0000\u1f12\u1f13\u0001\u0000\u0000\u0000\u1f13\u1f18"+
"\u0001\u0000\u0000\u0000\u1f14\u1f15\u0005\u00b8\u0000\u0000\u1f15\u1f17"+
"\u0003\u02a0\u0150\u0000\u1f16\u1f14\u0001\u0000\u0000\u0000\u1f17\u1f1a"+
"\u0001\u0000\u0000\u0000\u1f18\u1f16\u0001\u0000\u0000\u0000\u1f18\u1f19"+
"\u0001\u0000\u0000\u0000\u1f19\u1f1b\u0001\u0000\u0000\u0000\u1f1a\u1f18"+
"\u0001\u0000\u0000\u0000\u1f1b\u1f3b\u0005\u00bc\u0000\u0000\u1f1c\u1f21"+
"\u0005\u00bd\u0000\u0000\u1f1d\u1f1e\u0003\u02a0\u0150\u0000\u1f1e\u1f1f"+
"\u0005\u02c3\u0000\u0000\u1f1f\u1f20\u0003\u02a0\u0150\u0000\u1f20\u1f22"+
"\u0001\u0000\u0000\u0000\u1f21\u1f1d\u0001\u0000\u0000\u0000\u1f21\u1f22"+
"\u0001\u0000\u0000\u0000\u1f22\u1f2a\u0001\u0000\u0000\u0000\u1f23\u1f24"+
"\u0005\u00b8\u0000\u0000\u1f24\u1f25\u0003\u02a0\u0150\u0000\u1f25\u1f26"+
"\u0005\u02c3\u0000\u0000\u1f26\u1f27\u0003\u02a0\u0150\u0000\u1f27\u1f29"+
"\u0001\u0000\u0000\u0000\u1f28\u1f23\u0001\u0000\u0000\u0000\u1f29\u1f2c"+
"\u0001\u0000\u0000\u0000\u1f2a\u1f28\u0001\u0000\u0000\u0000\u1f2a\u1f2b"+
"\u0001\u0000\u0000\u0000\u1f2b\u1f2d\u0001\u0000\u0000\u0000\u1f2c\u1f2a"+
"\u0001\u0000\u0000\u0000\u1f2d\u1f3b\u0005\u00be\u0000\u0000\u1f2e\u1f2f"+
"\u0005\u00bd\u0000\u0000\u1f2f\u1f34\u0003\u02a0\u0150\u0000\u1f30\u1f31"+
"\u0005\u00b8\u0000\u0000\u1f31\u1f33\u0003\u02a0\u0150\u0000\u1f32\u1f30"+
"\u0001\u0000\u0000\u0000\u1f33\u1f36\u0001\u0000\u0000\u0000\u1f34\u1f32"+
"\u0001\u0000\u0000\u0000\u1f34\u1f35\u0001\u0000\u0000\u0000\u1f35\u1f37"+
"\u0001\u0000\u0000\u0000\u1f36\u1f34\u0001\u0000\u0000\u0000\u1f37\u1f38"+
"\u0005\u00be\u0000\u0000\u1f38\u1f3b\u0001\u0000\u0000\u0000\u1f39\u1f3b"+
"\u0005\u0207\u0000\u0000\u1f3a\u1f07\u0001\u0000\u0000\u0000\u1f3a\u1f08"+
"\u0001\u0000\u0000\u0000\u1f3a\u1f0a\u0001\u0000\u0000\u0000\u1f3a\u1f0b"+
"\u0001\u0000\u0000\u0000\u1f3a\u1f0d\u0001\u0000\u0000\u0000\u1f3a\u1f10"+
"\u0001\u0000\u0000\u0000\u1f3a\u1f1c\u0001\u0000\u0000\u0000\u1f3a\u1f2e"+
"\u0001\u0000\u0000\u0000\u1f3a\u1f39\u0001\u0000\u0000\u0000\u1f3b\u02a1"+
"\u0001\u0000\u0000\u0000\u1f3c\u1f3d\u0007U\u0000\u0000\u1f3d\u02a3\u0001"+
"\u0000\u0000\u0000\u1f3e\u1f3f\u0007!\u0000\u0000\u1f3f\u02a5\u0001\u0000"+
"\u0000\u0000\u1f40\u1f41\u0005\u02a7\u0000\u0000\u1f41\u1f42\u0003\u027c"+
"\u013e\u0000\u1f42\u1f43\u0005\u027a\u0000\u0000\u1f43\u1f44\u0003\u027c"+
"\u013e\u0000\u1f44\u02a7\u0001\u0000\u0000\u0000\u1f45\u1f46\u0005\u019d"+
"\u0000\u0000\u1f46\u1f47\u0003\u027c\u013e\u0000\u1f47\u1f48\u0003\u02aa"+
"\u0155\u0000\u1f48\u02a9\u0001\u0000\u0000\u0000\u1f49\u1f4a\u0007V\u0000"+
"\u0000\u1f4a\u02ab\u0001\u0000\u0000\u0000\u1f4b\u1f50\u0003\u02ae\u0157"+
"\u0000\u1f4c\u1f4e\u0005\u01e7\u0000\u0000\u1f4d\u1f4c\u0001\u0000\u0000"+
"\u0000\u1f4d\u1f4e\u0001\u0000\u0000\u0000\u1f4e\u1f4f\u0001\u0000\u0000"+
"\u0000\u1f4f\u1f51\u0005\u01e8\u0000\u0000\u1f50\u1f4d\u0001\u0000\u0000"+
"\u0000\u1f50\u1f51\u0001\u0000\u0000\u0000\u1f51\u02ad\u0001\u0000\u0000"+
"\u0000\u1f52\u1f53\u0005\u00d0\u0000\u0000\u1f53\u1f54\u0005\u02b3\u0000"+
"\u0000\u1f54\u1f55\u0003\u02ae\u0157\u0000\u1f55\u1f56\u0005\u02b5\u0000"+
"\u0000\u1f56\u1f81\u0001\u0000\u0000\u0000\u1f57\u1f58\u0005\u01c6\u0000"+
"\u0000\u1f58\u1f59\u0005\u02b3\u0000\u0000\u1f59\u1f5a\u0003\u02ae\u0157"+
"\u0000\u1f5a\u1f5b\u0005\u00b8\u0000\u0000\u1f5b\u1f5c\u0003\u02ae\u0157"+
"\u0000\u1f5c\u1f5d\u0005\u02b5\u0000\u0000\u1f5d\u1f81\u0001\u0000\u0000"+
"\u0000\u1f5e\u1f5f\u0005\u0268\u0000\u0000\u1f5f\u1f60\u0005\u02b3\u0000"+
"\u0000\u1f60\u1f61\u0003\u02b2\u0159\u0000\u1f61\u1f62\u0005\u02b5\u0000"+
"\u0000\u1f62\u1f81\u0001\u0000\u0000\u0000\u1f63\u1f81\u0003\u02b6\u015b"+
"\u0000\u1f64\u1f65\u0005\u00c5\u0000\u0000\u1f65\u1f66\u0005\u02b3\u0000"+
"\u0000\u1f66\u1f67\u0003\u0292\u0149\u0000\u1f67\u1f68\u0005\u00b6\u0000"+
"\u0000\u1f68\u1f6d\u0003\u02ac\u0156\u0000\u1f69\u1f6a\u0005\u00b8\u0000"+
"\u0000\u1f6a\u1f6c\u0003\u02ac\u0156\u0000\u1f6b\u1f69\u0001\u0000\u0000"+
"\u0000\u1f6c\u1f6f\u0001\u0000\u0000\u0000\u1f6d\u1f6b\u0001\u0000\u0000"+
"\u0000\u1f6d\u1f6e\u0001\u0000\u0000\u0000\u1f6e\u1f70\u0001\u0000\u0000"+
"\u0000\u1f6f\u1f6d\u0001\u0000\u0000\u0000\u1f70\u1f71\u0005\u00b7\u0000"+
"\u0000\u1f71\u1f72\u0005\u02b5\u0000\u0000\u1f72\u1f81\u0001\u0000\u0000"+
"\u0000\u1f73\u1f7e\u0003\u02b0\u0158\u0000\u1f74\u1f75\u0005\u00b6\u0000"+
"\u0000\u1f75\u1f7a\u0007W\u0000\u0000\u1f76\u1f77\u0005\u00b8\u0000\u0000"+
"\u1f77\u1f79\u0005\u02cf\u0000\u0000\u1f78\u1f76\u0001\u0000\u0000\u0000"+
"\u1f79\u1f7c\u0001\u0000\u0000\u0000\u1f7a\u1f78\u0001\u0000\u0000\u0000"+
"\u1f7a\u1f7b\u0001\u0000\u0000\u0000\u1f7b\u1f7d\u0001\u0000\u0000\u0000"+
"\u1f7c\u1f7a\u0001\u0000\u0000\u0000\u1f7d\u1f7f\u0005\u00b7\u0000\u0000"+
"\u1f7e\u1f74\u0001\u0000\u0000\u0000\u1f7e\u1f7f\u0001\u0000\u0000\u0000"+
"\u1f7f\u1f81\u0001\u0000\u0000\u0000\u1f80\u1f52\u0001\u0000\u0000\u0000"+
"\u1f80\u1f57\u0001\u0000\u0000\u0000\u1f80\u1f5e\u0001\u0000\u0000\u0000"+
"\u1f80\u1f63\u0001\u0000\u0000\u0000\u1f80\u1f64\u0001\u0000\u0000\u0000"+
"\u1f80\u1f73\u0001\u0000\u0000\u0000\u1f81\u02af\u0001\u0000\u0000\u0000"+
"\u1f82\u1fa2\u0005\u027d\u0000\u0000\u1f83\u1fa2\u0005\u0257\u0000\u0000"+
"\u1f84\u1fa2\u0007Q\u0000\u0000\u1f85\u1fa2\u0005\u00de\u0000\u0000\u1f86"+
"\u1fa2\u0005\u01b0\u0000\u0000\u1f87\u1fa2\u0005\u00e9\u0000\u0000\u1f88"+
"\u1fa2\u0005\u016a\u0000\u0000\u1f89\u1fa2\u0005\u0143\u0000\u0000\u1f8a"+
"\u1fa2\u0005\u0127\u0000\u0000\u1f8b\u1fa2\u0005\u0128\u0000\u0000\u1f8c"+
"\u1fa2\u0005\u027b\u0000\u0000\u1f8d\u1fa2\u0005\u012a\u0000\u0000\u1f8e"+
"\u1fa2\u0005\u0129\u0000\u0000\u1f8f\u1fa2\u0005\u012c\u0000\u0000\u1f90"+
"\u1fa2\u0005\u012b\u0000\u0000\u1f91\u1fa2\u0005\u00e3\u0000\u0000\u1f92"+
"\u1fa2\u0005\u0218\u0000\u0000\u1f93\u1fa2\u0005\u0186\u0000\u0000\u1f94"+
"\u1fa2\u0005\u00c5\u0000\u0000\u1f95\u1fa2\u0005\u0267\u0000\u0000\u1f96"+
"\u1fa2\u0005\u01aa\u0000\u0000\u1f97\u1fa2\u0005\u01ab\u0000\u0000\u1f98"+
"\u1fa2\u0005\u0278\u0000\u0000\u1f99\u1fa2\u0005\u029a\u0000\u0000\u1f9a"+
"\u1fa2\u0005\u00fb\u0000\u0000\u1f9b\u1fa2\u0005\u012e\u0000\u0000\u1f9c"+
"\u1fa2\u0005\u012f\u0000\u0000\u1f9d\u1fa2\u0005\u0130\u0000\u0000\u1f9e"+
"\u1fa2\u0005\u01a0\u0000\u0000\u1f9f\u1fa2\u0005\u01a1\u0000\u0000\u1fa0"+
"\u1fa2\u0005\u00c8\u0000\u0000\u1fa1\u1f82\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f83\u0001\u0000\u0000\u0000\u1fa1\u1f84\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f85\u0001\u0000\u0000\u0000\u1fa1\u1f86\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f87\u0001\u0000\u0000\u0000\u1fa1\u1f88\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f89\u0001\u0000\u0000\u0000\u1fa1\u1f8a\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f8b\u0001\u0000\u0000\u0000\u1fa1\u1f8c\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f8d\u0001\u0000\u0000\u0000\u1fa1\u1f8e\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f8f\u0001\u0000\u0000\u0000\u1fa1\u1f90\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f91\u0001\u0000\u0000\u0000\u1fa1\u1f92\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f93\u0001\u0000\u0000\u0000\u1fa1\u1f94\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f95\u0001\u0000\u0000\u0000\u1fa1\u1f96\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f97\u0001\u0000\u0000\u0000\u1fa1\u1f98\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f99\u0001\u0000\u0000\u0000\u1fa1\u1f9a\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f9b\u0001\u0000\u0000\u0000\u1fa1\u1f9c\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f9d\u0001\u0000\u0000\u0000\u1fa1\u1f9e\u0001\u0000\u0000\u0000\u1fa1"+
"\u1f9f\u0001\u0000\u0000\u0000\u1fa1\u1fa0\u0001\u0000\u0000\u0000\u1fa2"+
"\u02b1\u0001\u0000\u0000\u0000\u1fa3\u1fa8\u0003\u02b4\u015a\u0000\u1fa4"+
"\u1fa5\u0005\u00b8\u0000\u0000\u1fa5\u1fa7\u0003\u02b4\u015a\u0000\u1fa6"+
"\u1fa4\u0001\u0000\u0000\u0000\u1fa7\u1faa\u0001\u0000\u0000\u0000\u1fa8"+
"\u1fa6\u0001\u0000\u0000\u0000\u1fa8\u1fa9\u0001\u0000\u0000\u0000\u1fa9"+
"\u02b3\u0001\u0000\u0000\u0000\u1faa\u1fa8\u0001\u0000\u0000\u0000\u1fab"+
"\u1fac\u0003\u02ca\u0165\u0000\u1fac\u1fad\u0005\u02c3\u0000\u0000\u1fad"+
"\u1faf\u0003\u02ae\u0157\u0000\u1fae\u1fb0\u0003\u02be\u015f\u0000\u1faf"+
"\u1fae\u0001\u0000\u0000\u0000\u1faf\u1fb0\u0001\u0000\u0000\u0000\u1fb0"+
"\u02b5\u0001\u0000\u0000\u0000\u1fb1\u1fb2\u0005\u029d\u0000\u0000\u1fb2"+
"\u1fb3\u0005\u02b3\u0000\u0000\u1fb3\u1fb4\u0003\u02b8\u015c\u0000\u1fb4"+
"\u1fb5\u0005\u00b8\u0000\u0000\u1fb5\u1fb6\u0003\u0244\u0122\u0000\u1fb6"+
"\u1fb7\u0005\u02b5\u0000\u0000\u1fb7\u1fc4\u0001\u0000\u0000\u0000\u1fb8"+
"\u1fb9\u0005\u029d\u0000\u0000\u1fb9\u1fba\u0005\u02b3\u0000\u0000\u1fba"+
"\u1fbb\u0003\u02b8\u015c\u0000\u1fbb\u1fbc\u0005\u02b5\u0000\u0000\u1fbc"+
"\u1fc4\u0001\u0000\u0000\u0000\u1fbd\u1fbe\u0005\u029d\u0000\u0000\u1fbe"+
"\u1fbf\u0005\u02b3\u0000\u0000\u1fbf\u1fc0\u0003\u0244\u0122\u0000\u1fc0"+
"\u1fc1\u0005\u02b5\u0000\u0000\u1fc1\u1fc4\u0001\u0000\u0000\u0000\u1fc2"+
"\u1fc4\u0005\u029d\u0000\u0000\u1fc3\u1fb1\u0001\u0000\u0000\u0000\u1fc3"+
"\u1fb8\u0001\u0000\u0000\u0000\u1fc3\u1fbd\u0001\u0000\u0000\u0000\u1fc3"+
"\u1fc2\u0001\u0000\u0000\u0000\u1fc4\u02b7\u0001\u0000\u0000\u0000\u1fc5"+
"\u1fca\u0003\u02ba\u015d\u0000\u1fc6\u1fc7\u0005\u00b8\u0000\u0000\u1fc7"+
"\u1fc9\u0003\u02ba\u015d\u0000\u1fc8\u1fc6\u0001\u0000\u0000\u0000\u1fc9"+
"\u1fcc\u0001\u0000\u0000\u0000\u1fca\u1fc8\u0001\u0000\u0000\u0000\u1fca"+
"\u1fcb\u0001\u0000\u0000\u0000\u1fcb\u02b9\u0001\u0000\u0000\u0000\u1fcc"+
"\u1fca\u0001\u0000\u0000\u0000\u1fcd\u1fcf\u0003\u02bc\u015e\u0000\u1fce"+
"\u1fcd\u0001\u0000\u0000\u0000\u1fce\u1fcf\u0001\u0000\u0000\u0000\u1fcf"+
"\u1fd0\u0001\u0000\u0000\u0000\u1fd0\u1fd1\u0005\u02ca\u0000\u0000\u1fd1"+
"\u1fd2\u0005\u02c3\u0000\u0000\u1fd2\u1fd4\u0003\u02ae\u0157\u0000\u1fd3"+
"\u1fd5\u0003\u02be\u015f\u0000\u1fd4\u1fd3\u0001\u0000\u0000\u0000\u1fd4"+
"\u1fd5\u0001\u0000\u0000\u0000\u1fd5\u02bb\u0001\u0000\u0000\u0000\u1fd6"+
"\u1fd7\u0007X\u0000\u0000\u1fd7\u02bd\u0001\u0000\u0000\u0000\u1fd8\u1fd9"+
"\u0005\u0107\u0000\u0000\u1fd9\u1fda\u0005\u02ca\u0000\u0000\u1fda\u02bf"+
"\u0001\u0000\u0000\u0000\u1fdb\u1fdc\u0005\u0270\u0000\u0000\u1fdc\u1fde"+
"\u0005\u00b6\u0000\u0000\u1fdd\u1fdf\u0003\u02c2\u0161\u0000\u1fde\u1fdd"+
"\u0001\u0000\u0000\u0000\u1fde\u1fdf\u0001\u0000\u0000\u0000\u1fdf\u1fe0"+
"\u0001\u0000\u0000\u0000\u1fe0\u1fe3\u0005\u00b7\u0000\u0000\u1fe1\u1fe2"+
"\u0005\u022a\u0000\u0000\u1fe2\u1fe4\u0005\u02cf\u0000\u0000\u1fe3\u1fe1"+
"\u0001\u0000\u0000\u0000\u1fe3\u1fe4\u0001\u0000\u0000\u0000\u1fe4\u02c1"+
"\u0001\u0000\u0000\u0000\u1fe5\u1fe6\u0005\u02cf\u0000\u0000\u1fe6\u1fea"+
"\u0005\u0202\u0000\u0000\u1fe7\u1fe8\u0005\u02cf\u0000\u0000\u1fe8\u1fea"+
"\u0005\u0243\u0000\u0000\u1fe9\u1fe5\u0001\u0000\u0000\u0000\u1fe9\u1fe7"+
"\u0001\u0000\u0000\u0000\u1fea\u02c3\u0001\u0000\u0000\u0000\u1feb\u1fec"+
"\u0005\u016d\u0000\u0000\u1fec\u1fed\u0005\u02a1\u0000\u0000\u1fed\u1fee"+
"\u0005\u00d1\u0000\u0000\u1fee\u1fef\u0005\u01eb\u0000\u0000\u1fef\u1ff6"+
"\u0007)\u0000\u0000\u1ff0\u1ff1\u0005\u016d\u0000\u0000\u1ff1\u1ff2\u0005"+
"\u027b\u0000\u0000\u1ff2\u1ff3\u0005\u00d1\u0000\u0000\u1ff3\u1ff4\u0005"+
"\u01eb\u0000\u0000\u1ff4\u1ff6\u0005\u02ca\u0000\u0000\u1ff5\u1feb\u0001"+
"\u0000\u0000\u0000\u1ff5\u1ff0\u0001\u0000\u0000\u0000\u1ff6\u02c5\u0001"+
"\u0000\u0000\u0000\u1ff7\u1ff8\u0003\u02ca\u0165\u0000\u1ff8\u1ff9\u0003"+
"\u02c8\u0164\u0000\u1ff9\u02c7\u0001\u0000\u0000\u0000\u1ffa\u1ffb\u0005"+
"\u02b8\u0000\u0000\u1ffb\u1ffd\u0003\u02ca\u0165\u0000\u1ffc\u1ffa\u0001"+
"\u0000\u0000\u0000\u1ffd\u1ffe\u0001\u0000\u0000\u0000\u1ffe\u1ffc\u0001"+
"\u0000\u0000\u0000\u1ffe\u1fff\u0001\u0000\u0000\u0000\u1fff\u2002\u0001"+
"\u0000\u0000\u0000\u2000\u2002\u0001\u0000\u0000\u0000\u2001\u1ffc\u0001"+
"\u0000\u0000\u0000\u2001\u2000\u0001\u0000\u0000\u0000\u2002\u02c9\u0001"+
"\u0000\u0000\u0000\u2003\u2004\u0003\u02cc\u0166\u0000\u2004\u02cb\u0001"+
"\u0000\u0000\u0000\u2005\u2009\u0005\u02d3\u0000\u0000\u2006\u2009\u0003"+
"\u02ce\u0167\u0000\u2007\u2009\u0003\u02d2\u0169\u0000\u2008\u2005\u0001"+
"\u0000\u0000\u0000\u2008\u2006\u0001\u0000\u0000\u0000\u2008\u2007\u0001"+
"\u0000\u0000\u0000\u2009\u02cd\u0001\u0000\u0000\u0000\u200a\u200b\u0005"+
"\u02d4\u0000\u0000\u200b\u02cf\u0001\u0000\u0000\u0000\u200c\u200e\u0005"+
"\u02b8\u0000\u0000\u200d\u200c\u0001\u0000\u0000\u0000\u200d\u200e\u0001"+
"\u0000\u0000\u0000\u200e\u200f\u0001\u0000\u0000\u0000\u200f\u2015\u0005"+
"\u02cf\u0000\u0000\u2010\u2012\u0005\u02b8\u0000\u0000\u2011\u2010\u0001"+
"\u0000\u0000\u0000\u2011\u2012\u0001\u0000\u0000\u0000\u2012\u2013\u0001"+
"\u0000\u0000\u0000\u2013\u2015\u0007Y\u0000\u0000\u2014\u200d\u0001\u0000"+
"\u0000\u0000\u2014\u2011\u0001\u0000\u0000\u0000\u2015\u02d1\u0001\u0000"+
"\u0000\u0000\u2016\u2017\u0007Z\u0000\u0000\u2017\u02d3\u0001\u0000\u0000"+
"\u0000\u0474\u02d9\u02dc\u02e0\u02e3\u02e8\u02ef\u02f5\u02f7\u0300\u0303"+
"\u0305\u0332\u033a\u034a\u0351\u0354\u035a\u035e\u0367\u036c\u0379\u037e"+
"\u0387\u0393\u0398\u039b\u03a9\u03b0\u03b9\u03c7\u03cf\u03da\u03e4\u03eb"+
"\u03f2\u03f6\u03fa\u03ff\u0403\u0408\u040c\u0410\u041a\u041e\u0423\u0428"+
"\u042c\u0439\u0449\u0468\u046a\u046f\u0473\u0478\u047f\u0482\u0485\u048a"+
"\u048e\u0490\u0496\u0499\u049e\u04a2\u04a5\u04ac\u04b2\u04b5\u04bf\u04c8"+
"\u04cf\u04d6\u04d8\u04de\u04e1\u04ec\u04f5\u04fb\u0501\u0504\u0509\u050c"+
"\u050f\u0512\u0515\u051b\u0521\u052b\u0537\u053b\u0545\u0550\u0553\u055a"+
"\u055f\u0564\u0568\u0570\u0574\u0579\u057d\u057f\u0584\u058c\u0591\u0595"+
"\u059d\u05a5\u05a8\u05ab\u05b0\u05b9\u05bd\u05c7\u05da\u05de\u05e2\u05ea"+
"\u05f8\u05ff\u0603\u060a\u060c\u0610\u0614\u061c\u0620\u062f\u0632\u0636"+
"\u063d\u0644\u0646\u064a\u0650\u0653\u065a\u065e\u0661\u066c\u066f\u0679"+
"\u0680\u0684\u0688\u068f\u0693\u069b\u06a6\u06aa\u06b5\u06bc\u06ca\u06d2"+
"\u06d7\u06de\u06e6\u06ec\u06f1\u06fb\u070a\u070d\u0721\u072b\u072d\u0738"+
"\u0747\u0754\u0758\u0763\u0767\u0773\u0777\u0782\u0787\u078c\u0790\u0794"+
"\u0799\u079d\u07a1\u07b8\u07ba\u07cc\u07ce\u07d6\u07db\u07e0\u07e5\u07f2"+
"\u07f7\u07fc\u0801\u0806\u080b\u0810\u0815\u0817\u081f\u0824\u0828\u082e"+
"\u0831\u083c\u0846\u084e\u0857\u085d\u086e\u0871\u0881\u0884\u0894\u0897"+
"\u08a7\u08aa\u08ba\u08bd\u08cd\u08d0\u08de\u08ed\u08f1\u0901\u0907\u090c"+
"\u0912\u0916\u091d\u0927\u092e\u0930\u0939\u093e\u0948\u094f\u0952\u095b"+
"\u0960\u0967\u096d\u0972\u097f\u0983\u0988\u098d\u0993\u099b\u099f\u09a4"+
"\u09b5\u09b8\u09c0\u09c3\u09cb\u09d2\u09d9\u09e2\u09e9\u09f0\u09f4\u09f6"+
"\u09f9\u09fd\u0a09\u0a1f\u0a27\u0a2e\u0a31\u0a35\u0a38\u0a3a\u0a3d\u0a41"+
"\u0a45\u0a4d\u0a54\u0a58\u0a5a\u0a5d\u0a69\u0a77\u0a7f\u0a86\u0a8d\u0a92"+
"\u0aac\u0ab9\u0abb\u0abf\u0ac4\u0ac6\u0ac9\u0ae1\u0aea\u0aed\u0af3\u0af7"+
"\u0afd\u0b00\u0b05\u0b08\u0b0e\u0b12\u0b15\u0b1d\u0b20\u0b23\u0b26\u0b2c"+
"\u0b31\u0b34\u0b3f\u0b44\u0b47\u0b4a\u0b51\u0b54\u0b59\u0b5c\u0b5f\u0b63"+
"\u0b69\u0b6d\u0b73\u0b76\u0b7a\u0b7f\u0b87\u0b89\u0b8d\u0b90\u0b97\u0b9c"+
"\u0b9e\u0ba0\u0ba7\u0baa\u0bae\u0bb2\u0bb7\u0bbd\u0bc4\u0bc8\u0bcf\u0bd5"+
"\u0bdd\u0bdf\u0be7\u0bf2\u0c00\u0c04\u0c0d\u0c11\u0c1a\u0c1e\u0c20\u0c2b"+
"\u0c2e\u0c32\u0c42\u0c50\u0c59\u0c62\u0c6b\u0c6e\u0c76\u0c84\u0c88\u0c8e"+
"\u0c97\u0ca3\u0ca6\u0caf\u0cb6\u0cbe\u0cc1\u0cc4\u0cc7\u0cd5\u0cda\u0cdd"+
"\u0ceb\u0cf0\u0cf3\u0cfa\u0cfc\u0d02\u0d07\u0d0b\u0d0e\u0d11\u0d17\u0d20"+
"\u0d22\u0d2a\u0d2c\u0d3c\u0d40\u0d47\u0d4a\u0d51\u0d54\u0d58\u0d5d\u0d60"+
"\u0d64\u0d69\u0d6c\u0d73\u0d78\u0d7c\u0d80\u0d85\u0d88\u0d8e\u0d91\u0d97"+
"\u0d9e\u0db7\u0dbd\u0dc2\u0dc8\u0dcb\u0dd6\u0de1\u0de5\u0dec\u0def\u0df4"+
"\u0dfa\u0dfd\u0e0b\u0e12\u0e15\u0e18\u0e1c\u0e20\u0e25\u0e28\u0e2b\u0e2e"+
"\u0e34\u0e37\u0e3a\u0e3d\u0e43\u0e4c\u0e50\u0e53\u0e56\u0e59\u0e63\u0e67"+
"\u0e6a\u0e6d\u0e71\u0e77\u0e7a\u0e7d\u0e8d\u0e95\u0e98\u0e9b\u0e9e\u0ea4"+
"\u0ea7\u0ead\u0eb3\u0eb6\u0eba\u0ebf\u0ec2\u0ec9\u0ecc\u0ecf\u0ed5\u0edd"+
"\u0ee2\u0eeb\u0eef\u0efc\u0eff\u0f04\u0f07\u0f0c\u0f10\u0f16\u0f1c\u0f24"+
"\u0f2a\u0f2d\u0f33\u0f36\u0f3c\u0f3f\u0f49\u0f4c\u0f53\u0f56\u0f68\u0f73"+
"\u0f75\u0f77\u0f7e\u0f81\u0f84\u0f87\u0f8d\u0f93\u0f9b\u0fa7\u0fb1\u0fb4"+
"\u0fb7\u0fba\u0fc1\u0fc3\u0fcc\u0fcf\u0fd7\u0fdb\u0fe2\u0fe5\u0fe8\u0ff0"+
"\u100b\u1012\u1014\u101c\u101f\u1023\u1035\u1041\u1059\u1061\u1067\u106b"+
"\u1074\u107a\u1081\u1083\u1088\u1096\u109c\u10a1\u10a7\u10aa\u10af\u10b4"+
"\u10b6\u10bc\u10bf\u10c5\u10c8\u10d1\u10db\u10df\u10ec\u10f0\u10fa\u1101"+
"\u1107\u110e\u1110\u1116\u111a\u1120\u1124\u112a\u112e\u1133\u113c\u1164"+
"\u116b\u1172\u1175\u117b\u1187\u1194\u11a0\u11a9\u11b5\u11bc\u11c4\u11c6"+
"\u11ca\u11cd\u11d0\u11d3\u11d7\u11da\u11e0\u11e6\u11e8\u11ec\u11f0\u11f3"+
"\u11f6\u11f9\u11fd\u1201\u1204\u1207\u120a\u120c\u1216\u1224\u122b\u1233"+
"\u1240\u124e\u1255\u125d\u1262\u1266\u1269\u1270\u127b\u1288\u1295\u12a3"+
"\u12ce\u12de\u12e5\u12ed\u12f5\u12fb\u130f\u1315\u1320\u1322\u132b\u132f"+
"\u1338\u1342\u1359\u1364\u1370\u1379\u1386\u138a\u1391\u1394\u1397\u139d"+
"\u13a0\u13a3\u13ad\u13b2\u13b5\u13bb\u13be\u13c4\u13c7\u13ca\u13d0\u13d3"+
"\u13d7\u13dc\u13e2\u13e9\u13ee\u13f0\u13f2\u13f5\u13f9\u13fe\u1402\u1407"+
"\u140b\u1410\u1417\u1420\u1424\u1427\u142a\u1431\u144a\u1452\u145b\u1460"+
"\u1462\u1464\u1474\u1478\u1482\u1485\u148b\u1492\u1499\u14a0\u14a7\u14ae"+
"\u14b5\u14bb\u14be\u14c4\u14c7\u14ca\u14dd\u14e9\u14f1\u14f8\u1504\u1508"+
"\u150e\u1513\u1518\u151d\u1525\u1529\u152f\u1536\u1541\u1548\u1552\u155a"+
"\u1562\u1569\u1570\u1578\u1581\u1583\u158a\u1591\u1594\u159a\u159d\u15a3"+
"\u15a7\u15b0\u15b4\u15bf\u15c6\u15d1\u15d7\u15da\u15ef\u15f2\u1601\u1606"+
"\u1609\u1613\u1617\u161a\u1620\u1626\u1629\u1630\u163c\u1644\u164b\u164f"+
"\u1656\u165c\u1660\u1663\u1667\u166a\u1670\u1675\u167c\u167f\u1683\u168a"+
"\u168f\u1696\u16a1\u16a8\u16ad\u16b2\u16be\u16c3\u16ca\u16d2\u16da\u16dd"+
"\u16e1\u16e5\u16eb\u16ef\u16f7\u16fb\u1703\u1707\u170f\u1717\u171e\u1721"+
"\u1728\u1733\u1737\u173f\u1743\u174b\u1752\u1756\u1758\u175f\u1766\u1768"+
"\u176f\u1776\u177a\u1780\u1785\u1787\u178f\u1791\u1798\u179a\u179e\u17a4"+
"\u17a6\u17a9\u17b0\u17b5\u17ba\u17bf\u17c3\u17d1\u17d6\u17e3\u17e5\u17ec"+
"\u17f4\u17f8\u17fd\u1802\u1807\u180f\u1818\u181b\u1820\u1822\u1828\u182f"+
"\u183d\u1841\u1846\u184c\u1852\u1859\u185c\u1862\u1868\u186e\u1878\u187c"+
"\u187f\u1881\u1886\u188b\u1892\u189e\u18a0\u18ae\u18b1\u18b6\u18be\u18c1"+
"\u18c6\u18cb\u18d5\u18dc\u18df\u18e2\u18ec\u18f4\u18fa\u1900\u1905\u190a"+
"\u190d\u1910\u1913\u1916\u1919\u191c\u191f\u1922\u1925\u1928\u1933\u1936"+
"\u1939\u193c\u193f\u1941\u194d\u1954\u195a\u195e\u1963\u196a\u196f\u1978"+
"\u197a\u1980\u1983\u1987\u198a\u198d\u199b\u19b8\u19db\u19dd\u19e6\u19ea"+
"\u19f3\u19f9\u19ff\u1a02\u1a05\u1a08\u1a0b\u1a13\u1a1b\u1a1e\u1a21\u1a2c"+
"\u1a32\u1a35\u1a37\u1a42\u1a46\u1a49\u1a4c\u1a4f\u1a52\u1a5d\u1a62\u1a6f"+
"\u1a76\u1a81\u1a8a\u1a8f\u1a94\u1a98\u1aa8\u1aaf\u1ab5\u1ab9\u1ac3\u1acb"+
"\u1ad6\u1adb\u1ae8\u1aeb\u1af5\u1af8\u1b03\u1b0d\u1b12\u1b14\u1b1c\u1b1f"+
"\u1b28\u1b2d\u1b36\u1b3b\u1b40\u1b46\u1b48\u1b4b\u1b51\u1b58\u1b64\u1b67"+
"\u1b71\u1b75\u1b78\u1b81\u1b86\u1b8a\u1b96\u1b9f\u1ba3\u1ba8\u1bac\u1bb0"+
"\u1bba\u1bc0\u1bcb\u1bd3\u1bd9\u1bdc\u1bdf\u1be2\u1be5\u1be9\u1bec\u1bf1"+
"\u1bfb\u1c01\u1c0a\u1c19\u1c22\u1c26\u1c29\u1c2d\u1c2f\u1c36\u1c3e\u1c44"+
"\u1c4b\u1c51\u1c54\u1c58\u1c5f\u1c62\u1c65\u1c6c\u1c6e\u1c73\u1c77\u1c84"+
"\u1c86\u1c88\u1c91\u1c93\u1c97\u1c9e\u1ca5\u1cab\u1cb2\u1cb6\u1cbd\u1cc4"+
"\u1cca\u1cd0\u1cd8\u1cde\u1cef\u1cf5\u1cfa\u1d02\u1d08\u1d0a\u1d12\u1d18"+
"\u1d1e\u1d25\u1d2d\u1d30\u1d3b\u1d46\u1d4b\u1d4e\u1d55\u1d5a\u1d66\u1d6c"+
"\u1d82\u1d84\u1d92\u1d94\u1d9d\u1da0\u1da7\u1daa\u1db2\u1db7\u1dbd\u1dc0"+
"\u1dc5\u1dcd\u1dd6\u1ddd\u1de2\u1de5\u1deb\u1df7\u1df9\u1e08\u1e0c\u1e15"+
"\u1e19\u1e32\u1e37\u1e53\u1e57\u1e62\u1e6a\u1e6f\u1e7b\u1e87\u1e89\u1e8b"+
"\u1e91\u1e93\u1e98\u1e9f\u1ea9\u1eac\u1eae\u1eb3\u1eb8\u1ecc\u1ed0\u1ed3"+
"\u1ed6\u1ee3\u1eee\u1ef5\u1ef9\u1efe\u1f01\u1f05\u1f0d\u1f12\u1f18\u1f21"+
"\u1f2a\u1f34\u1f3a\u1f4d\u1f50\u1f6d\u1f7a\u1f7e\u1f80\u1fa1\u1fa8\u1faf"+
"\u1fc3\u1fca\u1fce\u1fd4\u1fde\u1fe3\u1fe9\u1ff5\u1ffe\u2001\u2008\u200d"+
"\u2011\u2014";
public static final String _serializedATN = Utils.join(
new String[] {
_serializedATNSegment0,
_serializedATNSegment1,
_serializedATNSegment2,
_serializedATNSegment3
},
""
);
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}