Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.edurt.datacap.parser.mysql.MySqlParser Maven / Gradle / Ivy
// Generated from io/edurt/datacap/parser/mysql/MySqlParser.g4 by ANTLR 4.12.0
package io.edurt.datacap.parser.mysql;
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 MySqlParser extends Parser {
static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
SPACE=1, SPEC_MYSQL_COMMENT=2, COMMENT_INPUT=3, LINE_COMMENT=4, ADD=5,
ALL=6, ALTER=7, ALWAYS=8, ANALYZE=9, AND=10, ARRAY=11, AS=12, ASC=13,
ATTRIBUTE=14, BEFORE=15, BETWEEN=16, BOTH=17, BUCKETS=18, BY=19, CALL=20,
CASCADE=21, CASE=22, CAST=23, CHANGE=24, CHARACTER=25, CHECK=26, COLLATE=27,
COLUMN=28, CONDITION=29, CONSTRAINT=30, CONTINUE=31, CONVERT=32, CREATE=33,
CROSS=34, CURRENT=35, CURRENT_ROLE=36, CURRENT_USER=37, CURSOR=38, DATABASE=39,
DATABASES=40, DECLARE=41, DEFAULT=42, DELAYED=43, DELETE=44, DESC=45,
DESCRIBE=46, DETERMINISTIC=47, DIAGNOSTICS=48, DISTINCT=49, DISTINCTROW=50,
DROP=51, EACH=52, ELSE=53, ELSEIF=54, EMPTY=55, ENCLOSED=56, ENFORCED=57,
ESCAPED=58, EXCEPT=59, EXISTS=60, EXIT=61, EXPLAIN=62, FALSE=63, FETCH=64,
FOR=65, FORCE=66, FOREIGN=67, FROM=68, FULLTEXT=69, GENERATED=70, GET=71,
GRANT=72, GROUP=73, HAVING=74, HIGH_PRIORITY=75, HISTOGRAM=76, IF=77,
IGNORE=78, IGNORED=79, IN=80, INDEX=81, INFILE=82, INNER=83, INOUT=84,
INSERT=85, INTERVAL=86, INTO=87, IS=88, ITERATE=89, JOIN=90, KEY=91, KEYS=92,
KILL=93, LATERAL=94, LEADING=95, LEAVE=96, LEFT=97, LIKE=98, LIMIT=99,
LINEAR=100, LINES=101, LOAD=102, LOCK=103, LOCKED=104, LOOP=105, LOW_PRIORITY=106,
MASTER_BIND=107, MASTER_SSL_VERIFY_SERVER_CERT=108, MATCH=109, MAXVALUE=110,
MINVALUE=111, MODIFIES=112, NATURAL=113, NOT=114, NO_WRITE_TO_BINLOG=115,
NULL_LITERAL=116, NUMBER=117, ON=118, OPTIMIZE=119, OPTION=120, OPTIONAL=121,
OPTIONALLY=122, OR=123, ORDER=124, OUT=125, OUTER=126, OUTFILE=127, OVER=128,
PARTITION=129, PRIMARY=130, PROCEDURE=131, PURGE=132, RANGE=133, READ=134,
READS=135, REFERENCES=136, REGEXP=137, RELEASE=138, RENAME=139, REPEAT=140,
REPLACE=141, REQUIRE=142, RESIGNAL=143, RESTRICT=144, RETAIN=145, RETURN=146,
REVOKE=147, RIGHT=148, RLIKE=149, SCHEMA=150, SCHEMAS=151, SELECT=152,
SET=153, SEPARATOR=154, SHOW=155, SIGNAL=156, SKIP_=157, SKIP_QUERY_REWRITE=158,
SPATIAL=159, SQL=160, SQLEXCEPTION=161, SQLSTATE=162, SQLWARNING=163,
SQL_BIG_RESULT=164, SQL_CALC_FOUND_ROWS=165, SQL_SMALL_RESULT=166, SSL=167,
STACKED=168, STARTING=169, STATEMENT=170, STRAIGHT_JOIN=171, TABLE=172,
TERMINATED=173, THEN=174, TO=175, TRAILING=176, TRIGGER=177, TRUE=178,
UNDO=179, UNION=180, UNIQUE=181, UNLOCK=182, UNSIGNED=183, UPDATE=184,
USAGE=185, USE=186, USING=187, VALUES=188, WHEN=189, WHERE=190, WHILE=191,
WITH=192, WRITE=193, XOR=194, ZEROFILL=195, TINYINT=196, SMALLINT=197,
MEDIUMINT=198, MIDDLEINT=199, INT=200, INT1=201, INT2=202, INT3=203, INT4=204,
INT8=205, INTEGER=206, BIGINT=207, REAL=208, DOUBLE=209, PRECISION=210,
FLOAT=211, FLOAT4=212, FLOAT8=213, DECIMAL=214, DEC=215, NUMERIC=216,
DATE=217, TIME=218, TIMESTAMP=219, DATETIME=220, YEAR=221, CHAR=222, VARCHAR=223,
NVARCHAR=224, NATIONAL=225, BINARY=226, VARBINARY=227, TINYBLOB=228, BLOB=229,
MEDIUMBLOB=230, LONG=231, LONGBLOB=232, TINYTEXT=233, TEXT=234, MEDIUMTEXT=235,
LONGTEXT=236, ENUM=237, VARYING=238, SERIAL=239, YEAR_MONTH=240, DAY_HOUR=241,
DAY_MINUTE=242, DAY_SECOND=243, HOUR_MINUTE=244, HOUR_SECOND=245, MINUTE_SECOND=246,
SECOND_MICROSECOND=247, MINUTE_MICROSECOND=248, HOUR_MICROSECOND=249,
DAY_MICROSECOND=250, JSON_ARRAY=251, JSON_ARRAYAGG=252, JSON_ARRAY_APPEND=253,
JSON_ARRAY_INSERT=254, JSON_CONTAINS=255, JSON_CONTAINS_PATH=256, JSON_DEPTH=257,
JSON_EXTRACT=258, JSON_INSERT=259, JSON_KEYS=260, JSON_LENGTH=261, JSON_MERGE=262,
JSON_MERGE_PATCH=263, JSON_MERGE_PRESERVE=264, JSON_OBJECT=265, JSON_OBJECTAGG=266,
JSON_OVERLAPS=267, JSON_PRETTY=268, JSON_QUOTE=269, JSON_REMOVE=270, JSON_REPLACE=271,
JSON_SCHEMA_VALID=272, JSON_SCHEMA_VALIDATION_REPORT=273, JSON_SEARCH=274,
JSON_SET=275, JSON_STORAGE_FREE=276, JSON_STORAGE_SIZE=277, JSON_TABLE=278,
JSON_TYPE=279, JSON_UNQUOTE=280, JSON_VALID=281, JSON_VALUE=282, NESTED=283,
ORDINALITY=284, PATH=285, AVG=286, BIT_AND=287, BIT_OR=288, BIT_XOR=289,
COUNT=290, CUME_DIST=291, DENSE_RANK=292, FIRST_VALUE=293, GROUP_CONCAT=294,
LAG=295, LAST_VALUE=296, LEAD=297, MAX=298, MIN=299, NTILE=300, NTH_VALUE=301,
PERCENT_RANK=302, RANK=303, ROW_NUMBER=304, STD=305, STDDEV=306, STDDEV_POP=307,
STDDEV_SAMP=308, SUM=309, VAR_POP=310, VAR_SAMP=311, VARIANCE=312, CURRENT_DATE=313,
CURRENT_TIME=314, CURRENT_TIMESTAMP=315, LOCALTIME=316, CURDATE=317, CURTIME=318,
DATE_ADD=319, DATE_SUB=320, EXTRACT=321, LOCALTIMESTAMP=322, NOW=323,
POSITION=324, SUBSTR=325, SUBSTRING=326, SYSDATE=327, TRIM=328, UTC_DATE=329,
UTC_TIME=330, UTC_TIMESTAMP=331, ACCOUNT=332, ACTION=333, AFTER=334, AGGREGATE=335,
ALGORITHM=336, ANY=337, AT=338, AUTHORS=339, AUTOCOMMIT=340, AUTOEXTEND_SIZE=341,
AUTO_INCREMENT=342, AVG_ROW_LENGTH=343, BEGIN=344, BINLOG=345, BIT=346,
BLOCK=347, BOOL=348, BOOLEAN=349, BTREE=350, CACHE=351, CASCADED=352,
CHAIN=353, CHANGED=354, CHANNEL=355, CHECKSUM=356, PAGE_CHECKSUM=357,
CIPHER=358, CLASS_ORIGIN=359, CLIENT=360, CLOSE=361, CLUSTERING=362, COALESCE=363,
CODE=364, COLUMNS=365, COLUMN_FORMAT=366, COLUMN_NAME=367, COMMENT=368,
COMMIT=369, COMPACT=370, COMPLETION=371, COMPRESSED=372, COMPRESSION=373,
CONCURRENT=374, CONNECT=375, CONNECTION=376, CONSISTENT=377, CONSTRAINT_CATALOG=378,
CONSTRAINT_SCHEMA=379, CONSTRAINT_NAME=380, CONTAINS=381, CONTEXT=382,
CONTRIBUTORS=383, COPY=384, CPU=385, CYCLE=386, CURSOR_NAME=387, DATA=388,
DATAFILE=389, DEALLOCATE=390, DEFAULT_AUTH=391, DEFINER=392, DELAY_KEY_WRITE=393,
DES_KEY_FILE=394, DIRECTORY=395, DISABLE=396, DISCARD=397, DISK=398, DO=399,
DUMPFILE=400, DUPLICATE=401, DYNAMIC=402, ENABLE=403, ENCRYPTED=404, ENCRYPTION=405,
ENCRYPTION_KEY_ID=406, END=407, ENDS=408, ENGINE=409, ENGINES=410, ERROR=411,
ERRORS=412, ESCAPE=413, EVEN=414, EVENT=415, EVENTS=416, EVERY=417, EXCHANGE=418,
EXCLUSIVE=419, EXPIRE=420, EXPORT=421, EXTENDED=422, EXTENT_SIZE=423,
FAILED_LOGIN_ATTEMPTS=424, FAST=425, FAULTS=426, FIELDS=427, FILE_BLOCK_SIZE=428,
FILTER=429, FIRST=430, FIXED=431, FLUSH=432, FOLLOWING=433, FOLLOWS=434,
FOUND=435, FULL=436, FUNCTION=437, GENERAL=438, GLOBAL=439, GRANTS=440,
GROUP_REPLICATION=441, HANDLER=442, HASH=443, HELP=444, HISTORY=445, HOST=446,
HOSTS=447, IDENTIFIED=448, IGNORE_SERVER_IDS=449, IMPORT=450, INCREMENT=451,
INDEXES=452, INITIAL_SIZE=453, INPLACE=454, INSERT_METHOD=455, INSTALL=456,
INSTANCE=457, INSTANT=458, INVISIBLE=459, INVOKER=460, IO=461, IO_THREAD=462,
IPC=463, ISOLATION=464, ISSUER=465, JSON=466, KEY_BLOCK_SIZE=467, LANGUAGE=468,
LAST=469, LEAVES=470, LESS=471, LEVEL=472, LIST=473, LOCAL=474, LOGFILE=475,
LOGS=476, MASTER=477, MASTER_AUTO_POSITION=478, MASTER_CONNECT_RETRY=479,
MASTER_DELAY=480, MASTER_HEARTBEAT_PERIOD=481, MASTER_HOST=482, MASTER_LOG_FILE=483,
MASTER_LOG_POS=484, MASTER_PASSWORD=485, MASTER_PORT=486, MASTER_RETRY_COUNT=487,
MASTER_SSL=488, MASTER_SSL_CA=489, MASTER_SSL_CAPATH=490, MASTER_SSL_CERT=491,
MASTER_SSL_CIPHER=492, MASTER_SSL_CRL=493, MASTER_SSL_CRLPATH=494, MASTER_SSL_KEY=495,
MASTER_TLS_VERSION=496, MASTER_USER=497, MAX_CONNECTIONS_PER_HOUR=498,
MAX_QUERIES_PER_HOUR=499, MAX_ROWS=500, MAX_SIZE=501, MAX_UPDATES_PER_HOUR=502,
MAX_USER_CONNECTIONS=503, MEDIUM=504, MEMBER=505, MERGE=506, MESSAGE_TEXT=507,
MID=508, MIGRATE=509, MIN_ROWS=510, MODE=511, MODIFY=512, MUTEX=513, MYSQL=514,
MYSQL_ERRNO=515, NAME=516, NAMES=517, NCHAR=518, NEVER=519, NEXT=520,
NO=521, NOCACHE=522, NOCOPY=523, NOCYCLE=524, NOMAXVALUE=525, NOMINVALUE=526,
NOWAIT=527, NODEGROUP=528, NONE=529, ODBC=530, OFFLINE=531, OFFSET=532,
OF=533, OJ=534, OLD_PASSWORD=535, ONE=536, ONLINE=537, ONLY=538, OPEN=539,
OPTIMIZER_COSTS=540, OPTIONS=541, OWNER=542, PACK_KEYS=543, PAGE=544,
PAGE_COMPRESSED=545, PAGE_COMPRESSION_LEVEL=546, PARSER=547, PARTIAL=548,
PARTITIONING=549, PARTITIONS=550, PASSWORD=551, PASSWORD_LOCK_TIME=552,
PHASE=553, PLUGIN=554, PLUGIN_DIR=555, PLUGINS=556, PORT=557, PRECEDES=558,
PRECEDING=559, PREPARE=560, PRESERVE=561, PREV=562, PROCESSLIST=563, PROFILE=564,
PROFILES=565, PROXY=566, QUERY=567, QUICK=568, REBUILD=569, RECOVER=570,
RECURSIVE=571, REDO_BUFFER_SIZE=572, REDUNDANT=573, RELAY=574, RELAY_LOG_FILE=575,
RELAY_LOG_POS=576, RELAYLOG=577, REMOVE=578, REORGANIZE=579, REPAIR=580,
REPLICATE_DO_DB=581, REPLICATE_DO_TABLE=582, REPLICATE_IGNORE_DB=583,
REPLICATE_IGNORE_TABLE=584, REPLICATE_REWRITE_DB=585, REPLICATE_WILD_DO_TABLE=586,
REPLICATE_WILD_IGNORE_TABLE=587, REPLICATION=588, RESET=589, RESTART=590,
RESUME=591, RETURNED_SQLSTATE=592, RETURNING=593, RETURNS=594, REUSE=595,
ROLE=596, ROLLBACK=597, ROLLUP=598, ROTATE=599, ROW=600, ROWS=601, ROW_FORMAT=602,
RTREE=603, SAVEPOINT=604, SCHEDULE=605, SECURITY=606, SEQUENCE=607, SERVER=608,
SESSION=609, SHARE=610, SHARED=611, SIGNED=612, SIMPLE=613, SLAVE=614,
SLOW=615, SNAPSHOT=616, SOCKET=617, SOME=618, SONAME=619, SOUNDS=620,
SOURCE=621, SQL_AFTER_GTIDS=622, SQL_AFTER_MTS_GAPS=623, SQL_BEFORE_GTIDS=624,
SQL_BUFFER_RESULT=625, SQL_CACHE=626, SQL_NO_CACHE=627, SQL_THREAD=628,
START=629, STARTS=630, STATS_AUTO_RECALC=631, STATS_PERSISTENT=632, STATS_SAMPLE_PAGES=633,
STATUS=634, STOP=635, STORAGE=636, STORED=637, STRING=638, SUBCLASS_ORIGIN=639,
SUBJECT=640, SUBPARTITION=641, SUBPARTITIONS=642, SUSPEND=643, SWAPS=644,
SWITCHES=645, TABLE_NAME=646, TABLESPACE=647, TABLE_TYPE=648, TEMPORARY=649,
TEMPTABLE=650, THAN=651, TRADITIONAL=652, TRANSACTION=653, TRANSACTIONAL=654,
TRIGGERS=655, TRUNCATE=656, UNBOUNDED=657, UNDEFINED=658, UNDOFILE=659,
UNDO_BUFFER_SIZE=660, UNINSTALL=661, UNKNOWN=662, UNTIL=663, UPGRADE=664,
USER=665, USE_FRM=666, USER_RESOURCES=667, VALIDATION=668, VALUE=669,
VARIABLES=670, VIEW=671, VIRTUAL=672, VISIBLE=673, WAIT=674, WARNINGS=675,
WINDOW=676, WITHOUT=677, WORK=678, WRAPPER=679, X509=680, XA=681, XML=682,
YES=683, EUR=684, USA=685, JIS=686, ISO=687, INTERNAL=688, QUARTER=689,
MONTH=690, DAY=691, HOUR=692, MINUTE=693, WEEK=694, SECOND=695, MICROSECOND=696,
ADMIN=697, APPLICATION_PASSWORD_ADMIN=698, AUDIT_ABORT_EXEMPT=699, AUDIT_ADMIN=700,
AUTHENTICATION_POLICY_ADMIN=701, BACKUP_ADMIN=702, BINLOG_ADMIN=703, BINLOG_ENCRYPTION_ADMIN=704,
CLONE_ADMIN=705, CONNECTION_ADMIN=706, ENCRYPTION_KEY_ADMIN=707, EXECUTE=708,
FILE=709, FIREWALL_ADMIN=710, FIREWALL_EXEMPT=711, FIREWALL_USER=712,
FLUSH_OPTIMIZER_COSTS=713, FLUSH_STATUS=714, FLUSH_TABLES=715, FLUSH_USER_RESOURCES=716,
GROUP_REPLICATION_ADMIN=717, INNODB_REDO_LOG_ARCHIVE=718, INNODB_REDO_LOG_ENABLE=719,
INVOKE=720, LAMBDA=721, NDB_STORED_USER=722, PASSWORDLESS_USER_ADMIN=723,
PERSIST_RO_VARIABLES_ADMIN=724, PRIVILEGES=725, PROCESS=726, RELOAD=727,
REPLICATION_APPLIER=728, REPLICATION_SLAVE_ADMIN=729, RESOURCE_GROUP_ADMIN=730,
RESOURCE_GROUP_USER=731, ROLE_ADMIN=732, ROUTINE=733, S3=734, SERVICE_CONNECTION_ADMIN=735,
SESSION_VARIABLES_ADMIN=736, SET_USER_ID=737, SHOW_ROUTINE=738, SHUTDOWN=739,
SUPER=740, SYSTEM_VARIABLES_ADMIN=741, TABLES=742, TABLE_ENCRYPTION_ADMIN=743,
VERSION_TOKEN_ADMIN=744, XA_RECOVER_ADMIN=745, ARMSCII8=746, ASCII=747,
BIG5=748, CP1250=749, CP1251=750, CP1256=751, CP1257=752, CP850=753, CP852=754,
CP866=755, CP932=756, DEC8=757, EUCJPMS=758, EUCKR=759, GB18030=760, GB2312=761,
GBK=762, GEOSTD8=763, GREEK=764, HEBREW=765, HP8=766, KEYBCS2=767, KOI8R=768,
KOI8U=769, LATIN1=770, LATIN2=771, LATIN5=772, LATIN7=773, MACCE=774,
MACROMAN=775, SJIS=776, SWE7=777, TIS620=778, UCS2=779, UJIS=780, UTF16=781,
UTF16LE=782, UTF32=783, UTF8=784, UTF8MB3=785, UTF8MB4=786, ARCHIVE=787,
BLACKHOLE=788, CSV=789, FEDERATED=790, INNODB=791, MEMORY=792, MRG_MYISAM=793,
MYISAM=794, NDB=795, NDBCLUSTER=796, PERFORMANCE_SCHEMA=797, TOKUDB=798,
REPEATABLE=799, COMMITTED=800, UNCOMMITTED=801, SERIALIZABLE=802, GEOMETRYCOLLECTION=803,
GEOMCOLLECTION=804, GEOMETRY=805, LINESTRING=806, MULTILINESTRING=807,
MULTIPOINT=808, MULTIPOLYGON=809, POINT=810, POLYGON=811, ABS=812, ACOS=813,
ADDDATE=814, ADDTIME=815, AES_DECRYPT=816, AES_ENCRYPT=817, AREA=818,
ASBINARY=819, ASIN=820, ASTEXT=821, ASWKB=822, ASWKT=823, ASYMMETRIC_DECRYPT=824,
ASYMMETRIC_DERIVE=825, ASYMMETRIC_ENCRYPT=826, ASYMMETRIC_SIGN=827, ASYMMETRIC_VERIFY=828,
ATAN=829, ATAN2=830, BENCHMARK=831, BIN=832, BIT_COUNT=833, BIT_LENGTH=834,
BUFFER=835, CATALOG_NAME=836, CEIL=837, CEILING=838, CENTROID=839, CHARACTER_LENGTH=840,
CHARSET=841, CHAR_LENGTH=842, COERCIBILITY=843, COLLATION=844, COMPRESS=845,
CONCAT=846, CONCAT_WS=847, CONNECTION_ID=848, CONV=849, CONVERT_TZ=850,
COS=851, COT=852, CRC32=853, CREATE_ASYMMETRIC_PRIV_KEY=854, CREATE_ASYMMETRIC_PUB_KEY=855,
CREATE_DH_PARAMETERS=856, CREATE_DIGEST=857, CROSSES=858, DATEDIFF=859,
DATE_FORMAT=860, DAYNAME=861, DAYOFMONTH=862, DAYOFWEEK=863, DAYOFYEAR=864,
DECODE=865, DEGREES=866, DES_DECRYPT=867, DES_ENCRYPT=868, DIMENSION=869,
DISJOINT=870, ELT=871, ENCODE=872, ENCRYPT=873, ENDPOINT=874, ENGINE_ATTRIBUTE=875,
ENVELOPE=876, EQUALS=877, EXP=878, EXPORT_SET=879, EXTERIORRING=880, EXTRACTVALUE=881,
FIELD=882, FIND_IN_SET=883, FLOOR=884, FORMAT=885, FOUND_ROWS=886, FROM_BASE64=887,
FROM_DAYS=888, FROM_UNIXTIME=889, GEOMCOLLFROMTEXT=890, GEOMCOLLFROMWKB=891,
GEOMETRYCOLLECTIONFROMTEXT=892, GEOMETRYCOLLECTIONFROMWKB=893, GEOMETRYFROMTEXT=894,
GEOMETRYFROMWKB=895, GEOMETRYN=896, GEOMETRYTYPE=897, GEOMFROMTEXT=898,
GEOMFROMWKB=899, GET_FORMAT=900, GET_LOCK=901, GLENGTH=902, GREATEST=903,
GTID_SUBSET=904, GTID_SUBTRACT=905, HEX=906, IFNULL=907, INET6_ATON=908,
INET6_NTOA=909, INET_ATON=910, INET_NTOA=911, INSTR=912, INTERIORRINGN=913,
INTERSECTS=914, ISCLOSED=915, ISEMPTY=916, ISNULL=917, ISSIMPLE=918, IS_FREE_LOCK=919,
IS_IPV4=920, IS_IPV4_COMPAT=921, IS_IPV4_MAPPED=922, IS_IPV6=923, IS_USED_LOCK=924,
LAST_INSERT_ID=925, LCASE=926, LEAST=927, LENGTH=928, LINEFROMTEXT=929,
LINEFROMWKB=930, LINESTRINGFROMTEXT=931, LINESTRINGFROMWKB=932, LN=933,
LOAD_FILE=934, LOCATE=935, LOG=936, LOG10=937, LOG2=938, LOWER=939, LPAD=940,
LTRIM=941, MAKEDATE=942, MAKETIME=943, MAKE_SET=944, MASTER_POS_WAIT=945,
MBRCONTAINS=946, MBRDISJOINT=947, MBREQUAL=948, MBRINTERSECTS=949, MBROVERLAPS=950,
MBRTOUCHES=951, MBRWITHIN=952, MD5=953, MLINEFROMTEXT=954, MLINEFROMWKB=955,
MONTHNAME=956, MPOINTFROMTEXT=957, MPOINTFROMWKB=958, MPOLYFROMTEXT=959,
MPOLYFROMWKB=960, MULTILINESTRINGFROMTEXT=961, MULTILINESTRINGFROMWKB=962,
MULTIPOINTFROMTEXT=963, MULTIPOINTFROMWKB=964, MULTIPOLYGONFROMTEXT=965,
MULTIPOLYGONFROMWKB=966, NAME_CONST=967, NULLIF=968, NUMGEOMETRIES=969,
NUMINTERIORRINGS=970, NUMPOINTS=971, OCT=972, OCTET_LENGTH=973, ORD=974,
OVERLAPS=975, PERIOD_ADD=976, PERIOD_DIFF=977, PI=978, POINTFROMTEXT=979,
POINTFROMWKB=980, POINTN=981, POLYFROMTEXT=982, POLYFROMWKB=983, POLYGONFROMTEXT=984,
POLYGONFROMWKB=985, POW=986, POWER=987, QUOTE=988, RADIANS=989, RAND=990,
RANDOM=991, RANDOM_BYTES=992, RELEASE_LOCK=993, REVERSE=994, ROUND=995,
ROW_COUNT=996, RPAD=997, RTRIM=998, SEC_TO_TIME=999, SECONDARY_ENGINE_ATTRIBUTE=1000,
SESSION_USER=1001, SHA=1002, SHA1=1003, SHA2=1004, SCHEMA_NAME=1005, SIGN=1006,
SIN=1007, SLEEP=1008, SOUNDEX=1009, SQL_THREAD_WAIT_AFTER_GTIDS=1010,
SQRT=1011, SRID=1012, STARTPOINT=1013, STRCMP=1014, STR_TO_DATE=1015,
ST_AREA=1016, ST_ASBINARY=1017, ST_ASTEXT=1018, ST_ASWKB=1019, ST_ASWKT=1020,
ST_BUFFER=1021, ST_CENTROID=1022, ST_CONTAINS=1023, ST_CROSSES=1024, ST_DIFFERENCE=1025,
ST_DIMENSION=1026, ST_DISJOINT=1027, ST_DISTANCE=1028, ST_ENDPOINT=1029,
ST_ENVELOPE=1030, ST_EQUALS=1031, ST_EXTERIORRING=1032, ST_GEOMCOLLFROMTEXT=1033,
ST_GEOMCOLLFROMTXT=1034, ST_GEOMCOLLFROMWKB=1035, ST_GEOMETRYCOLLECTIONFROMTEXT=1036,
ST_GEOMETRYCOLLECTIONFROMWKB=1037, ST_GEOMETRYFROMTEXT=1038, ST_GEOMETRYFROMWKB=1039,
ST_GEOMETRYN=1040, ST_GEOMETRYTYPE=1041, ST_GEOMFROMTEXT=1042, ST_GEOMFROMWKB=1043,
ST_INTERIORRINGN=1044, ST_INTERSECTION=1045, ST_INTERSECTS=1046, ST_ISCLOSED=1047,
ST_ISEMPTY=1048, ST_ISSIMPLE=1049, ST_LINEFROMTEXT=1050, ST_LINEFROMWKB=1051,
ST_LINESTRINGFROMTEXT=1052, ST_LINESTRINGFROMWKB=1053, ST_NUMGEOMETRIES=1054,
ST_NUMINTERIORRING=1055, ST_NUMINTERIORRINGS=1056, ST_NUMPOINTS=1057,
ST_OVERLAPS=1058, ST_POINTFROMTEXT=1059, ST_POINTFROMWKB=1060, ST_POINTN=1061,
ST_POLYFROMTEXT=1062, ST_POLYFROMWKB=1063, ST_POLYGONFROMTEXT=1064, ST_POLYGONFROMWKB=1065,
ST_SRID=1066, ST_STARTPOINT=1067, ST_SYMDIFFERENCE=1068, ST_TOUCHES=1069,
ST_UNION=1070, ST_WITHIN=1071, ST_X=1072, ST_Y=1073, SUBDATE=1074, SUBSTRING_INDEX=1075,
SUBTIME=1076, SYSTEM_USER=1077, TAN=1078, TIMEDIFF=1079, TIMESTAMPADD=1080,
TIMESTAMPDIFF=1081, TIME_FORMAT=1082, TIME_TO_SEC=1083, TOUCHES=1084,
TO_BASE64=1085, TO_DAYS=1086, TO_SECONDS=1087, TP_CONNECTION_ADMIN=1088,
UCASE=1089, UNCOMPRESS=1090, UNCOMPRESSED_LENGTH=1091, UNHEX=1092, UNIX_TIMESTAMP=1093,
UPDATEXML=1094, UPPER=1095, UUID=1096, UUID_SHORT=1097, VALIDATE_PASSWORD_STRENGTH=1098,
VERSION=1099, WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS=1100, WEEKDAY=1101, WEEKOFYEAR=1102,
WEIGHT_STRING=1103, WITHIN=1104, YEARWEEK=1105, Y_FUNCTION=1106, X_FUNCTION=1107,
VAR_ASSIGN=1108, PLUS_ASSIGN=1109, MINUS_ASSIGN=1110, MULT_ASSIGN=1111,
DIV_ASSIGN=1112, MOD_ASSIGN=1113, AND_ASSIGN=1114, XOR_ASSIGN=1115, OR_ASSIGN=1116,
STAR=1117, DIVIDE=1118, MODULE=1119, PLUS=1120, MINUS=1121, DIV=1122,
MOD=1123, EQUAL_SYMBOL=1124, GREATER_SYMBOL=1125, LESS_SYMBOL=1126, EXCLAMATION_SYMBOL=1127,
BIT_NOT_OP=1128, BIT_OR_OP=1129, BIT_AND_OP=1130, BIT_XOR_OP=1131, DOT=1132,
LR_BRACKET=1133, RR_BRACKET=1134, COMMA=1135, SEMI=1136, AT_SIGN=1137,
ZERO_DECIMAL=1138, ONE_DECIMAL=1139, TWO_DECIMAL=1140, SINGLE_QUOTE_SYMB=1141,
DOUBLE_QUOTE_SYMB=1142, REVERSE_QUOTE_SYMB=1143, COLON_SYMB=1144, CHARSET_REVERSE_QOUTE_STRING=1145,
FILESIZE_LITERAL=1146, START_NATIONAL_STRING_LITERAL=1147, STRING_LITERAL=1148,
DECIMAL_LITERAL=1149, HEXADECIMAL_LITERAL=1150, REAL_LITERAL=1151, NULL_SPEC_LITERAL=1152,
BIT_STRING=1153, STRING_CHARSET_NAME=1154, DOT_ID=1155, ID=1156, REVERSE_QUOTE_ID=1157,
HOST_IP_ADDRESS=1158, LOCAL_ID=1159, GLOBAL_ID=1160, ERROR_RECONGNIGION=1161;
public static final int
RULE_root = 0, RULE_sqlStatements = 1, RULE_sqlStatement = 2, RULE_emptyStatement_ = 3,
RULE_ddlStatement = 4, RULE_dmlStatement = 5, RULE_transactionStatement = 6,
RULE_replicationStatement = 7, RULE_preparedStatement = 8, RULE_compoundStatement = 9,
RULE_administrationStatement = 10, RULE_utilityStatement = 11, RULE_createDatabase = 12,
RULE_createEvent = 13, RULE_createIndex = 14, RULE_createLogfileGroup = 15,
RULE_createProcedure = 16, RULE_createFunction = 17, RULE_createRole = 18,
RULE_createServer = 19, RULE_createTable = 20, RULE_createTablespaceInnodb = 21,
RULE_createTablespaceNdb = 22, RULE_createTrigger = 23, RULE_withClause = 24,
RULE_commonTableExpressions = 25, RULE_cteName = 26, RULE_cteColumnName = 27,
RULE_createView = 28, RULE_createDatabaseOption = 29, RULE_charSet = 30,
RULE_currentUserExpression = 31, RULE_ownerStatement = 32, RULE_scheduleExpression = 33,
RULE_timestampValue = 34, RULE_intervalExpr = 35, RULE_intervalType = 36,
RULE_enableType = 37, RULE_indexType = 38, RULE_indexOption = 39, RULE_procedureParameter = 40,
RULE_functionParameter = 41, RULE_routineOption = 42, RULE_serverOption = 43,
RULE_createDefinitions = 44, RULE_createDefinition = 45, RULE_columnDefinition = 46,
RULE_columnConstraint = 47, RULE_tableConstraint = 48, RULE_referenceDefinition = 49,
RULE_referenceAction = 50, RULE_referenceControlType = 51, RULE_indexColumnDefinition = 52,
RULE_tableOption = 53, RULE_tableType = 54, RULE_tablespaceStorage = 55,
RULE_partitionDefinitions = 56, RULE_partitionFunctionDefinition = 57,
RULE_subpartitionFunctionDefinition = 58, RULE_partitionDefinition = 59,
RULE_partitionDefinerAtom = 60, RULE_partitionDefinerVector = 61, RULE_subpartitionDefinition = 62,
RULE_partitionOption = 63, RULE_alterDatabase = 64, RULE_alterEvent = 65,
RULE_alterFunction = 66, RULE_alterInstance = 67, RULE_alterLogfileGroup = 68,
RULE_alterProcedure = 69, RULE_alterServer = 70, RULE_alterTable = 71,
RULE_alterTablespace = 72, RULE_alterView = 73, RULE_alterSpecification = 74,
RULE_alterPartitionSpecification = 75, RULE_dropDatabase = 76, RULE_dropEvent = 77,
RULE_dropIndex = 78, RULE_dropLogfileGroup = 79, RULE_dropProcedure = 80,
RULE_dropFunction = 81, RULE_dropServer = 82, RULE_dropTable = 83, RULE_dropTablespace = 84,
RULE_dropTrigger = 85, RULE_dropView = 86, RULE_dropRole = 87, RULE_setRole = 88,
RULE_renameTable = 89, RULE_renameTableClause = 90, RULE_truncateTable = 91,
RULE_callStatement = 92, RULE_deleteStatement = 93, RULE_doStatement = 94,
RULE_handlerStatement = 95, RULE_insertStatement = 96, RULE_loadDataStatement = 97,
RULE_loadXmlStatement = 98, RULE_replaceStatement = 99, RULE_selectStatement = 100,
RULE_updateStatement = 101, RULE_valuesStatement = 102, RULE_insertStatementValue = 103,
RULE_updatedElement = 104, RULE_assignmentField = 105, RULE_lockClause = 106,
RULE_singleDeleteStatement = 107, RULE_multipleDeleteStatement = 108,
RULE_handlerOpenStatement = 109, RULE_handlerReadIndexStatement = 110,
RULE_handlerReadStatement = 111, RULE_handlerCloseStatement = 112, RULE_singleUpdateStatement = 113,
RULE_multipleUpdateStatement = 114, RULE_orderByClause = 115, RULE_orderByExpression = 116,
RULE_tableSources = 117, RULE_tableSource = 118, RULE_tableSourceItem = 119,
RULE_indexHint = 120, RULE_indexHintType = 121, RULE_joinPart = 122, RULE_joinSpec = 123,
RULE_queryExpression = 124, RULE_queryExpressionNointo = 125, RULE_querySpecification = 126,
RULE_querySpecificationNointo = 127, RULE_unionParenthesis = 128, RULE_unionStatement = 129,
RULE_lateralStatement = 130, RULE_jsonTable = 131, RULE_jsonColumnList = 132,
RULE_jsonColumn = 133, RULE_jsonOnEmpty = 134, RULE_jsonOnError = 135,
RULE_selectSpec = 136, RULE_selectElements = 137, RULE_selectElement = 138,
RULE_selectIntoExpression = 139, RULE_selectFieldsInto = 140, RULE_selectLinesInto = 141,
RULE_fromClause = 142, RULE_groupByClause = 143, RULE_havingClause = 144,
RULE_windowClause = 145, RULE_groupByItem = 146, RULE_limitClause = 147,
RULE_limitClauseAtom = 148, RULE_startTransaction = 149, RULE_beginWork = 150,
RULE_commitWork = 151, RULE_rollbackWork = 152, RULE_savepointStatement = 153,
RULE_rollbackStatement = 154, RULE_releaseStatement = 155, RULE_lockTables = 156,
RULE_unlockTables = 157, RULE_setAutocommitStatement = 158, RULE_setTransactionStatement = 159,
RULE_transactionMode = 160, RULE_lockTableElement = 161, RULE_lockAction = 162,
RULE_transactionOption = 163, RULE_transactionLevel = 164, RULE_changeMaster = 165,
RULE_changeReplicationFilter = 166, RULE_purgeBinaryLogs = 167, RULE_resetMaster = 168,
RULE_resetSlave = 169, RULE_startSlave = 170, RULE_stopSlave = 171, RULE_startGroupReplication = 172,
RULE_stopGroupReplication = 173, RULE_masterOption = 174, RULE_stringMasterOption = 175,
RULE_decimalMasterOption = 176, RULE_boolMasterOption = 177, RULE_channelOption = 178,
RULE_replicationFilter = 179, RULE_tablePair = 180, RULE_threadType = 181,
RULE_untilOption = 182, RULE_connectionOption = 183, RULE_gtuidSet = 184,
RULE_xaStartTransaction = 185, RULE_xaEndTransaction = 186, RULE_xaPrepareStatement = 187,
RULE_xaCommitWork = 188, RULE_xaRollbackWork = 189, RULE_xaRecoverWork = 190,
RULE_prepareStatement = 191, RULE_executeStatement = 192, RULE_deallocatePrepare = 193,
RULE_routineBody = 194, RULE_blockStatement = 195, RULE_caseStatement = 196,
RULE_ifStatement = 197, RULE_iterateStatement = 198, RULE_leaveStatement = 199,
RULE_loopStatement = 200, RULE_repeatStatement = 201, RULE_returnStatement = 202,
RULE_whileStatement = 203, RULE_cursorStatement = 204, RULE_declareVariable = 205,
RULE_declareCondition = 206, RULE_declareCursor = 207, RULE_declareHandler = 208,
RULE_handlerConditionValue = 209, RULE_procedureSqlStatement = 210, RULE_caseAlternative = 211,
RULE_elifAlternative = 212, RULE_alterUser = 213, RULE_createUser = 214,
RULE_dropUser = 215, RULE_grantStatement = 216, RULE_roleOption = 217,
RULE_grantProxy = 218, RULE_renameUser = 219, RULE_revokeStatement = 220,
RULE_revokeProxy = 221, RULE_setPasswordStatement = 222, RULE_userSpecification = 223,
RULE_userAuthOption = 224, RULE_authOptionClause = 225, RULE_authenticationRule = 226,
RULE_tlsOption = 227, RULE_userResourceOption = 228, RULE_userPasswordOption = 229,
RULE_userLockOption = 230, RULE_privelegeClause = 231, RULE_privilege = 232,
RULE_privilegeLevel = 233, RULE_renameUserClause = 234, RULE_analyzeTable = 235,
RULE_checkTable = 236, RULE_checksumTable = 237, RULE_optimizeTable = 238,
RULE_repairTable = 239, RULE_checkTableOption = 240, RULE_createUdfunction = 241,
RULE_installPlugin = 242, RULE_uninstallPlugin = 243, RULE_setStatement = 244,
RULE_showStatement = 245, RULE_variableClause = 246, RULE_showCommonEntity = 247,
RULE_showFilter = 248, RULE_showGlobalInfoClause = 249, RULE_showSchemaEntity = 250,
RULE_showProfileType = 251, RULE_binlogStatement = 252, RULE_cacheIndexStatement = 253,
RULE_flushStatement = 254, RULE_killStatement = 255, RULE_loadIndexIntoCache = 256,
RULE_resetStatement = 257, RULE_shutdownStatement = 258, RULE_tableIndexes = 259,
RULE_flushOption = 260, RULE_flushTableOption = 261, RULE_loadedTableIndexes = 262,
RULE_simpleDescribeStatement = 263, RULE_fullDescribeStatement = 264,
RULE_helpStatement = 265, RULE_useStatement = 266, RULE_signalStatement = 267,
RULE_resignalStatement = 268, RULE_signalConditionInformation = 269, RULE_withStatement = 270,
RULE_tableStatement = 271, RULE_diagnosticsStatement = 272, RULE_diagnosticsConditionInformationName = 273,
RULE_describeObjectClause = 274, RULE_fullId = 275, RULE_tableName = 276,
RULE_roleName = 277, RULE_fullColumnName = 278, RULE_indexColumnName = 279,
RULE_simpleUserName = 280, RULE_hostName = 281, RULE_userName = 282, RULE_mysqlVariable = 283,
RULE_charsetName = 284, RULE_collationName = 285, RULE_engineName = 286,
RULE_engineNameBase = 287, RULE_uuidSet = 288, RULE_xid = 289, RULE_xuidStringId = 290,
RULE_authPlugin = 291, RULE_uid = 292, RULE_simpleId = 293, RULE_dottedId = 294,
RULE_decimalLiteral = 295, RULE_fileSizeLiteral = 296, RULE_stringLiteral = 297,
RULE_booleanLiteral = 298, RULE_hexadecimalLiteral = 299, RULE_nullNotnull = 300,
RULE_constant = 301, RULE_dataType = 302, RULE_collectionOptions = 303,
RULE_convertedDataType = 304, RULE_lengthOneDimension = 305, RULE_lengthTwoDimension = 306,
RULE_lengthTwoOptionalDimension = 307, RULE_uidList = 308, RULE_fullColumnNameList = 309,
RULE_tables = 310, RULE_indexColumnNames = 311, RULE_expressions = 312,
RULE_expressionsWithDefaults = 313, RULE_constants = 314, RULE_simpleStrings = 315,
RULE_userVariables = 316, RULE_defaultValue = 317, RULE_currentTimestamp = 318,
RULE_expressionOrDefault = 319, RULE_ifExists = 320, RULE_ifNotExists = 321,
RULE_orReplace = 322, RULE_waitNowaitClause = 323, RULE_functionCall = 324,
RULE_specificFunction = 325, RULE_caseFuncAlternative = 326, RULE_levelsInWeightString = 327,
RULE_levelInWeightListElement = 328, RULE_aggregateWindowedFunction = 329,
RULE_nonAggregateWindowedFunction = 330, RULE_overClause = 331, RULE_windowSpec = 332,
RULE_windowName = 333, RULE_frameClause = 334, RULE_frameUnits = 335,
RULE_frameExtent = 336, RULE_frameBetween = 337, RULE_frameRange = 338,
RULE_partitionClause = 339, RULE_scalarFunctionName = 340, RULE_passwordFunctionClause = 341,
RULE_functionArgs = 342, RULE_functionArg = 343, RULE_expression = 344,
RULE_predicate = 345, RULE_expressionAtom = 346, RULE_unaryOperator = 347,
RULE_comparisonOperator = 348, RULE_logicalOperator = 349, RULE_bitOperator = 350,
RULE_multOperator = 351, RULE_addOperator = 352, RULE_jsonOperator = 353,
RULE_charsetNameBase = 354, RULE_transactionLevelBase = 355, RULE_privilegesBase = 356,
RULE_intervalTypeBase = 357, RULE_dataTypeBase = 358, RULE_keywordsCanBeId = 359,
RULE_functionNameBase = 360;
private static String[] makeRuleNames() {
return new String[] {
"root", "sqlStatements", "sqlStatement", "emptyStatement_", "ddlStatement",
"dmlStatement", "transactionStatement", "replicationStatement", "preparedStatement",
"compoundStatement", "administrationStatement", "utilityStatement", "createDatabase",
"createEvent", "createIndex", "createLogfileGroup", "createProcedure",
"createFunction", "createRole", "createServer", "createTable", "createTablespaceInnodb",
"createTablespaceNdb", "createTrigger", "withClause", "commonTableExpressions",
"cteName", "cteColumnName", "createView", "createDatabaseOption", "charSet",
"currentUserExpression", "ownerStatement", "scheduleExpression", "timestampValue",
"intervalExpr", "intervalType", "enableType", "indexType", "indexOption",
"procedureParameter", "functionParameter", "routineOption", "serverOption",
"createDefinitions", "createDefinition", "columnDefinition", "columnConstraint",
"tableConstraint", "referenceDefinition", "referenceAction", "referenceControlType",
"indexColumnDefinition", "tableOption", "tableType", "tablespaceStorage",
"partitionDefinitions", "partitionFunctionDefinition", "subpartitionFunctionDefinition",
"partitionDefinition", "partitionDefinerAtom", "partitionDefinerVector",
"subpartitionDefinition", "partitionOption", "alterDatabase", "alterEvent",
"alterFunction", "alterInstance", "alterLogfileGroup", "alterProcedure",
"alterServer", "alterTable", "alterTablespace", "alterView", "alterSpecification",
"alterPartitionSpecification", "dropDatabase", "dropEvent", "dropIndex",
"dropLogfileGroup", "dropProcedure", "dropFunction", "dropServer", "dropTable",
"dropTablespace", "dropTrigger", "dropView", "dropRole", "setRole", "renameTable",
"renameTableClause", "truncateTable", "callStatement", "deleteStatement",
"doStatement", "handlerStatement", "insertStatement", "loadDataStatement",
"loadXmlStatement", "replaceStatement", "selectStatement", "updateStatement",
"valuesStatement", "insertStatementValue", "updatedElement", "assignmentField",
"lockClause", "singleDeleteStatement", "multipleDeleteStatement", "handlerOpenStatement",
"handlerReadIndexStatement", "handlerReadStatement", "handlerCloseStatement",
"singleUpdateStatement", "multipleUpdateStatement", "orderByClause",
"orderByExpression", "tableSources", "tableSource", "tableSourceItem",
"indexHint", "indexHintType", "joinPart", "joinSpec", "queryExpression",
"queryExpressionNointo", "querySpecification", "querySpecificationNointo",
"unionParenthesis", "unionStatement", "lateralStatement", "jsonTable",
"jsonColumnList", "jsonColumn", "jsonOnEmpty", "jsonOnError", "selectSpec",
"selectElements", "selectElement", "selectIntoExpression", "selectFieldsInto",
"selectLinesInto", "fromClause", "groupByClause", "havingClause", "windowClause",
"groupByItem", "limitClause", "limitClauseAtom", "startTransaction",
"beginWork", "commitWork", "rollbackWork", "savepointStatement", "rollbackStatement",
"releaseStatement", "lockTables", "unlockTables", "setAutocommitStatement",
"setTransactionStatement", "transactionMode", "lockTableElement", "lockAction",
"transactionOption", "transactionLevel", "changeMaster", "changeReplicationFilter",
"purgeBinaryLogs", "resetMaster", "resetSlave", "startSlave", "stopSlave",
"startGroupReplication", "stopGroupReplication", "masterOption", "stringMasterOption",
"decimalMasterOption", "boolMasterOption", "channelOption", "replicationFilter",
"tablePair", "threadType", "untilOption", "connectionOption", "gtuidSet",
"xaStartTransaction", "xaEndTransaction", "xaPrepareStatement", "xaCommitWork",
"xaRollbackWork", "xaRecoverWork", "prepareStatement", "executeStatement",
"deallocatePrepare", "routineBody", "blockStatement", "caseStatement",
"ifStatement", "iterateStatement", "leaveStatement", "loopStatement",
"repeatStatement", "returnStatement", "whileStatement", "cursorStatement",
"declareVariable", "declareCondition", "declareCursor", "declareHandler",
"handlerConditionValue", "procedureSqlStatement", "caseAlternative",
"elifAlternative", "alterUser", "createUser", "dropUser", "grantStatement",
"roleOption", "grantProxy", "renameUser", "revokeStatement", "revokeProxy",
"setPasswordStatement", "userSpecification", "userAuthOption", "authOptionClause",
"authenticationRule", "tlsOption", "userResourceOption", "userPasswordOption",
"userLockOption", "privelegeClause", "privilege", "privilegeLevel", "renameUserClause",
"analyzeTable", "checkTable", "checksumTable", "optimizeTable", "repairTable",
"checkTableOption", "createUdfunction", "installPlugin", "uninstallPlugin",
"setStatement", "showStatement", "variableClause", "showCommonEntity",
"showFilter", "showGlobalInfoClause", "showSchemaEntity", "showProfileType",
"binlogStatement", "cacheIndexStatement", "flushStatement", "killStatement",
"loadIndexIntoCache", "resetStatement", "shutdownStatement", "tableIndexes",
"flushOption", "flushTableOption", "loadedTableIndexes", "simpleDescribeStatement",
"fullDescribeStatement", "helpStatement", "useStatement", "signalStatement",
"resignalStatement", "signalConditionInformation", "withStatement", "tableStatement",
"diagnosticsStatement", "diagnosticsConditionInformationName", "describeObjectClause",
"fullId", "tableName", "roleName", "fullColumnName", "indexColumnName",
"simpleUserName", "hostName", "userName", "mysqlVariable", "charsetName",
"collationName", "engineName", "engineNameBase", "uuidSet", "xid", "xuidStringId",
"authPlugin", "uid", "simpleId", "dottedId", "decimalLiteral", "fileSizeLiteral",
"stringLiteral", "booleanLiteral", "hexadecimalLiteral", "nullNotnull",
"constant", "dataType", "collectionOptions", "convertedDataType", "lengthOneDimension",
"lengthTwoDimension", "lengthTwoOptionalDimension", "uidList", "fullColumnNameList",
"tables", "indexColumnNames", "expressions", "expressionsWithDefaults",
"constants", "simpleStrings", "userVariables", "defaultValue", "currentTimestamp",
"expressionOrDefault", "ifExists", "ifNotExists", "orReplace", "waitNowaitClause",
"functionCall", "specificFunction", "caseFuncAlternative", "levelsInWeightString",
"levelInWeightListElement", "aggregateWindowedFunction", "nonAggregateWindowedFunction",
"overClause", "windowSpec", "windowName", "frameClause", "frameUnits",
"frameExtent", "frameBetween", "frameRange", "partitionClause", "scalarFunctionName",
"passwordFunctionClause", "functionArgs", "functionArg", "expression",
"predicate", "expressionAtom", "unaryOperator", "comparisonOperator",
"logicalOperator", "bitOperator", "multOperator", "addOperator", "jsonOperator",
"charsetNameBase", "transactionLevelBase", "privilegesBase", "intervalTypeBase",
"dataTypeBase", "keywordsCanBeId", "functionNameBase"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, "'ADD'", "'ALL'", "'ALTER'", "'ALWAYS'",
"'ANALYZE'", "'AND'", "'ARRAY'", "'AS'", "'ASC'", "'ATTRIBUTE'", "'BEFORE'",
"'BETWEEN'", "'BOTH'", "'BUCKETS'", "'BY'", "'CALL'", "'CASCADE'", "'CASE'",
"'CAST'", "'CHANGE'", "'CHARACTER'", "'CHECK'", "'COLLATE'", "'COLUMN'",
"'CONDITION'", "'CONSTRAINT'", "'CONTINUE'", "'CONVERT'", "'CREATE'",
"'CROSS'", "'CURRENT'", "'CURRENT_ROLE'", "'CURRENT_USER'", "'CURSOR'",
"'DATABASE'", "'DATABASES'", "'DECLARE'", "'DEFAULT'", "'DELAYED'", "'DELETE'",
"'DESC'", "'DESCRIBE'", "'DETERMINISTIC'", "'DIAGNOSTICS'", "'DISTINCT'",
"'DISTINCTROW'", "'DROP'", "'EACH'", "'ELSE'", "'ELSEIF'", "'EMPTY'",
"'ENCLOSED'", "'ENFORCED'", "'ESCAPED'", "'EXCEPT'", "'EXISTS'", "'EXIT'",
"'EXPLAIN'", "'FALSE'", "'FETCH'", "'FOR'", "'FORCE'", "'FOREIGN'", "'FROM'",
"'FULLTEXT'", "'GENERATED'", "'GET'", "'GRANT'", "'GROUP'", "'HAVING'",
"'HIGH_PRIORITY'", "'HISTOGRAM'", "'IF'", "'IGNORE'", "'IGNORED'", "'IN'",
"'INDEX'", "'INFILE'", "'INNER'", "'INOUT'", "'INSERT'", "'INTERVAL'",
"'INTO'", "'IS'", "'ITERATE'", "'JOIN'", "'KEY'", "'KEYS'", "'KILL'",
"'LATERAL'", "'LEADING'", "'LEAVE'", "'LEFT'", "'LIKE'", "'LIMIT'", "'LINEAR'",
"'LINES'", "'LOAD'", "'LOCK'", "'LOCKED'", "'LOOP'", "'LOW_PRIORITY'",
"'MASTER_BIND'", "'MASTER_SSL_VERIFY_SERVER_CERT'", "'MATCH'", "'MAXVALUE'",
"'MINVALUE'", "'MODIFIES'", "'NATURAL'", "'NOT'", "'NO_WRITE_TO_BINLOG'",
"'NULL'", "'NUMBER'", "'ON'", "'OPTIMIZE'", "'OPTION'", "'OPTIONAL'",
"'OPTIONALLY'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTFILE'", "'OVER'",
"'PARTITION'", "'PRIMARY'", "'PROCEDURE'", "'PURGE'", "'RANGE'", "'READ'",
"'READS'", "'REFERENCES'", "'REGEXP'", "'RELEASE'", "'RENAME'", "'REPEAT'",
"'REPLACE'", "'REQUIRE'", "'RESIGNAL'", "'RESTRICT'", "'RETAIN'", "'RETURN'",
"'REVOKE'", "'RIGHT'", "'RLIKE'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'",
"'SET'", "'SEPARATOR'", "'SHOW'", "'SIGNAL'", "'SKIP'", "'SKIP_QUERY_REWRITE'",
"'SPATIAL'", "'SQL'", "'SQLEXCEPTION'", "'SQLSTATE'", "'SQLWARNING'",
"'SQL_BIG_RESULT'", "'SQL_CALC_FOUND_ROWS'", "'SQL_SMALL_RESULT'", "'SSL'",
"'STACKED'", "'STARTING'", "'STATEMENT'", "'STRAIGHT_JOIN'", "'TABLE'",
"'TERMINATED'", "'THEN'", "'TO'", "'TRAILING'", "'TRIGGER'", "'TRUE'",
"'UNDO'", "'UNION'", "'UNIQUE'", "'UNLOCK'", "'UNSIGNED'", "'UPDATE'",
"'USAGE'", "'USE'", "'USING'", "'VALUES'", "'WHEN'", "'WHERE'", "'WHILE'",
"'WITH'", "'WRITE'", "'XOR'", "'ZEROFILL'", "'TINYINT'", "'SMALLINT'",
"'MEDIUMINT'", "'MIDDLEINT'", "'INT'", "'INT1'", "'INT2'", "'INT3'",
"'INT4'", "'INT8'", "'INTEGER'", "'BIGINT'", "'REAL'", "'DOUBLE'", "'PRECISION'",
"'FLOAT'", "'FLOAT4'", "'FLOAT8'", "'DECIMAL'", "'DEC'", "'NUMERIC'",
"'DATE'", "'TIME'", "'TIMESTAMP'", "'DATETIME'", "'YEAR'", "'CHAR'",
"'VARCHAR'", "'NVARCHAR'", "'NATIONAL'", "'BINARY'", "'VARBINARY'", "'TINYBLOB'",
"'BLOB'", "'MEDIUMBLOB'", "'LONG'", "'LONGBLOB'", "'TINYTEXT'", "'TEXT'",
"'MEDIUMTEXT'", "'LONGTEXT'", "'ENUM'", "'VARYING'", "'SERIAL'", "'YEAR_MONTH'",
"'DAY_HOUR'", "'DAY_MINUTE'", "'DAY_SECOND'", "'HOUR_MINUTE'", "'HOUR_SECOND'",
"'MINUTE_SECOND'", "'SECOND_MICROSECOND'", "'MINUTE_MICROSECOND'", "'HOUR_MICROSECOND'",
"'DAY_MICROSECOND'", "'JSON_ARRAY'", "'JSON_ARRAYAGG'", "'JSON_ARRAY_APPEND'",
"'JSON_ARRAY_INSERT'", "'JSON_CONTAINS'", "'JSON_CONTAINS_PATH'", "'JSON_DEPTH'",
"'JSON_EXTRACT'", "'JSON_INSERT'", "'JSON_KEYS'", "'JSON_LENGTH'", "'JSON_MERGE'",
"'JSON_MERGE_PATCH'", "'JSON_MERGE_PRESERVE'", "'JSON_OBJECT'", "'JSON_OBJECTAGG'",
"'JSON_OVERLAPS'", "'JSON_PRETTY'", "'JSON_QUOTE'", "'JSON_REMOVE'",
"'JSON_REPLACE'", "'JSON_SCHEMA_VALID'", "'JSON_SCHEMA_VALIDATION_REPORT'",
"'JSON_SEARCH'", "'JSON_SET'", "'JSON_STORAGE_FREE'", "'JSON_STORAGE_SIZE'",
"'JSON_TABLE'", "'JSON_TYPE'", "'JSON_UNQUOTE'", "'JSON_VALID'", "'JSON_VALUE'",
"'NESTED'", "'ORDINALITY'", "'PATH'", "'AVG'", "'BIT_AND'", "'BIT_OR'",
"'BIT_XOR'", "'COUNT'", "'CUME_DIST'", "'DENSE_RANK'", "'FIRST_VALUE'",
"'GROUP_CONCAT'", "'LAG'", "'LAST_VALUE'", "'LEAD'", "'MAX'", "'MIN'",
"'NTILE'", "'NTH_VALUE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'",
"'STD'", "'STDDEV'", "'STDDEV_POP'", "'STDDEV_SAMP'", "'SUM'", "'VAR_POP'",
"'VAR_SAMP'", "'VARIANCE'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'",
"'LOCALTIME'", "'CURDATE'", "'CURTIME'", "'DATE_ADD'", "'DATE_SUB'",
"'EXTRACT'", "'LOCALTIMESTAMP'", "'NOW'", "'POSITION'", "'SUBSTR'", "'SUBSTRING'",
"'SYSDATE'", "'TRIM'", "'UTC_DATE'", "'UTC_TIME'", "'UTC_TIMESTAMP'",
"'ACCOUNT'", "'ACTION'", "'AFTER'", "'AGGREGATE'", "'ALGORITHM'", "'ANY'",
"'AT'", "'AUTHORS'", "'AUTOCOMMIT'", "'AUTOEXTEND_SIZE'", "'AUTO_INCREMENT'",
"'AVG_ROW_LENGTH'", "'BEGIN'", "'BINLOG'", "'BIT'", "'BLOCK'", "'BOOL'",
"'BOOLEAN'", "'BTREE'", "'CACHE'", "'CASCADED'", "'CHAIN'", "'CHANGED'",
"'CHANNEL'", "'CHECKSUM'", "'PAGE_CHECKSUM'", "'CIPHER'", "'CLASS_ORIGIN'",
"'CLIENT'", "'CLOSE'", "'CLUSTERING'", "'COALESCE'", "'CODE'", "'COLUMNS'",
"'COLUMN_FORMAT'", "'COLUMN_NAME'", "'COMMENT'", "'COMMIT'", "'COMPACT'",
"'COMPLETION'", "'COMPRESSED'", "'COMPRESSION'", "'CONCURRENT'", "'CONNECT'",
"'CONNECTION'", "'CONSISTENT'", "'CONSTRAINT_CATALOG'", "'CONSTRAINT_SCHEMA'",
"'CONSTRAINT_NAME'", "'CONTAINS'", "'CONTEXT'", "'CONTRIBUTORS'", "'COPY'",
"'CPU'", "'CYCLE'", "'CURSOR_NAME'", "'DATA'", "'DATAFILE'", "'DEALLOCATE'",
"'DEFAULT_AUTH'", "'DEFINER'", "'DELAY_KEY_WRITE'", "'DES_KEY_FILE'",
"'DIRECTORY'", "'DISABLE'", "'DISCARD'", "'DISK'", "'DO'", "'DUMPFILE'",
"'DUPLICATE'", "'DYNAMIC'", "'ENABLE'", "'ENCRYPTED'", "'ENCRYPTION'",
"'ENCRYPTION_KEY_ID'", "'END'", "'ENDS'", "'ENGINE'", "'ENGINES'", "'ERROR'",
"'ERRORS'", "'ESCAPE'", "'EVEN'", "'EVENT'", "'EVENTS'", "'EVERY'", "'EXCHANGE'",
"'EXCLUSIVE'", "'EXPIRE'", "'EXPORT'", "'EXTENDED'", "'EXTENT_SIZE'",
"'FAILED_LOGIN_ATTEMPTS'", "'FAST'", "'FAULTS'", "'FIELDS'", "'FILE_BLOCK_SIZE'",
"'FILTER'", "'FIRST'", "'FIXED'", "'FLUSH'", "'FOLLOWING'", "'FOLLOWS'",
"'FOUND'", "'FULL'", "'FUNCTION'", "'GENERAL'", "'GLOBAL'", "'GRANTS'",
"'GROUP_REPLICATION'", "'HANDLER'", "'HASH'", "'HELP'", "'HISTORY'",
"'HOST'", "'HOSTS'", "'IDENTIFIED'", "'IGNORE_SERVER_IDS'", "'IMPORT'",
"'INCREMENT'", "'INDEXES'", "'INITIAL_SIZE'", "'INPLACE'", "'INSERT_METHOD'",
"'INSTALL'", "'INSTANCE'", "'INSTANT'", "'INVISIBLE'", "'INVOKER'", "'IO'",
"'IO_THREAD'", "'IPC'", "'ISOLATION'", "'ISSUER'", "'JSON'", "'KEY_BLOCK_SIZE'",
"'LANGUAGE'", "'LAST'", "'LEAVES'", "'LESS'", "'LEVEL'", "'LIST'", "'LOCAL'",
"'LOGFILE'", "'LOGS'", "'MASTER'", "'MASTER_AUTO_POSITION'", "'MASTER_CONNECT_RETRY'",
"'MASTER_DELAY'", "'MASTER_HEARTBEAT_PERIOD'", "'MASTER_HOST'", "'MASTER_LOG_FILE'",
"'MASTER_LOG_POS'", "'MASTER_PASSWORD'", "'MASTER_PORT'", "'MASTER_RETRY_COUNT'",
"'MASTER_SSL'", "'MASTER_SSL_CA'", "'MASTER_SSL_CAPATH'", "'MASTER_SSL_CERT'",
"'MASTER_SSL_CIPHER'", "'MASTER_SSL_CRL'", "'MASTER_SSL_CRLPATH'", "'MASTER_SSL_KEY'",
"'MASTER_TLS_VERSION'", "'MASTER_USER'", "'MAX_CONNECTIONS_PER_HOUR'",
"'MAX_QUERIES_PER_HOUR'", "'MAX_ROWS'", "'MAX_SIZE'", "'MAX_UPDATES_PER_HOUR'",
"'MAX_USER_CONNECTIONS'", "'MEDIUM'", "'MEMBER'", "'MERGE'", "'MESSAGE_TEXT'",
"'MID'", "'MIGRATE'", "'MIN_ROWS'", "'MODE'", "'MODIFY'", "'MUTEX'",
"'MYSQL'", "'MYSQL_ERRNO'", "'NAME'", "'NAMES'", "'NCHAR'", "'NEVER'",
"'NEXT'", "'NO'", "'NOCACHE'", "'NOCOPY'", "'NOCYCLE'", "'NOMAXVALUE'",
"'NOMINVALUE'", "'NOWAIT'", "'NODEGROUP'", "'NONE'", "'ODBC'", "'OFFLINE'",
"'OFFSET'", "'OF'", "'OJ'", "'OLD_PASSWORD'", "'ONE'", "'ONLINE'", "'ONLY'",
"'OPEN'", "'OPTIMIZER_COSTS'", "'OPTIONS'", "'OWNER'", "'PACK_KEYS'",
"'PAGE'", "'PAGE_COMPRESSED'", "'PAGE_COMPRESSION_LEVEL'", "'PARSER'",
"'PARTIAL'", "'PARTITIONING'", "'PARTITIONS'", "'PASSWORD'", "'PASSWORD_LOCK_TIME'",
"'PHASE'", "'PLUGIN'", "'PLUGIN_DIR'", "'PLUGINS'", "'PORT'", "'PRECEDES'",
"'PRECEDING'", "'PREPARE'", "'PRESERVE'", "'PREV'", "'PROCESSLIST'",
"'PROFILE'", "'PROFILES'", "'PROXY'", "'QUERY'", "'QUICK'", "'REBUILD'",
"'RECOVER'", "'RECURSIVE'", "'REDO_BUFFER_SIZE'", "'REDUNDANT'", "'RELAY'",
"'RELAY_LOG_FILE'", "'RELAY_LOG_POS'", "'RELAYLOG'", "'REMOVE'", "'REORGANIZE'",
"'REPAIR'", "'REPLICATE_DO_DB'", "'REPLICATE_DO_TABLE'", "'REPLICATE_IGNORE_DB'",
"'REPLICATE_IGNORE_TABLE'", "'REPLICATE_REWRITE_DB'", "'REPLICATE_WILD_DO_TABLE'",
"'REPLICATE_WILD_IGNORE_TABLE'", "'REPLICATION'", "'RESET'", "'RESTART'",
"'RESUME'", "'RETURNED_SQLSTATE'", "'RETURNING'", "'RETURNS'", "'REUSE'",
"'ROLE'", "'ROLLBACK'", "'ROLLUP'", "'ROTATE'", "'ROW'", "'ROWS'", "'ROW_FORMAT'",
"'RTREE'", "'SAVEPOINT'", "'SCHEDULE'", "'SECURITY'", "'SEQUENCE'", "'SERVER'",
"'SESSION'", "'SHARE'", "'SHARED'", "'SIGNED'", "'SIMPLE'", "'SLAVE'",
"'SLOW'", "'SNAPSHOT'", "'SOCKET'", "'SOME'", "'SONAME'", "'SOUNDS'",
"'SOURCE'", "'SQL_AFTER_GTIDS'", "'SQL_AFTER_MTS_GAPS'", "'SQL_BEFORE_GTIDS'",
"'SQL_BUFFER_RESULT'", "'SQL_CACHE'", "'SQL_NO_CACHE'", "'SQL_THREAD'",
"'START'", "'STARTS'", "'STATS_AUTO_RECALC'", "'STATS_PERSISTENT'", "'STATS_SAMPLE_PAGES'",
"'STATUS'", "'STOP'", "'STORAGE'", "'STORED'", "'STRING'", "'SUBCLASS_ORIGIN'",
"'SUBJECT'", "'SUBPARTITION'", "'SUBPARTITIONS'", "'SUSPEND'", "'SWAPS'",
"'SWITCHES'", "'TABLE_NAME'", "'TABLESPACE'", "'TABLE_TYPE'", "'TEMPORARY'",
"'TEMPTABLE'", "'THAN'", "'TRADITIONAL'", "'TRANSACTION'", "'TRANSACTIONAL'",
"'TRIGGERS'", "'TRUNCATE'", "'UNBOUNDED'", "'UNDEFINED'", "'UNDOFILE'",
"'UNDO_BUFFER_SIZE'", "'UNINSTALL'", "'UNKNOWN'", "'UNTIL'", "'UPGRADE'",
"'USER'", "'USE_FRM'", "'USER_RESOURCES'", "'VALIDATION'", "'VALUE'",
"'VARIABLES'", "'VIEW'", "'VIRTUAL'", "'VISIBLE'", "'WAIT'", "'WARNINGS'",
"'WINDOW'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'X509'", "'XA'", "'XML'",
"'YES'", "'EUR'", "'USA'", "'JIS'", "'ISO'", "'INTERNAL'", "'QUARTER'",
"'MONTH'", "'DAY'", "'HOUR'", "'MINUTE'", "'WEEK'", "'SECOND'", "'MICROSECOND'",
"'ADMIN'", "'APPLICATION_PASSWORD_ADMIN'", "'AUDIT_ABORT_EXEMPT'", "'AUDIT_ADMIN'",
"'AUTHENTICATION_POLICY_ADMIN'", "'BACKUP_ADMIN'", "'BINLOG_ADMIN'",
"'BINLOG_ENCRYPTION_ADMIN'", "'CLONE_ADMIN'", "'CONNECTION_ADMIN'", "'ENCRYPTION_KEY_ADMIN'",
"'EXECUTE'", "'FILE'", "'FIREWALL_ADMIN'", "'FIREWALL_EXEMPT'", "'FIREWALL_USER'",
"'FLUSH_OPTIMIZER_COSTS'", "'FLUSH_STATUS'", "'FLUSH_TABLES'", "'FLUSH_USER_RESOURCES'",
"'GROUP_REPLICATION_ADMIN'", "'INNODB_REDO_LOG_ARCHIVE'", "'INNODB_REDO_LOG_ENABLE'",
"'INVOKE'", "'LAMBDA'", "'NDB_STORED_USER'", "'PASSWORDLESS_USER_ADMIN'",
"'PERSIST_RO_VARIABLES_ADMIN'", "'PRIVILEGES'", "'PROCESS'", "'RELOAD'",
"'REPLICATION_APPLIER'", "'REPLICATION_SLAVE_ADMIN'", "'RESOURCE_GROUP_ADMIN'",
"'RESOURCE_GROUP_USER'", "'ROLE_ADMIN'", "'ROUTINE'", "'S3'", "'SERVICE_CONNECTION_ADMIN'",
null, "'SET_USER_ID'", "'SHOW_ROUTINE'", "'SHUTDOWN'", "'SUPER'", "'SYSTEM_VARIABLES_ADMIN'",
"'TABLES'", "'TABLE_ENCRYPTION_ADMIN'", "'VERSION_TOKEN_ADMIN'", "'XA_RECOVER_ADMIN'",
"'ARMSCII8'", "'ASCII'", "'BIG5'", "'CP1250'", "'CP1251'", "'CP1256'",
"'CP1257'", "'CP850'", "'CP852'", "'CP866'", "'CP932'", "'DEC8'", "'EUCJPMS'",
"'EUCKR'", "'GB18030'", "'GB2312'", "'GBK'", "'GEOSTD8'", "'GREEK'",
"'HEBREW'", "'HP8'", "'KEYBCS2'", "'KOI8R'", "'KOI8U'", "'LATIN1'", "'LATIN2'",
"'LATIN5'", "'LATIN7'", "'MACCE'", "'MACROMAN'", "'SJIS'", "'SWE7'",
"'TIS620'", "'UCS2'", "'UJIS'", "'UTF16'", "'UTF16LE'", "'UTF32'", "'UTF8'",
"'UTF8MB3'", "'UTF8MB4'", "'ARCHIVE'", "'BLACKHOLE'", "'CSV'", "'FEDERATED'",
"'INNODB'", "'MEMORY'", "'MRG_MYISAM'", "'MYISAM'", "'NDB'", "'NDBCLUSTER'",
"'PERFORMANCE_SCHEMA'", "'TOKUDB'", "'REPEATABLE'", "'COMMITTED'", "'UNCOMMITTED'",
"'SERIALIZABLE'", "'GEOMETRYCOLLECTION'", "'GEOMCOLLECTION'", "'GEOMETRY'",
"'LINESTRING'", "'MULTILINESTRING'", "'MULTIPOINT'", "'MULTIPOLYGON'",
"'POINT'", "'POLYGON'", "'ABS'", "'ACOS'", "'ADDDATE'", "'ADDTIME'",
"'AES_DECRYPT'", "'AES_ENCRYPT'", "'AREA'", "'ASBINARY'", "'ASIN'", "'ASTEXT'",
"'ASWKB'", "'ASWKT'", "'ASYMMETRIC_DECRYPT'", "'ASYMMETRIC_DERIVE'",
"'ASYMMETRIC_ENCRYPT'", "'ASYMMETRIC_SIGN'", "'ASYMMETRIC_VERIFY'", "'ATAN'",
"'ATAN2'", "'BENCHMARK'", "'BIN'", "'BIT_COUNT'", "'BIT_LENGTH'", "'BUFFER'",
"'CATALOG_NAME'", "'CEIL'", "'CEILING'", "'CENTROID'", "'CHARACTER_LENGTH'",
"'CHARSET'", "'CHAR_LENGTH'", "'COERCIBILITY'", "'COLLATION'", "'COMPRESS'",
"'CONCAT'", "'CONCAT_WS'", "'CONNECTION_ID'", "'CONV'", "'CONVERT_TZ'",
"'COS'", "'COT'", "'CRC32'", "'CREATE_ASYMMETRIC_PRIV_KEY'", "'CREATE_ASYMMETRIC_PUB_KEY'",
"'CREATE_DH_PARAMETERS'", "'CREATE_DIGEST'", "'CROSSES'", "'DATEDIFF'",
"'DATE_FORMAT'", "'DAYNAME'", "'DAYOFMONTH'", "'DAYOFWEEK'", "'DAYOFYEAR'",
"'DECODE'", "'DEGREES'", "'DES_DECRYPT'", "'DES_ENCRYPT'", "'DIMENSION'",
"'DISJOINT'", "'ELT'", "'ENCODE'", "'ENCRYPT'", "'ENDPOINT'", "'ENGINE_ATTRIBUTE'",
"'ENVELOPE'", "'EQUALS'", "'EXP'", "'EXPORT_SET'", "'EXTERIORRING'",
"'EXTRACTVALUE'", "'FIELD'", "'FIND_IN_SET'", "'FLOOR'", "'FORMAT'",
"'FOUND_ROWS'", "'FROM_BASE64'", "'FROM_DAYS'", "'FROM_UNIXTIME'", "'GEOMCOLLFROMTEXT'",
"'GEOMCOLLFROMWKB'", "'GEOMETRYCOLLECTIONFROMTEXT'", "'GEOMETRYCOLLECTIONFROMWKB'",
"'GEOMETRYFROMTEXT'", "'GEOMETRYFROMWKB'", "'GEOMETRYN'", "'GEOMETRYTYPE'",
"'GEOMFROMTEXT'", "'GEOMFROMWKB'", "'GET_FORMAT'", "'GET_LOCK'", "'GLENGTH'",
"'GREATEST'", "'GTID_SUBSET'", "'GTID_SUBTRACT'", "'HEX'", "'IFNULL'",
"'INET6_ATON'", "'INET6_NTOA'", "'INET_ATON'", "'INET_NTOA'", "'INSTR'",
"'INTERIORRINGN'", "'INTERSECTS'", "'ISCLOSED'", "'ISEMPTY'", "'ISNULL'",
"'ISSIMPLE'", "'IS_FREE_LOCK'", "'IS_IPV4'", "'IS_IPV4_COMPAT'", "'IS_IPV4_MAPPED'",
"'IS_IPV6'", "'IS_USED_LOCK'", "'LAST_INSERT_ID'", "'LCASE'", "'LEAST'",
"'LENGTH'", "'LINEFROMTEXT'", "'LINEFROMWKB'", "'LINESTRINGFROMTEXT'",
"'LINESTRINGFROMWKB'", "'LN'", "'LOAD_FILE'", "'LOCATE'", "'LOG'", "'LOG10'",
"'LOG2'", "'LOWER'", "'LPAD'", "'LTRIM'", "'MAKEDATE'", "'MAKETIME'",
"'MAKE_SET'", "'MASTER_POS_WAIT'", "'MBRCONTAINS'", "'MBRDISJOINT'",
"'MBREQUAL'", "'MBRINTERSECTS'", "'MBROVERLAPS'", "'MBRTOUCHES'", "'MBRWITHIN'",
"'MD5'", "'MLINEFROMTEXT'", "'MLINEFROMWKB'", "'MONTHNAME'", "'MPOINTFROMTEXT'",
"'MPOINTFROMWKB'", "'MPOLYFROMTEXT'", "'MPOLYFROMWKB'", "'MULTILINESTRINGFROMTEXT'",
"'MULTILINESTRINGFROMWKB'", "'MULTIPOINTFROMTEXT'", "'MULTIPOINTFROMWKB'",
"'MULTIPOLYGONFROMTEXT'", "'MULTIPOLYGONFROMWKB'", "'NAME_CONST'", "'NULLIF'",
"'NUMGEOMETRIES'", "'NUMINTERIORRINGS'", "'NUMPOINTS'", "'OCT'", "'OCTET_LENGTH'",
"'ORD'", "'OVERLAPS'", "'PERIOD_ADD'", "'PERIOD_DIFF'", "'PI'", "'POINTFROMTEXT'",
"'POINTFROMWKB'", "'POINTN'", "'POLYFROMTEXT'", "'POLYFROMWKB'", "'POLYGONFROMTEXT'",
"'POLYGONFROMWKB'", "'POW'", "'POWER'", "'QUOTE'", "'RADIANS'", "'RAND'",
"'RANDOM'", "'RANDOM_BYTES'", "'RELEASE_LOCK'", "'REVERSE'", "'ROUND'",
"'ROW_COUNT'", "'RPAD'", "'RTRIM'", "'SEC_TO_TIME'", "'SECONDARY_ENGINE_ATTRIBUTE'",
"'SESSION_USER'", "'SHA'", "'SHA1'", "'SHA2'", "'SCHEMA_NAME'", "'SIGN'",
"'SIN'", "'SLEEP'", "'SOUNDEX'", "'SQL_THREAD_WAIT_AFTER_GTIDS'", "'SQRT'",
"'SRID'", "'STARTPOINT'", "'STRCMP'", "'STR_TO_DATE'", "'ST_AREA'", "'ST_ASBINARY'",
"'ST_ASTEXT'", "'ST_ASWKB'", "'ST_ASWKT'", "'ST_BUFFER'", "'ST_CENTROID'",
"'ST_CONTAINS'", "'ST_CROSSES'", "'ST_DIFFERENCE'", "'ST_DIMENSION'",
"'ST_DISJOINT'", "'ST_DISTANCE'", "'ST_ENDPOINT'", "'ST_ENVELOPE'", "'ST_EQUALS'",
"'ST_EXTERIORRING'", "'ST_GEOMCOLLFROMTEXT'", "'ST_GEOMCOLLFROMTXT'",
"'ST_GEOMCOLLFROMWKB'", "'ST_GEOMETRYCOLLECTIONFROMTEXT'", "'ST_GEOMETRYCOLLECTIONFROMWKB'",
"'ST_GEOMETRYFROMTEXT'", "'ST_GEOMETRYFROMWKB'", "'ST_GEOMETRYN'", "'ST_GEOMETRYTYPE'",
"'ST_GEOMFROMTEXT'", "'ST_GEOMFROMWKB'", "'ST_INTERIORRINGN'", "'ST_INTERSECTION'",
"'ST_INTERSECTS'", "'ST_ISCLOSED'", "'ST_ISEMPTY'", "'ST_ISSIMPLE'",
"'ST_LINEFROMTEXT'", "'ST_LINEFROMWKB'", "'ST_LINESTRINGFROMTEXT'", "'ST_LINESTRINGFROMWKB'",
"'ST_NUMGEOMETRIES'", "'ST_NUMINTERIORRING'", "'ST_NUMINTERIORRINGS'",
"'ST_NUMPOINTS'", "'ST_OVERLAPS'", "'ST_POINTFROMTEXT'", "'ST_POINTFROMWKB'",
"'ST_POINTN'", "'ST_POLYFROMTEXT'", "'ST_POLYFROMWKB'", "'ST_POLYGONFROMTEXT'",
"'ST_POLYGONFROMWKB'", "'ST_SRID'", "'ST_STARTPOINT'", "'ST_SYMDIFFERENCE'",
"'ST_TOUCHES'", "'ST_UNION'", "'ST_WITHIN'", "'ST_X'", "'ST_Y'", "'SUBDATE'",
"'SUBSTRING_INDEX'", "'SUBTIME'", "'SYSTEM_USER'", "'TAN'", "'TIMEDIFF'",
"'TIMESTAMPADD'", "'TIMESTAMPDIFF'", "'TIME_FORMAT'", "'TIME_TO_SEC'",
"'TOUCHES'", "'TO_BASE64'", "'TO_DAYS'", "'TO_SECONDS'", "'TP_CONNECTION_ADMIN'",
"'UCASE'", "'UNCOMPRESS'", "'UNCOMPRESSED_LENGTH'", "'UNHEX'", "'UNIX_TIMESTAMP'",
"'UPDATEXML'", "'UPPER'", "'UUID'", "'UUID_SHORT'", "'VALIDATE_PASSWORD_STRENGTH'",
"'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", "'WEEKDAY'", "'WEEKOFYEAR'",
"'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", "'Y'", "'X'", "':='", "'+='",
"'-='", "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'*'", "'/'",
"'%'", "'+'", "'-'", "'DIV'", "'MOD'", "'='", "'>'", "'<'", "'!'", "'~'",
"'|'", "'&'", "'^'", "'.'", "'('", "')'", "','", "';'", "'@'", "'0'",
"'1'", "'2'", "'''", "'\"'", "'`'", "':'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "SPACE", "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT",
"ADD", "ALL", "ALTER", "ALWAYS", "ANALYZE", "AND", "ARRAY", "AS", "ASC",
"ATTRIBUTE", "BEFORE", "BETWEEN", "BOTH", "BUCKETS", "BY", "CALL", "CASCADE",
"CASE", "CAST", "CHANGE", "CHARACTER", "CHECK", "COLLATE", "COLUMN",
"CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS",
"CURRENT", "CURRENT_ROLE", "CURRENT_USER", "CURSOR", "DATABASE", "DATABASES",
"DECLARE", "DEFAULT", "DELAYED", "DELETE", "DESC", "DESCRIBE", "DETERMINISTIC",
"DIAGNOSTICS", "DISTINCT", "DISTINCTROW", "DROP", "EACH", "ELSE", "ELSEIF",
"EMPTY", "ENCLOSED", "ENFORCED", "ESCAPED", "EXCEPT", "EXISTS", "EXIT",
"EXPLAIN", "FALSE", "FETCH", "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT",
"GENERATED", "GET", "GRANT", "GROUP", "HAVING", "HIGH_PRIORITY", "HISTOGRAM",
"IF", "IGNORE", "IGNORED", "IN", "INDEX", "INFILE", "INNER", "INOUT",
"INSERT", "INTERVAL", "INTO", "IS", "ITERATE", "JOIN", "KEY", "KEYS",
"KILL", "LATERAL", "LEADING", "LEAVE", "LEFT", "LIKE", "LIMIT", "LINEAR",
"LINES", "LOAD", "LOCK", "LOCKED", "LOOP", "LOW_PRIORITY", "MASTER_BIND",
"MASTER_SSL_VERIFY_SERVER_CERT", "MATCH", "MAXVALUE", "MINVALUE", "MODIFIES",
"NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL_LITERAL", "NUMBER", "ON",
"OPTIMIZE", "OPTION", "OPTIONAL", "OPTIONALLY", "OR", "ORDER", "OUT",
"OUTER", "OUTFILE", "OVER", "PARTITION", "PRIMARY", "PROCEDURE", "PURGE",
"RANGE", "READ", "READS", "REFERENCES", "REGEXP", "RELEASE", "RENAME",
"REPEAT", "REPLACE", "REQUIRE", "RESIGNAL", "RESTRICT", "RETAIN", "RETURN",
"REVOKE", "RIGHT", "RLIKE", "SCHEMA", "SCHEMAS", "SELECT", "SET", "SEPARATOR",
"SHOW", "SIGNAL", "SKIP_", "SKIP_QUERY_REWRITE", "SPATIAL", "SQL", "SQLEXCEPTION",
"SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT",
"SSL", "STACKED", "STARTING", "STATEMENT", "STRAIGHT_JOIN", "TABLE",
"TERMINATED", "THEN", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION",
"UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "VALUES",
"WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "ZEROFILL", "TINYINT",
"SMALLINT", "MEDIUMINT", "MIDDLEINT", "INT", "INT1", "INT2", "INT3",
"INT4", "INT8", "INTEGER", "BIGINT", "REAL", "DOUBLE", "PRECISION", "FLOAT",
"FLOAT4", "FLOAT8", "DECIMAL", "DEC", "NUMERIC", "DATE", "TIME", "TIMESTAMP",
"DATETIME", "YEAR", "CHAR", "VARCHAR", "NVARCHAR", "NATIONAL", "BINARY",
"VARBINARY", "TINYBLOB", "BLOB", "MEDIUMBLOB", "LONG", "LONGBLOB", "TINYTEXT",
"TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "VARYING", "SERIAL", "YEAR_MONTH",
"DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "HOUR_MINUTE", "HOUR_SECOND",
"MINUTE_SECOND", "SECOND_MICROSECOND", "MINUTE_MICROSECOND", "HOUR_MICROSECOND",
"DAY_MICROSECOND", "JSON_ARRAY", "JSON_ARRAYAGG", "JSON_ARRAY_APPEND",
"JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH", "JSON_DEPTH",
"JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH", "JSON_MERGE",
"JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT", "JSON_OBJECTAGG",
"JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE", "JSON_REMOVE", "JSON_REPLACE",
"JSON_SCHEMA_VALID", "JSON_SCHEMA_VALIDATION_REPORT", "JSON_SEARCH",
"JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE", "JSON_TABLE", "JSON_TYPE",
"JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE", "NESTED", "ORDINALITY", "PATH",
"AVG", "BIT_AND", "BIT_OR", "BIT_XOR", "COUNT", "CUME_DIST", "DENSE_RANK",
"FIRST_VALUE", "GROUP_CONCAT", "LAG", "LAST_VALUE", "LEAD", "MAX", "MIN",
"NTILE", "NTH_VALUE", "PERCENT_RANK", "RANK", "ROW_NUMBER", "STD", "STDDEV",
"STDDEV_POP", "STDDEV_SAMP", "SUM", "VAR_POP", "VAR_SAMP", "VARIANCE",
"CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "LOCALTIME", "CURDATE",
"CURTIME", "DATE_ADD", "DATE_SUB", "EXTRACT", "LOCALTIMESTAMP", "NOW",
"POSITION", "SUBSTR", "SUBSTRING", "SYSDATE", "TRIM", "UTC_DATE", "UTC_TIME",
"UTC_TIMESTAMP", "ACCOUNT", "ACTION", "AFTER", "AGGREGATE", "ALGORITHM",
"ANY", "AT", "AUTHORS", "AUTOCOMMIT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT",
"AVG_ROW_LENGTH", "BEGIN", "BINLOG", "BIT", "BLOCK", "BOOL", "BOOLEAN",
"BTREE", "CACHE", "CASCADED", "CHAIN", "CHANGED", "CHANNEL", "CHECKSUM",
"PAGE_CHECKSUM", "CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "CLUSTERING",
"COALESCE", "CODE", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME", "COMMENT",
"COMMIT", "COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT",
"CONNECT", "CONNECTION", "CONSISTENT", "CONSTRAINT_CATALOG", "CONSTRAINT_SCHEMA",
"CONSTRAINT_NAME", "CONTAINS", "CONTEXT", "CONTRIBUTORS", "COPY", "CPU",
"CYCLE", "CURSOR_NAME", "DATA", "DATAFILE", "DEALLOCATE", "DEFAULT_AUTH",
"DEFINER", "DELAY_KEY_WRITE", "DES_KEY_FILE", "DIRECTORY", "DISABLE",
"DISCARD", "DISK", "DO", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ENABLE",
"ENCRYPTED", "ENCRYPTION", "ENCRYPTION_KEY_ID", "END", "ENDS", "ENGINE",
"ENGINES", "ERROR", "ERRORS", "ESCAPE", "EVEN", "EVENT", "EVENTS", "EVERY",
"EXCHANGE", "EXCLUSIVE", "EXPIRE", "EXPORT", "EXTENDED", "EXTENT_SIZE",
"FAILED_LOGIN_ATTEMPTS", "FAST", "FAULTS", "FIELDS", "FILE_BLOCK_SIZE",
"FILTER", "FIRST", "FIXED", "FLUSH", "FOLLOWING", "FOLLOWS", "FOUND",
"FULL", "FUNCTION", "GENERAL", "GLOBAL", "GRANTS", "GROUP_REPLICATION",
"HANDLER", "HASH", "HELP", "HISTORY", "HOST", "HOSTS", "IDENTIFIED",
"IGNORE_SERVER_IDS", "IMPORT", "INCREMENT", "INDEXES", "INITIAL_SIZE",
"INPLACE", "INSERT_METHOD", "INSTALL", "INSTANCE", "INSTANT", "INVISIBLE",
"INVOKER", "IO", "IO_THREAD", "IPC", "ISOLATION", "ISSUER", "JSON", "KEY_BLOCK_SIZE",
"LANGUAGE", "LAST", "LEAVES", "LESS", "LEVEL", "LIST", "LOCAL", "LOGFILE",
"LOGS", "MASTER", "MASTER_AUTO_POSITION", "MASTER_CONNECT_RETRY", "MASTER_DELAY",
"MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE", "MASTER_LOG_POS",
"MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT", "MASTER_SSL",
"MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_CIPHER",
"MASTER_SSL_CRL", "MASTER_SSL_CRLPATH", "MASTER_SSL_KEY", "MASTER_TLS_VERSION",
"MASTER_USER", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR", "MAX_ROWS",
"MAX_SIZE", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MEDIUM",
"MEMBER", "MERGE", "MESSAGE_TEXT", "MID", "MIGRATE", "MIN_ROWS", "MODE",
"MODIFY", "MUTEX", "MYSQL", "MYSQL_ERRNO", "NAME", "NAMES", "NCHAR",
"NEVER", "NEXT", "NO", "NOCACHE", "NOCOPY", "NOCYCLE", "NOMAXVALUE",
"NOMINVALUE", "NOWAIT", "NODEGROUP", "NONE", "ODBC", "OFFLINE", "OFFSET",
"OF", "OJ", "OLD_PASSWORD", "ONE", "ONLINE", "ONLY", "OPEN", "OPTIMIZER_COSTS",
"OPTIONS", "OWNER", "PACK_KEYS", "PAGE", "PAGE_COMPRESSED", "PAGE_COMPRESSION_LEVEL",
"PARSER", "PARTIAL", "PARTITIONING", "PARTITIONS", "PASSWORD", "PASSWORD_LOCK_TIME",
"PHASE", "PLUGIN", "PLUGIN_DIR", "PLUGINS", "PORT", "PRECEDES", "PRECEDING",
"PREPARE", "PRESERVE", "PREV", "PROCESSLIST", "PROFILE", "PROFILES",
"PROXY", "QUERY", "QUICK", "REBUILD", "RECOVER", "RECURSIVE", "REDO_BUFFER_SIZE",
"REDUNDANT", "RELAY", "RELAY_LOG_FILE", "RELAY_LOG_POS", "RELAYLOG",
"REMOVE", "REORGANIZE", "REPAIR", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE",
"REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB",
"REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION",
"RESET", "RESTART", "RESUME", "RETURNED_SQLSTATE", "RETURNING", "RETURNS",
"REUSE", "ROLE", "ROLLBACK", "ROLLUP", "ROTATE", "ROW", "ROWS", "ROW_FORMAT",
"RTREE", "SAVEPOINT", "SCHEDULE", "SECURITY", "SEQUENCE", "SERVER", "SESSION",
"SHARE", "SHARED", "SIGNED", "SIMPLE", "SLAVE", "SLOW", "SNAPSHOT", "SOCKET",
"SOME", "SONAME", "SOUNDS", "SOURCE", "SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS",
"SQL_BEFORE_GTIDS", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_NO_CACHE",
"SQL_THREAD", "START", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT",
"STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE", "STORED", "STRING",
"SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUSPEND",
"SWAPS", "SWITCHES", "TABLE_NAME", "TABLESPACE", "TABLE_TYPE", "TEMPORARY",
"TEMPTABLE", "THAN", "TRADITIONAL", "TRANSACTION", "TRANSACTIONAL", "TRIGGERS",
"TRUNCATE", "UNBOUNDED", "UNDEFINED", "UNDOFILE", "UNDO_BUFFER_SIZE",
"UNINSTALL", "UNKNOWN", "UNTIL", "UPGRADE", "USER", "USE_FRM", "USER_RESOURCES",
"VALIDATION", "VALUE", "VARIABLES", "VIEW", "VIRTUAL", "VISIBLE", "WAIT",
"WARNINGS", "WINDOW", "WITHOUT", "WORK", "WRAPPER", "X509", "XA", "XML",
"YES", "EUR", "USA", "JIS", "ISO", "INTERNAL", "QUARTER", "MONTH", "DAY",
"HOUR", "MINUTE", "WEEK", "SECOND", "MICROSECOND", "ADMIN", "APPLICATION_PASSWORD_ADMIN",
"AUDIT_ABORT_EXEMPT", "AUDIT_ADMIN", "AUTHENTICATION_POLICY_ADMIN", "BACKUP_ADMIN",
"BINLOG_ADMIN", "BINLOG_ENCRYPTION_ADMIN", "CLONE_ADMIN", "CONNECTION_ADMIN",
"ENCRYPTION_KEY_ADMIN", "EXECUTE", "FILE", "FIREWALL_ADMIN", "FIREWALL_EXEMPT",
"FIREWALL_USER", "FLUSH_OPTIMIZER_COSTS", "FLUSH_STATUS", "FLUSH_TABLES",
"FLUSH_USER_RESOURCES", "GROUP_REPLICATION_ADMIN", "INNODB_REDO_LOG_ARCHIVE",
"INNODB_REDO_LOG_ENABLE", "INVOKE", "LAMBDA", "NDB_STORED_USER", "PASSWORDLESS_USER_ADMIN",
"PERSIST_RO_VARIABLES_ADMIN", "PRIVILEGES", "PROCESS", "RELOAD", "REPLICATION_APPLIER",
"REPLICATION_SLAVE_ADMIN", "RESOURCE_GROUP_ADMIN", "RESOURCE_GROUP_USER",
"ROLE_ADMIN", "ROUTINE", "S3", "SERVICE_CONNECTION_ADMIN", "SESSION_VARIABLES_ADMIN",
"SET_USER_ID", "SHOW_ROUTINE", "SHUTDOWN", "SUPER", "SYSTEM_VARIABLES_ADMIN",
"TABLES", "TABLE_ENCRYPTION_ADMIN", "VERSION_TOKEN_ADMIN", "XA_RECOVER_ADMIN",
"ARMSCII8", "ASCII", "BIG5", "CP1250", "CP1251", "CP1256", "CP1257",
"CP850", "CP852", "CP866", "CP932", "DEC8", "EUCJPMS", "EUCKR", "GB18030",
"GB2312", "GBK", "GEOSTD8", "GREEK", "HEBREW", "HP8", "KEYBCS2", "KOI8R",
"KOI8U", "LATIN1", "LATIN2", "LATIN5", "LATIN7", "MACCE", "MACROMAN",
"SJIS", "SWE7", "TIS620", "UCS2", "UJIS", "UTF16", "UTF16LE", "UTF32",
"UTF8", "UTF8MB3", "UTF8MB4", "ARCHIVE", "BLACKHOLE", "CSV", "FEDERATED",
"INNODB", "MEMORY", "MRG_MYISAM", "MYISAM", "NDB", "NDBCLUSTER", "PERFORMANCE_SCHEMA",
"TOKUDB", "REPEATABLE", "COMMITTED", "UNCOMMITTED", "SERIALIZABLE", "GEOMETRYCOLLECTION",
"GEOMCOLLECTION", "GEOMETRY", "LINESTRING", "MULTILINESTRING", "MULTIPOINT",
"MULTIPOLYGON", "POINT", "POLYGON", "ABS", "ACOS", "ADDDATE", "ADDTIME",
"AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASIN", "ASTEXT", "ASWKB",
"ASWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE", "ASYMMETRIC_ENCRYPT",
"ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY", "ATAN", "ATAN2", "BENCHMARK",
"BIN", "BIT_COUNT", "BIT_LENGTH", "BUFFER", "CATALOG_NAME", "CEIL", "CEILING",
"CENTROID", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH", "COERCIBILITY",
"COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "CONV",
"CONVERT_TZ", "COS", "COT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY", "CREATE_ASYMMETRIC_PUB_KEY",
"CREATE_DH_PARAMETERS", "CREATE_DIGEST", "CROSSES", "DATEDIFF", "DATE_FORMAT",
"DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE", "DEGREES",
"DES_DECRYPT", "DES_ENCRYPT", "DIMENSION", "DISJOINT", "ELT", "ENCODE",
"ENCRYPT", "ENDPOINT", "ENGINE_ATTRIBUTE", "ENVELOPE", "EQUALS", "EXP",
"EXPORT_SET", "EXTERIORRING", "EXTRACTVALUE", "FIELD", "FIND_IN_SET",
"FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64", "FROM_DAYS", "FROM_UNIXTIME",
"GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB", "GEOMETRYCOLLECTIONFROMTEXT",
"GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT", "GEOMETRYFROMWKB", "GEOMETRYN",
"GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB", "GET_FORMAT", "GET_LOCK",
"GLENGTH", "GREATEST", "GTID_SUBSET", "GTID_SUBTRACT", "HEX", "IFNULL",
"INET6_ATON", "INET6_NTOA", "INET_ATON", "INET_NTOA", "INSTR", "INTERIORRINGN",
"INTERSECTS", "ISCLOSED", "ISEMPTY", "ISNULL", "ISSIMPLE", "IS_FREE_LOCK",
"IS_IPV4", "IS_IPV4_COMPAT", "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK",
"LAST_INSERT_ID", "LCASE", "LEAST", "LENGTH", "LINEFROMTEXT", "LINEFROMWKB",
"LINESTRINGFROMTEXT", "LINESTRINGFROMWKB", "LN", "LOAD_FILE", "LOCATE",
"LOG", "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM", "MAKEDATE", "MAKETIME",
"MAKE_SET", "MASTER_POS_WAIT", "MBRCONTAINS", "MBRDISJOINT", "MBREQUAL",
"MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES", "MBRWITHIN", "MD5", "MLINEFROMTEXT",
"MLINEFROMWKB", "MONTHNAME", "MPOINTFROMTEXT", "MPOINTFROMWKB", "MPOLYFROMTEXT",
"MPOLYFROMWKB", "MULTILINESTRINGFROMTEXT", "MULTILINESTRINGFROMWKB",
"MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB", "MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB",
"NAME_CONST", "NULLIF", "NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS",
"OCT", "OCTET_LENGTH", "ORD", "OVERLAPS", "PERIOD_ADD", "PERIOD_DIFF",
"PI", "POINTFROMTEXT", "POINTFROMWKB", "POINTN", "POLYFROMTEXT", "POLYFROMWKB",
"POLYGONFROMTEXT", "POLYGONFROMWKB", "POW", "POWER", "QUOTE", "RADIANS",
"RAND", "RANDOM", "RANDOM_BYTES", "RELEASE_LOCK", "REVERSE", "ROUND",
"ROW_COUNT", "RPAD", "RTRIM", "SEC_TO_TIME", "SECONDARY_ENGINE_ATTRIBUTE",
"SESSION_USER", "SHA", "SHA1", "SHA2", "SCHEMA_NAME", "SIGN", "SIN",
"SLEEP", "SOUNDEX", "SQL_THREAD_WAIT_AFTER_GTIDS", "SQRT", "SRID", "STARTPOINT",
"STRCMP", "STR_TO_DATE", "ST_AREA", "ST_ASBINARY", "ST_ASTEXT", "ST_ASWKB",
"ST_ASWKT", "ST_BUFFER", "ST_CENTROID", "ST_CONTAINS", "ST_CROSSES",
"ST_DIFFERENCE", "ST_DIMENSION", "ST_DISJOINT", "ST_DISTANCE", "ST_ENDPOINT",
"ST_ENVELOPE", "ST_EQUALS", "ST_EXTERIORRING", "ST_GEOMCOLLFROMTEXT",
"ST_GEOMCOLLFROMTXT", "ST_GEOMCOLLFROMWKB", "ST_GEOMETRYCOLLECTIONFROMTEXT",
"ST_GEOMETRYCOLLECTIONFROMWKB", "ST_GEOMETRYFROMTEXT", "ST_GEOMETRYFROMWKB",
"ST_GEOMETRYN", "ST_GEOMETRYTYPE", "ST_GEOMFROMTEXT", "ST_GEOMFROMWKB",
"ST_INTERIORRINGN", "ST_INTERSECTION", "ST_INTERSECTS", "ST_ISCLOSED",
"ST_ISEMPTY", "ST_ISSIMPLE", "ST_LINEFROMTEXT", "ST_LINEFROMWKB", "ST_LINESTRINGFROMTEXT",
"ST_LINESTRINGFROMWKB", "ST_NUMGEOMETRIES", "ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS",
"ST_NUMPOINTS", "ST_OVERLAPS", "ST_POINTFROMTEXT", "ST_POINTFROMWKB",
"ST_POINTN", "ST_POLYFROMTEXT", "ST_POLYFROMWKB", "ST_POLYGONFROMTEXT",
"ST_POLYGONFROMWKB", "ST_SRID", "ST_STARTPOINT", "ST_SYMDIFFERENCE",
"ST_TOUCHES", "ST_UNION", "ST_WITHIN", "ST_X", "ST_Y", "SUBDATE", "SUBSTRING_INDEX",
"SUBTIME", "SYSTEM_USER", "TAN", "TIMEDIFF", "TIMESTAMPADD", "TIMESTAMPDIFF",
"TIME_FORMAT", "TIME_TO_SEC", "TOUCHES", "TO_BASE64", "TO_DAYS", "TO_SECONDS",
"TP_CONNECTION_ADMIN", "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH",
"UNHEX", "UNIX_TIMESTAMP", "UPDATEXML", "UPPER", "UUID", "UUID_SHORT",
"VALIDATE_PASSWORD_STRENGTH", "VERSION", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS",
"WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING", "WITHIN", "YEARWEEK", "Y_FUNCTION",
"X_FUNCTION", "VAR_ASSIGN", "PLUS_ASSIGN", "MINUS_ASSIGN", "MULT_ASSIGN",
"DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN",
"STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL",
"GREATER_SYMBOL", "LESS_SYMBOL", "EXCLAMATION_SYMBOL", "BIT_NOT_OP",
"BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP", "DOT", "LR_BRACKET", "RR_BRACKET",
"COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL", "ONE_DECIMAL", "TWO_DECIMAL",
"SINGLE_QUOTE_SYMB", "DOUBLE_QUOTE_SYMB", "REVERSE_QUOTE_SYMB", "COLON_SYMB",
"CHARSET_REVERSE_QOUTE_STRING", "FILESIZE_LITERAL", "START_NATIONAL_STRING_LITERAL",
"STRING_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL",
"NULL_SPEC_LITERAL", "BIT_STRING", "STRING_CHARSET_NAME", "DOT_ID", "ID",
"REVERSE_QUOTE_ID", "HOST_IP_ADDRESS", "LOCAL_ID", "GLOBAL_ID", "ERROR_RECONGNIGION"
};
}
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] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "MySqlParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public MySqlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class RootContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(MySqlParser.EOF, 0); }
public SqlStatementsContext sqlStatements() {
return getRuleContext(SqlStatementsContext.class,0);
}
public List MINUS() { return getTokens(MySqlParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(MySqlParser.MINUS, i);
}
public RootContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_root; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoot(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoot(this);
else return visitor.visitChildren(this);
}
}
public final RootContext root() throws RecognitionException {
RootContext _localctx = new RootContext(_ctx, getState());
enterRule(_localctx, 0, RULE_root);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(723);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4614060972218253952L) != 0) || ((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & 2306124490637066243L) != 0) || ((((_la - 138)) & ~0x3f) == 0 && ((1L << (_la - 138)) & 19509751503569451L) != 0) || ((((_la - 344)) & ~0x3f) == 0 && ((1L << (_la - 344)) & 36099165796700291L) != 0) || ((((_la - 432)) & ~0x3f) == 0 && ((1L << (_la - 432)) & 16782337L) != 0) || ((((_la - 560)) & ~0x3f) == 0 && ((1L << (_la - 560)) & 17730162917377L) != 0) || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 4503604056555585L) != 0) || _la==EXECUTE || _la==SHUTDOWN || _la==LR_BRACKET || _la==SEMI) {
{
setState(722);
sqlStatements();
}
}
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(725);
match(MINUS);
setState(726);
match(MINUS);
}
}
setState(729);
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 SqlStatementsContext extends ParserRuleContext {
public List sqlStatement() {
return getRuleContexts(SqlStatementContext.class);
}
public SqlStatementContext sqlStatement(int i) {
return getRuleContext(SqlStatementContext.class,i);
}
public List emptyStatement_() {
return getRuleContexts(EmptyStatement_Context.class);
}
public EmptyStatement_Context emptyStatement_(int i) {
return getRuleContext(EmptyStatement_Context.class,i);
}
public List SEMI() { return getTokens(MySqlParser.SEMI); }
public TerminalNode SEMI(int i) {
return getToken(MySqlParser.SEMI, i);
}
public List MINUS() { return getTokens(MySqlParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(MySqlParser.MINUS, i);
}
public SqlStatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sqlStatements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSqlStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSqlStatements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSqlStatements(this);
else return visitor.visitChildren(this);
}
}
public final SqlStatementsContext sqlStatements() throws RecognitionException {
SqlStatementsContext _localctx = new SqlStatementsContext(_ctx, getState());
enterRule(_localctx, 2, RULE_sqlStatements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(742);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(740);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
case ANALYZE:
case CALL:
case CHANGE:
case CHECK:
case CREATE:
case DELETE:
case DESC:
case DESCRIBE:
case DROP:
case EXPLAIN:
case GET:
case GRANT:
case INSERT:
case KILL:
case LOAD:
case LOCK:
case OPTIMIZE:
case PURGE:
case RELEASE:
case RENAME:
case REPLACE:
case RESIGNAL:
case REVOKE:
case SELECT:
case SET:
case SHOW:
case SIGNAL:
case TABLE:
case UNLOCK:
case UPDATE:
case USE:
case VALUES:
case WITH:
case BEGIN:
case BINLOG:
case CACHE:
case CHECKSUM:
case COMMIT:
case DEALLOCATE:
case DO:
case FLUSH:
case HANDLER:
case HELP:
case INSTALL:
case PREPARE:
case REPAIR:
case RESET:
case ROLLBACK:
case SAVEPOINT:
case START:
case STOP:
case TRUNCATE:
case UNINSTALL:
case XA:
case EXECUTE:
case SHUTDOWN:
case LR_BRACKET:
{
setState(731);
sqlStatement();
setState(734);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(732);
match(MINUS);
setState(733);
match(MINUS);
}
}
setState(737);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
setState(736);
match(SEMI);
}
break;
}
}
break;
case SEMI:
{
setState(739);
emptyStatement_();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(744);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
setState(754);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
case ANALYZE:
case CALL:
case CHANGE:
case CHECK:
case CREATE:
case DELETE:
case DESC:
case DESCRIBE:
case DROP:
case EXPLAIN:
case GET:
case GRANT:
case INSERT:
case KILL:
case LOAD:
case LOCK:
case OPTIMIZE:
case PURGE:
case RELEASE:
case RENAME:
case REPLACE:
case RESIGNAL:
case REVOKE:
case SELECT:
case SET:
case SHOW:
case SIGNAL:
case TABLE:
case UNLOCK:
case UPDATE:
case USE:
case VALUES:
case WITH:
case BEGIN:
case BINLOG:
case CACHE:
case CHECKSUM:
case COMMIT:
case DEALLOCATE:
case DO:
case FLUSH:
case HANDLER:
case HELP:
case INSTALL:
case PREPARE:
case REPAIR:
case RESET:
case ROLLBACK:
case SAVEPOINT:
case START:
case STOP:
case TRUNCATE:
case UNINSTALL:
case XA:
case EXECUTE:
case SHUTDOWN:
case LR_BRACKET:
{
setState(745);
sqlStatement();
setState(751);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(748);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(746);
match(MINUS);
setState(747);
match(MINUS);
}
}
setState(750);
match(SEMI);
}
break;
}
}
break;
case SEMI:
{
setState(753);
emptyStatement_();
}
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 SqlStatementContext extends ParserRuleContext {
public DdlStatementContext ddlStatement() {
return getRuleContext(DdlStatementContext.class,0);
}
public DmlStatementContext dmlStatement() {
return getRuleContext(DmlStatementContext.class,0);
}
public TransactionStatementContext transactionStatement() {
return getRuleContext(TransactionStatementContext.class,0);
}
public ReplicationStatementContext replicationStatement() {
return getRuleContext(ReplicationStatementContext.class,0);
}
public PreparedStatementContext preparedStatement() {
return getRuleContext(PreparedStatementContext.class,0);
}
public AdministrationStatementContext administrationStatement() {
return getRuleContext(AdministrationStatementContext.class,0);
}
public UtilityStatementContext utilityStatement() {
return getRuleContext(UtilityStatementContext.class,0);
}
public SqlStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sqlStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSqlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSqlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSqlStatement(this);
else return visitor.visitChildren(this);
}
}
public final SqlStatementContext sqlStatement() throws RecognitionException {
SqlStatementContext _localctx = new SqlStatementContext(_ctx, getState());
enterRule(_localctx, 4, RULE_sqlStatement);
try {
setState(763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(756);
ddlStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(757);
dmlStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(758);
transactionStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(759);
replicationStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(760);
preparedStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(761);
administrationStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(762);
utilityStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EmptyStatement_Context extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(MySqlParser.SEMI, 0); }
public EmptyStatement_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyStatement_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEmptyStatement_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEmptyStatement_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitEmptyStatement_(this);
else return visitor.visitChildren(this);
}
}
public final EmptyStatement_Context emptyStatement_() throws RecognitionException {
EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState());
enterRule(_localctx, 6, RULE_emptyStatement_);
try {
enterOuterAlt(_localctx, 1);
{
setState(765);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DdlStatementContext extends ParserRuleContext {
public CreateDatabaseContext createDatabase() {
return getRuleContext(CreateDatabaseContext.class,0);
}
public CreateEventContext createEvent() {
return getRuleContext(CreateEventContext.class,0);
}
public CreateIndexContext createIndex() {
return getRuleContext(CreateIndexContext.class,0);
}
public CreateLogfileGroupContext createLogfileGroup() {
return getRuleContext(CreateLogfileGroupContext.class,0);
}
public CreateProcedureContext createProcedure() {
return getRuleContext(CreateProcedureContext.class,0);
}
public CreateFunctionContext createFunction() {
return getRuleContext(CreateFunctionContext.class,0);
}
public CreateServerContext createServer() {
return getRuleContext(CreateServerContext.class,0);
}
public CreateTableContext createTable() {
return getRuleContext(CreateTableContext.class,0);
}
public CreateTablespaceInnodbContext createTablespaceInnodb() {
return getRuleContext(CreateTablespaceInnodbContext.class,0);
}
public CreateTablespaceNdbContext createTablespaceNdb() {
return getRuleContext(CreateTablespaceNdbContext.class,0);
}
public CreateTriggerContext createTrigger() {
return getRuleContext(CreateTriggerContext.class,0);
}
public CreateViewContext createView() {
return getRuleContext(CreateViewContext.class,0);
}
public CreateRoleContext createRole() {
return getRuleContext(CreateRoleContext.class,0);
}
public AlterDatabaseContext alterDatabase() {
return getRuleContext(AlterDatabaseContext.class,0);
}
public AlterEventContext alterEvent() {
return getRuleContext(AlterEventContext.class,0);
}
public AlterFunctionContext alterFunction() {
return getRuleContext(AlterFunctionContext.class,0);
}
public AlterInstanceContext alterInstance() {
return getRuleContext(AlterInstanceContext.class,0);
}
public AlterLogfileGroupContext alterLogfileGroup() {
return getRuleContext(AlterLogfileGroupContext.class,0);
}
public AlterProcedureContext alterProcedure() {
return getRuleContext(AlterProcedureContext.class,0);
}
public AlterServerContext alterServer() {
return getRuleContext(AlterServerContext.class,0);
}
public AlterTableContext alterTable() {
return getRuleContext(AlterTableContext.class,0);
}
public AlterTablespaceContext alterTablespace() {
return getRuleContext(AlterTablespaceContext.class,0);
}
public AlterViewContext alterView() {
return getRuleContext(AlterViewContext.class,0);
}
public DropDatabaseContext dropDatabase() {
return getRuleContext(DropDatabaseContext.class,0);
}
public DropEventContext dropEvent() {
return getRuleContext(DropEventContext.class,0);
}
public DropIndexContext dropIndex() {
return getRuleContext(DropIndexContext.class,0);
}
public DropLogfileGroupContext dropLogfileGroup() {
return getRuleContext(DropLogfileGroupContext.class,0);
}
public DropProcedureContext dropProcedure() {
return getRuleContext(DropProcedureContext.class,0);
}
public DropFunctionContext dropFunction() {
return getRuleContext(DropFunctionContext.class,0);
}
public DropServerContext dropServer() {
return getRuleContext(DropServerContext.class,0);
}
public DropTableContext dropTable() {
return getRuleContext(DropTableContext.class,0);
}
public DropTablespaceContext dropTablespace() {
return getRuleContext(DropTablespaceContext.class,0);
}
public DropTriggerContext dropTrigger() {
return getRuleContext(DropTriggerContext.class,0);
}
public DropViewContext dropView() {
return getRuleContext(DropViewContext.class,0);
}
public DropRoleContext dropRole() {
return getRuleContext(DropRoleContext.class,0);
}
public SetRoleContext setRole() {
return getRuleContext(SetRoleContext.class,0);
}
public RenameTableContext renameTable() {
return getRuleContext(RenameTableContext.class,0);
}
public TruncateTableContext truncateTable() {
return getRuleContext(TruncateTableContext.class,0);
}
public DdlStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ddlStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDdlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDdlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitDdlStatement(this);
else return visitor.visitChildren(this);
}
}
public final DdlStatementContext ddlStatement() throws RecognitionException {
DdlStatementContext _localctx = new DdlStatementContext(_ctx, getState());
enterRule(_localctx, 8, RULE_ddlStatement);
try {
setState(805);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(767);
createDatabase();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(768);
createEvent();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(769);
createIndex();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(770);
createLogfileGroup();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(771);
createProcedure();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(772);
createFunction();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(773);
createServer();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(774);
createTable();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(775);
createTablespaceInnodb();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(776);
createTablespaceNdb();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(777);
createTrigger();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(778);
createView();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(779);
createRole();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(780);
alterDatabase();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(781);
alterEvent();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(782);
alterFunction();
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(783);
alterInstance();
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(784);
alterLogfileGroup();
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(785);
alterProcedure();
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(786);
alterServer();
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(787);
alterTable();
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(788);
alterTablespace();
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(789);
alterView();
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(790);
dropDatabase();
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(791);
dropEvent();
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(792);
dropIndex();
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(793);
dropLogfileGroup();
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(794);
dropProcedure();
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(795);
dropFunction();
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(796);
dropServer();
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(797);
dropTable();
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(798);
dropTablespace();
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(799);
dropTrigger();
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(800);
dropView();
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(801);
dropRole();
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(802);
setRole();
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(803);
renameTable();
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(804);
truncateTable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DmlStatementContext extends ParserRuleContext {
public SelectStatementContext selectStatement() {
return getRuleContext(SelectStatementContext.class,0);
}
public InsertStatementContext insertStatement() {
return getRuleContext(InsertStatementContext.class,0);
}
public UpdateStatementContext updateStatement() {
return getRuleContext(UpdateStatementContext.class,0);
}
public DeleteStatementContext deleteStatement() {
return getRuleContext(DeleteStatementContext.class,0);
}
public ReplaceStatementContext replaceStatement() {
return getRuleContext(ReplaceStatementContext.class,0);
}
public CallStatementContext callStatement() {
return getRuleContext(CallStatementContext.class,0);
}
public LoadDataStatementContext loadDataStatement() {
return getRuleContext(LoadDataStatementContext.class,0);
}
public LoadXmlStatementContext loadXmlStatement() {
return getRuleContext(LoadXmlStatementContext.class,0);
}
public DoStatementContext doStatement() {
return getRuleContext(DoStatementContext.class,0);
}
public HandlerStatementContext handlerStatement() {
return getRuleContext(HandlerStatementContext.class,0);
}
public ValuesStatementContext valuesStatement() {
return getRuleContext(ValuesStatementContext.class,0);
}
public WithStatementContext withStatement() {
return getRuleContext(WithStatementContext.class,0);
}
public TableStatementContext tableStatement() {
return getRuleContext(TableStatementContext.class,0);
}
public DmlStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dmlStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDmlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDmlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitDmlStatement(this);
else return visitor.visitChildren(this);
}
}
public final DmlStatementContext dmlStatement() throws RecognitionException {
DmlStatementContext _localctx = new DmlStatementContext(_ctx, getState());
enterRule(_localctx, 10, RULE_dmlStatement);
try {
setState(820);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(807);
selectStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(808);
insertStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(809);
updateStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(810);
deleteStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(811);
replaceStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(812);
callStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(813);
loadDataStatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(814);
loadXmlStatement();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(815);
doStatement();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(816);
handlerStatement();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(817);
valuesStatement();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(818);
withStatement();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(819);
tableStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TransactionStatementContext extends ParserRuleContext {
public StartTransactionContext startTransaction() {
return getRuleContext(StartTransactionContext.class,0);
}
public BeginWorkContext beginWork() {
return getRuleContext(BeginWorkContext.class,0);
}
public CommitWorkContext commitWork() {
return getRuleContext(CommitWorkContext.class,0);
}
public RollbackWorkContext rollbackWork() {
return getRuleContext(RollbackWorkContext.class,0);
}
public SavepointStatementContext savepointStatement() {
return getRuleContext(SavepointStatementContext.class,0);
}
public RollbackStatementContext rollbackStatement() {
return getRuleContext(RollbackStatementContext.class,0);
}
public ReleaseStatementContext releaseStatement() {
return getRuleContext(ReleaseStatementContext.class,0);
}
public LockTablesContext lockTables() {
return getRuleContext(LockTablesContext.class,0);
}
public UnlockTablesContext unlockTables() {
return getRuleContext(UnlockTablesContext.class,0);
}
public TransactionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transactionStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTransactionStatement(this);
else return visitor.visitChildren(this);
}
}
public final TransactionStatementContext transactionStatement() throws RecognitionException {
TransactionStatementContext _localctx = new TransactionStatementContext(_ctx, getState());
enterRule(_localctx, 12, RULE_transactionStatement);
try {
setState(831);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(822);
startTransaction();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(823);
beginWork();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(824);
commitWork();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(825);
rollbackWork();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(826);
savepointStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(827);
rollbackStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(828);
releaseStatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(829);
lockTables();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(830);
unlockTables();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReplicationStatementContext extends ParserRuleContext {
public ChangeMasterContext changeMaster() {
return getRuleContext(ChangeMasterContext.class,0);
}
public ChangeReplicationFilterContext changeReplicationFilter() {
return getRuleContext(ChangeReplicationFilterContext.class,0);
}
public PurgeBinaryLogsContext purgeBinaryLogs() {
return getRuleContext(PurgeBinaryLogsContext.class,0);
}
public ResetMasterContext resetMaster() {
return getRuleContext(ResetMasterContext.class,0);
}
public ResetSlaveContext resetSlave() {
return getRuleContext(ResetSlaveContext.class,0);
}
public StartSlaveContext startSlave() {
return getRuleContext(StartSlaveContext.class,0);
}
public StopSlaveContext stopSlave() {
return getRuleContext(StopSlaveContext.class,0);
}
public StartGroupReplicationContext startGroupReplication() {
return getRuleContext(StartGroupReplicationContext.class,0);
}
public StopGroupReplicationContext stopGroupReplication() {
return getRuleContext(StopGroupReplicationContext.class,0);
}
public XaStartTransactionContext xaStartTransaction() {
return getRuleContext(XaStartTransactionContext.class,0);
}
public XaEndTransactionContext xaEndTransaction() {
return getRuleContext(XaEndTransactionContext.class,0);
}
public XaPrepareStatementContext xaPrepareStatement() {
return getRuleContext(XaPrepareStatementContext.class,0);
}
public XaCommitWorkContext xaCommitWork() {
return getRuleContext(XaCommitWorkContext.class,0);
}
public XaRollbackWorkContext xaRollbackWork() {
return getRuleContext(XaRollbackWorkContext.class,0);
}
public XaRecoverWorkContext xaRecoverWork() {
return getRuleContext(XaRecoverWorkContext.class,0);
}
public ReplicationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_replicationStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReplicationStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReplicationStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitReplicationStatement(this);
else return visitor.visitChildren(this);
}
}
public final ReplicationStatementContext replicationStatement() throws RecognitionException {
ReplicationStatementContext _localctx = new ReplicationStatementContext(_ctx, getState());
enterRule(_localctx, 14, RULE_replicationStatement);
try {
setState(848);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(833);
changeMaster();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(834);
changeReplicationFilter();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(835);
purgeBinaryLogs();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(836);
resetMaster();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(837);
resetSlave();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(838);
startSlave();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(839);
stopSlave();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(840);
startGroupReplication();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(841);
stopGroupReplication();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(842);
xaStartTransaction();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(843);
xaEndTransaction();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(844);
xaPrepareStatement();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(845);
xaCommitWork();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(846);
xaRollbackWork();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(847);
xaRecoverWork();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PreparedStatementContext extends ParserRuleContext {
public PrepareStatementContext prepareStatement() {
return getRuleContext(PrepareStatementContext.class,0);
}
public ExecuteStatementContext executeStatement() {
return getRuleContext(ExecuteStatementContext.class,0);
}
public DeallocatePrepareContext deallocatePrepare() {
return getRuleContext(DeallocatePrepareContext.class,0);
}
public PreparedStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preparedStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPreparedStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPreparedStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPreparedStatement(this);
else return visitor.visitChildren(this);
}
}
public final PreparedStatementContext preparedStatement() throws RecognitionException {
PreparedStatementContext _localctx = new PreparedStatementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_preparedStatement);
try {
setState(853);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PREPARE:
enterOuterAlt(_localctx, 1);
{
setState(850);
prepareStatement();
}
break;
case EXECUTE:
enterOuterAlt(_localctx, 2);
{
setState(851);
executeStatement();
}
break;
case DROP:
case DEALLOCATE:
enterOuterAlt(_localctx, 3);
{
setState(852);
deallocatePrepare();
}
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 CompoundStatementContext extends ParserRuleContext {
public BlockStatementContext blockStatement() {
return getRuleContext(BlockStatementContext.class,0);
}
public CaseStatementContext caseStatement() {
return getRuleContext(CaseStatementContext.class,0);
}
public IfStatementContext ifStatement() {
return getRuleContext(IfStatementContext.class,0);
}
public LeaveStatementContext leaveStatement() {
return getRuleContext(LeaveStatementContext.class,0);
}
public LoopStatementContext loopStatement() {
return getRuleContext(LoopStatementContext.class,0);
}
public RepeatStatementContext repeatStatement() {
return getRuleContext(RepeatStatementContext.class,0);
}
public WhileStatementContext whileStatement() {
return getRuleContext(WhileStatementContext.class,0);
}
public IterateStatementContext iterateStatement() {
return getRuleContext(IterateStatementContext.class,0);
}
public ReturnStatementContext returnStatement() {
return getRuleContext(ReturnStatementContext.class,0);
}
public CursorStatementContext cursorStatement() {
return getRuleContext(CursorStatementContext.class,0);
}
public CompoundStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compoundStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCompoundStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCompoundStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCompoundStatement(this);
else return visitor.visitChildren(this);
}
}
public final CompoundStatementContext compoundStatement() throws RecognitionException {
CompoundStatementContext _localctx = new CompoundStatementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_compoundStatement);
try {
setState(865);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(855);
blockStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(856);
caseStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(857);
ifStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(858);
leaveStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(859);
loopStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(860);
repeatStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(861);
whileStatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(862);
iterateStatement();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(863);
returnStatement();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(864);
cursorStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AdministrationStatementContext extends ParserRuleContext {
public AlterUserContext alterUser() {
return getRuleContext(AlterUserContext.class,0);
}
public CreateUserContext createUser() {
return getRuleContext(CreateUserContext.class,0);
}
public DropUserContext dropUser() {
return getRuleContext(DropUserContext.class,0);
}
public GrantStatementContext grantStatement() {
return getRuleContext(GrantStatementContext.class,0);
}
public GrantProxyContext grantProxy() {
return getRuleContext(GrantProxyContext.class,0);
}
public RenameUserContext renameUser() {
return getRuleContext(RenameUserContext.class,0);
}
public RevokeStatementContext revokeStatement() {
return getRuleContext(RevokeStatementContext.class,0);
}
public RevokeProxyContext revokeProxy() {
return getRuleContext(RevokeProxyContext.class,0);
}
public AnalyzeTableContext analyzeTable() {
return getRuleContext(AnalyzeTableContext.class,0);
}
public CheckTableContext checkTable() {
return getRuleContext(CheckTableContext.class,0);
}
public ChecksumTableContext checksumTable() {
return getRuleContext(ChecksumTableContext.class,0);
}
public OptimizeTableContext optimizeTable() {
return getRuleContext(OptimizeTableContext.class,0);
}
public RepairTableContext repairTable() {
return getRuleContext(RepairTableContext.class,0);
}
public CreateUdfunctionContext createUdfunction() {
return getRuleContext(CreateUdfunctionContext.class,0);
}
public InstallPluginContext installPlugin() {
return getRuleContext(InstallPluginContext.class,0);
}
public UninstallPluginContext uninstallPlugin() {
return getRuleContext(UninstallPluginContext.class,0);
}
public SetStatementContext setStatement() {
return getRuleContext(SetStatementContext.class,0);
}
public ShowStatementContext showStatement() {
return getRuleContext(ShowStatementContext.class,0);
}
public BinlogStatementContext binlogStatement() {
return getRuleContext(BinlogStatementContext.class,0);
}
public CacheIndexStatementContext cacheIndexStatement() {
return getRuleContext(CacheIndexStatementContext.class,0);
}
public FlushStatementContext flushStatement() {
return getRuleContext(FlushStatementContext.class,0);
}
public KillStatementContext killStatement() {
return getRuleContext(KillStatementContext.class,0);
}
public LoadIndexIntoCacheContext loadIndexIntoCache() {
return getRuleContext(LoadIndexIntoCacheContext.class,0);
}
public ResetStatementContext resetStatement() {
return getRuleContext(ResetStatementContext.class,0);
}
public ShutdownStatementContext shutdownStatement() {
return getRuleContext(ShutdownStatementContext.class,0);
}
public AdministrationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_administrationStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAdministrationStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAdministrationStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAdministrationStatement(this);
else return visitor.visitChildren(this);
}
}
public final AdministrationStatementContext administrationStatement() throws RecognitionException {
AdministrationStatementContext _localctx = new AdministrationStatementContext(_ctx, getState());
enterRule(_localctx, 20, RULE_administrationStatement);
try {
setState(892);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(867);
alterUser();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(868);
createUser();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(869);
dropUser();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(870);
grantStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(871);
grantProxy();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(872);
renameUser();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(873);
revokeStatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(874);
revokeProxy();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(875);
analyzeTable();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(876);
checkTable();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(877);
checksumTable();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(878);
optimizeTable();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(879);
repairTable();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(880);
createUdfunction();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(881);
installPlugin();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(882);
uninstallPlugin();
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(883);
setStatement();
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(884);
showStatement();
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(885);
binlogStatement();
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(886);
cacheIndexStatement();
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(887);
flushStatement();
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(888);
killStatement();
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(889);
loadIndexIntoCache();
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(890);
resetStatement();
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(891);
shutdownStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UtilityStatementContext extends ParserRuleContext {
public SimpleDescribeStatementContext simpleDescribeStatement() {
return getRuleContext(SimpleDescribeStatementContext.class,0);
}
public FullDescribeStatementContext fullDescribeStatement() {
return getRuleContext(FullDescribeStatementContext.class,0);
}
public HelpStatementContext helpStatement() {
return getRuleContext(HelpStatementContext.class,0);
}
public UseStatementContext useStatement() {
return getRuleContext(UseStatementContext.class,0);
}
public SignalStatementContext signalStatement() {
return getRuleContext(SignalStatementContext.class,0);
}
public ResignalStatementContext resignalStatement() {
return getRuleContext(ResignalStatementContext.class,0);
}
public DiagnosticsStatementContext diagnosticsStatement() {
return getRuleContext(DiagnosticsStatementContext.class,0);
}
public UtilityStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_utilityStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUtilityStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUtilityStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitUtilityStatement(this);
else return visitor.visitChildren(this);
}
}
public final UtilityStatementContext utilityStatement() throws RecognitionException {
UtilityStatementContext _localctx = new UtilityStatementContext(_ctx, getState());
enterRule(_localctx, 22, RULE_utilityStatement);
try {
setState(901);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(894);
simpleDescribeStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(895);
fullDescribeStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(896);
helpStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(897);
useStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(898);
signalStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(899);
resignalStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(900);
diagnosticsStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateDatabaseContext extends ParserRuleContext {
public Token dbFormat;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); }
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public List createDatabaseOption() {
return getRuleContexts(CreateDatabaseOptionContext.class);
}
public CreateDatabaseOptionContext createDatabaseOption(int i) {
return getRuleContext(CreateDatabaseOptionContext.class,i);
}
public CreateDatabaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createDatabase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDatabase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateDatabase(this);
else return visitor.visitChildren(this);
}
}
public final CreateDatabaseContext createDatabase() throws RecognitionException {
CreateDatabaseContext _localctx = new CreateDatabaseContext(_ctx, getState());
enterRule(_localctx, 24, RULE_createDatabase);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
match(CREATE);
setState(904);
((CreateDatabaseContext)_localctx).dbFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
((CreateDatabaseContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(906);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(905);
ifNotExists();
}
break;
}
setState(908);
uid();
setState(912);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4398214283264L) != 0) || _la==READ || _la==CHAR || _la==ENCRYPTION || _la==CHARSET) {
{
{
setState(909);
createDatabaseOption();
}
}
setState(914);
_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 CreateEventContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public List ON() { return getTokens(MySqlParser.ON); }
public TerminalNode ON(int i) {
return getToken(MySqlParser.ON, i);
}
public TerminalNode SCHEDULE() { return getToken(MySqlParser.SCHEDULE, 0); }
public ScheduleExpressionContext scheduleExpression() {
return getRuleContext(ScheduleExpressionContext.class,0);
}
public TerminalNode DO() { return getToken(MySqlParser.DO, 0); }
public RoutineBodyContext routineBody() {
return getRuleContext(RoutineBodyContext.class,0);
}
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public TerminalNode COMPLETION() { return getToken(MySqlParser.COMPLETION, 0); }
public TerminalNode PRESERVE() { return getToken(MySqlParser.PRESERVE, 0); }
public EnableTypeContext enableType() {
return getRuleContext(EnableTypeContext.class,0);
}
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); }
public CreateEventContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createEvent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateEvent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateEvent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateEvent(this);
else return visitor.visitChildren(this);
}
}
public final CreateEventContext createEvent() throws RecognitionException {
CreateEventContext _localctx = new CreateEventContext(_ctx, getState());
enterRule(_localctx, 26, RULE_createEvent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(915);
match(CREATE);
setState(917);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(916);
ownerStatement();
}
}
setState(919);
match(EVENT);
setState(921);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(920);
ifNotExists();
}
break;
}
setState(923);
fullId();
setState(924);
match(ON);
setState(925);
match(SCHEDULE);
setState(926);
scheduleExpression();
setState(933);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(927);
match(ON);
setState(928);
match(COMPLETION);
setState(930);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(929);
match(NOT);
}
}
setState(932);
match(PRESERVE);
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISABLE || _la==ENABLE) {
{
setState(935);
enableType();
}
}
setState(940);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(938);
match(COMMENT);
setState(939);
match(STRING_LITERAL);
}
}
setState(942);
match(DO);
setState(943);
routineBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateIndexContext extends ParserRuleContext {
public Token intimeAction;
public Token indexCategory;
public Token algType;
public Token lockType;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode ON() { return getToken(MySqlParser.ON, 0); }
public TableNameContext tableName() {
return getRuleContext(TableNameContext.class,0);
}
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public List indexOption() {
return getRuleContexts(IndexOptionContext.class);
}
public IndexOptionContext indexOption(int i) {
return getRuleContext(IndexOptionContext.class,i);
}
public List ALGORITHM() { return getTokens(MySqlParser.ALGORITHM); }
public TerminalNode ALGORITHM(int i) {
return getToken(MySqlParser.ALGORITHM, i);
}
public List LOCK() { return getTokens(MySqlParser.LOCK); }
public TerminalNode LOCK(int i) {
return getToken(MySqlParser.LOCK, i);
}
public TerminalNode ONLINE() { return getToken(MySqlParser.ONLINE, 0); }
public TerminalNode OFFLINE() { return getToken(MySqlParser.OFFLINE, 0); }
public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); }
public TerminalNode FULLTEXT() { return getToken(MySqlParser.FULLTEXT, 0); }
public TerminalNode SPATIAL() { return getToken(MySqlParser.SPATIAL, 0); }
public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); }
public TerminalNode DEFAULT(int i) {
return getToken(MySqlParser.DEFAULT, i);
}
public List INPLACE() { return getTokens(MySqlParser.INPLACE); }
public TerminalNode INPLACE(int i) {
return getToken(MySqlParser.INPLACE, i);
}
public List COPY() { return getTokens(MySqlParser.COPY); }
public TerminalNode COPY(int i) {
return getToken(MySqlParser.COPY, i);
}
public List NONE() { return getTokens(MySqlParser.NONE); }
public TerminalNode NONE(int i) {
return getToken(MySqlParser.NONE, i);
}
public List SHARED() { return getTokens(MySqlParser.SHARED); }
public TerminalNode SHARED(int i) {
return getToken(MySqlParser.SHARED, i);
}
public List EXCLUSIVE() { return getTokens(MySqlParser.EXCLUSIVE); }
public TerminalNode EXCLUSIVE(int i) {
return getToken(MySqlParser.EXCLUSIVE, i);
}
public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); }
public TerminalNode EQUAL_SYMBOL(int i) {
return getToken(MySqlParser.EQUAL_SYMBOL, i);
}
public CreateIndexContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndex; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateIndex(this);
else return visitor.visitChildren(this);
}
}
public final CreateIndexContext createIndex() throws RecognitionException {
CreateIndexContext _localctx = new CreateIndexContext(_ctx, getState());
enterRule(_localctx, 28, RULE_createIndex);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(945);
match(CREATE);
setState(947);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFLINE || _la==ONLINE) {
{
setState(946);
((CreateIndexContext)_localctx).intimeAction = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==OFFLINE || _la==ONLINE) ) {
((CreateIndexContext)_localctx).intimeAction = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FULLTEXT || _la==SPATIAL || _la==UNIQUE) {
{
setState(949);
((CreateIndexContext)_localctx).indexCategory = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FULLTEXT || _la==SPATIAL || _la==UNIQUE) ) {
((CreateIndexContext)_localctx).indexCategory = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(952);
match(INDEX);
setState(953);
uid();
setState(955);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(954);
indexType();
}
}
setState(957);
match(ON);
setState(958);
tableName();
setState(959);
indexColumnNames();
setState(963);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(960);
indexOption();
}
}
}
setState(965);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
}
setState(978);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(976);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALGORITHM:
{
setState(966);
match(ALGORITHM);
setState(968);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(967);
match(EQUAL_SYMBOL);
}
}
setState(970);
((CreateIndexContext)_localctx).algType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==COPY || _la==INPLACE) ) {
((CreateIndexContext)_localctx).algType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case LOCK:
{
setState(971);
match(LOCK);
setState(973);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(972);
match(EQUAL_SYMBOL);
}
}
setState(975);
((CreateIndexContext)_localctx).lockType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==EXCLUSIVE || _la==NONE || _la==SHARED) ) {
((CreateIndexContext)_localctx).lockType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(980);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateLogfileGroupContext extends ParserRuleContext {
public Token undoFile;
public FileSizeLiteralContext initSize;
public FileSizeLiteralContext undoSize;
public FileSizeLiteralContext redoSize;
public Token comment;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); }
public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); }
public List uid() {
return getRuleContexts(UidContext.class);
}
public UidContext uid(int i) {
return getRuleContext(UidContext.class,i);
}
public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); }
public TerminalNode UNDOFILE() { return getToken(MySqlParser.UNDOFILE, 0); }
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(MySqlParser.STRING_LITERAL, i);
}
public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); }
public TerminalNode UNDO_BUFFER_SIZE() { return getToken(MySqlParser.UNDO_BUFFER_SIZE, 0); }
public TerminalNode REDO_BUFFER_SIZE() { return getToken(MySqlParser.REDO_BUFFER_SIZE, 0); }
public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); }
public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); }
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); }
public TerminalNode EQUAL_SYMBOL(int i) {
return getToken(MySqlParser.EQUAL_SYMBOL, i);
}
public List fileSizeLiteral() {
return getRuleContexts(FileSizeLiteralContext.class);
}
public FileSizeLiteralContext fileSizeLiteral(int i) {
return getRuleContext(FileSizeLiteralContext.class,i);
}
public CreateLogfileGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createLogfileGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateLogfileGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateLogfileGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateLogfileGroup(this);
else return visitor.visitChildren(this);
}
}
public final CreateLogfileGroupContext createLogfileGroup() throws RecognitionException {
CreateLogfileGroupContext _localctx = new CreateLogfileGroupContext(_ctx, getState());
enterRule(_localctx, 30, RULE_createLogfileGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(981);
match(CREATE);
setState(982);
match(LOGFILE);
setState(983);
match(GROUP);
setState(984);
uid();
setState(985);
match(ADD);
setState(986);
match(UNDOFILE);
setState(987);
((CreateLogfileGroupContext)_localctx).undoFile = match(STRING_LITERAL);
setState(993);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIAL_SIZE) {
{
setState(988);
match(INITIAL_SIZE);
setState(990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(989);
match(EQUAL_SYMBOL);
}
}
setState(992);
((CreateLogfileGroupContext)_localctx).initSize = fileSizeLiteral();
}
}
setState(1000);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNDO_BUFFER_SIZE) {
{
setState(995);
match(UNDO_BUFFER_SIZE);
setState(997);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(996);
match(EQUAL_SYMBOL);
}
}
setState(999);
((CreateLogfileGroupContext)_localctx).undoSize = fileSizeLiteral();
}
}
setState(1007);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==REDO_BUFFER_SIZE) {
{
setState(1002);
match(REDO_BUFFER_SIZE);
setState(1004);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1003);
match(EQUAL_SYMBOL);
}
}
setState(1006);
((CreateLogfileGroupContext)_localctx).redoSize = fileSizeLiteral();
}
}
setState(1014);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NODEGROUP) {
{
setState(1009);
match(NODEGROUP);
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1010);
match(EQUAL_SYMBOL);
}
}
setState(1013);
uid();
}
}
setState(1017);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WAIT) {
{
setState(1016);
match(WAIT);
}
}
setState(1024);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(1019);
match(COMMENT);
setState(1021);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1020);
match(EQUAL_SYMBOL);
}
}
setState(1023);
((CreateLogfileGroupContext)_localctx).comment = match(STRING_LITERAL);
}
}
setState(1026);
match(ENGINE);
setState(1028);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1027);
match(EQUAL_SYMBOL);
}
}
setState(1030);
engineName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateProcedureContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public RoutineBodyContext routineBody() {
return getRuleContext(RoutineBodyContext.class,0);
}
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public List procedureParameter() {
return getRuleContexts(ProcedureParameterContext.class);
}
public ProcedureParameterContext procedureParameter(int i) {
return getRuleContext(ProcedureParameterContext.class,i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public List routineOption() {
return getRuleContexts(RoutineOptionContext.class);
}
public RoutineOptionContext routineOption(int i) {
return getRuleContext(RoutineOptionContext.class,i);
}
public CreateProcedureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createProcedure; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateProcedure(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateProcedure(this);
else return visitor.visitChildren(this);
}
}
public final CreateProcedureContext createProcedure() throws RecognitionException {
CreateProcedureContext _localctx = new CreateProcedureContext(_ctx, getState());
enterRule(_localctx, 32, RULE_createProcedure);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1032);
match(CREATE);
setState(1034);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(1033);
ownerStatement();
}
}
setState(1036);
match(PROCEDURE);
setState(1037);
fullId();
setState(1038);
match(LR_BRACKET);
setState(1040);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 151169654698547409L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1039);
procedureParameter();
}
}
setState(1046);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1042);
match(COMMA);
setState(1043);
procedureParameter();
}
}
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1049);
match(RR_BRACKET);
setState(1053);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1050);
routineOption();
}
}
}
setState(1055);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
}
setState(1056);
routineBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateFunctionContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode RETURNS() { return getToken(MySqlParser.RETURNS, 0); }
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public RoutineBodyContext routineBody() {
return getRuleContext(RoutineBodyContext.class,0);
}
public ReturnStatementContext returnStatement() {
return getRuleContext(ReturnStatementContext.class,0);
}
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public TerminalNode AGGREGATE() { return getToken(MySqlParser.AGGREGATE, 0); }
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public List functionParameter() {
return getRuleContexts(FunctionParameterContext.class);
}
public FunctionParameterContext functionParameter(int i) {
return getRuleContext(FunctionParameterContext.class,i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public List routineOption() {
return getRuleContexts(RoutineOptionContext.class);
}
public RoutineOptionContext routineOption(int i) {
return getRuleContext(RoutineOptionContext.class,i);
}
public CreateFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateFunction(this);
else return visitor.visitChildren(this);
}
}
public final CreateFunctionContext createFunction() throws RecognitionException {
CreateFunctionContext _localctx = new CreateFunctionContext(_ctx, getState());
enterRule(_localctx, 34, RULE_createFunction);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1058);
match(CREATE);
setState(1060);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(1059);
ownerStatement();
}
}
setState(1063);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AGGREGATE) {
{
setState(1062);
match(AGGREGATE);
}
}
setState(1065);
match(FUNCTION);
setState(1067);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
{
setState(1066);
ifNotExists();
}
break;
}
setState(1069);
fullId();
setState(1070);
match(LR_BRACKET);
setState(1072);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1071);
functionParameter();
}
}
setState(1078);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1074);
match(COMMA);
setState(1075);
functionParameter();
}
}
setState(1080);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1081);
match(RR_BRACKET);
setState(1082);
match(RETURNS);
setState(1083);
dataType();
setState(1087);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1084);
routineOption();
}
}
}
setState(1089);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
}
setState(1092);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALTER:
case ANALYZE:
case ARRAY:
case ATTRIBUTE:
case BUCKETS:
case CALL:
case CHANGE:
case CHECK:
case CONDITION:
case CREATE:
case CURRENT:
case CURRENT_USER:
case DATABASE:
case DEFAULT:
case DELETE:
case DESC:
case DESCRIBE:
case DIAGNOSTICS:
case DROP:
case EMPTY:
case ENFORCED:
case EXCEPT:
case EXPLAIN:
case GET:
case GRANT:
case GROUP:
case IF:
case IGNORED:
case INSERT:
case KILL:
case LATERAL:
case LEFT:
case LOAD:
case LOCK:
case NUMBER:
case OPTIMIZE:
case OPTIONAL:
case ORDER:
case PRIMARY:
case PURGE:
case RELEASE:
case RENAME:
case REPEAT:
case REPLACE:
case RESIGNAL:
case REVOKE:
case RIGHT:
case SCHEMA:
case SELECT:
case SET:
case SHOW:
case SIGNAL:
case SKIP_QUERY_REWRITE:
case STACKED:
case TABLE:
case UNLOCK:
case UPDATE:
case USE:
case VALUES:
case WITH:
case DATE:
case TIME:
case TIMESTAMP:
case DATETIME:
case YEAR:
case BINARY:
case TEXT:
case ENUM:
case SERIAL:
case JSON_ARRAY:
case JSON_ARRAYAGG:
case JSON_ARRAY_APPEND:
case JSON_ARRAY_INSERT:
case JSON_CONTAINS:
case JSON_CONTAINS_PATH:
case JSON_DEPTH:
case JSON_EXTRACT:
case JSON_INSERT:
case JSON_KEYS:
case JSON_LENGTH:
case JSON_MERGE:
case JSON_MERGE_PATCH:
case JSON_MERGE_PRESERVE:
case JSON_OBJECT:
case JSON_OBJECTAGG:
case JSON_OVERLAPS:
case JSON_PRETTY:
case JSON_QUOTE:
case JSON_REMOVE:
case JSON_REPLACE:
case JSON_SCHEMA_VALID:
case JSON_SCHEMA_VALIDATION_REPORT:
case JSON_SEARCH:
case JSON_SET:
case JSON_STORAGE_FREE:
case JSON_STORAGE_SIZE:
case JSON_TABLE:
case JSON_TYPE:
case JSON_UNQUOTE:
case JSON_VALID:
case JSON_VALUE:
case NESTED:
case ORDINALITY:
case PATH:
case AVG:
case BIT_AND:
case BIT_OR:
case BIT_XOR:
case COUNT:
case CUME_DIST:
case DENSE_RANK:
case FIRST_VALUE:
case GROUP_CONCAT:
case LAG:
case LAST_VALUE:
case LEAD:
case MAX:
case MIN:
case NTILE:
case NTH_VALUE:
case PERCENT_RANK:
case RANK:
case ROW_NUMBER:
case STD:
case STDDEV:
case STDDEV_POP:
case STDDEV_SAMP:
case SUM:
case VAR_POP:
case VAR_SAMP:
case VARIANCE:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case LOCALTIME:
case CURDATE:
case CURTIME:
case DATE_ADD:
case DATE_SUB:
case LOCALTIMESTAMP:
case NOW:
case POSITION:
case SUBSTR:
case SUBSTRING:
case SYSDATE:
case TRIM:
case UTC_DATE:
case UTC_TIME:
case UTC_TIMESTAMP:
case ACCOUNT:
case ACTION:
case AFTER:
case AGGREGATE:
case ALGORITHM:
case ANY:
case AT:
case AUTHORS:
case AUTOCOMMIT:
case AUTOEXTEND_SIZE:
case AUTO_INCREMENT:
case AVG_ROW_LENGTH:
case BEGIN:
case BINLOG:
case BIT:
case BLOCK:
case BOOL:
case BOOLEAN:
case BTREE:
case CACHE:
case CASCADED:
case CHAIN:
case CHANGED:
case CHANNEL:
case CHECKSUM:
case PAGE_CHECKSUM:
case CIPHER:
case CLASS_ORIGIN:
case CLIENT:
case CLOSE:
case CLUSTERING:
case COALESCE:
case CODE:
case COLUMNS:
case COLUMN_FORMAT:
case COLUMN_NAME:
case COMMENT:
case COMMIT:
case COMPACT:
case COMPLETION:
case COMPRESSED:
case COMPRESSION:
case CONCURRENT:
case CONNECT:
case CONNECTION:
case CONSISTENT:
case CONSTRAINT_CATALOG:
case CONSTRAINT_SCHEMA:
case CONSTRAINT_NAME:
case CONTAINS:
case CONTEXT:
case CONTRIBUTORS:
case COPY:
case CPU:
case CURSOR_NAME:
case DATA:
case DATAFILE:
case DEALLOCATE:
case DEFAULT_AUTH:
case DEFINER:
case DELAY_KEY_WRITE:
case DES_KEY_FILE:
case DIRECTORY:
case DISABLE:
case DISCARD:
case DISK:
case DO:
case DUMPFILE:
case DUPLICATE:
case DYNAMIC:
case ENABLE:
case ENCRYPTION:
case END:
case ENDS:
case ENGINE:
case ENGINES:
case ERROR:
case ERRORS:
case ESCAPE:
case EVEN:
case EVENT:
case EVENTS:
case EVERY:
case EXCHANGE:
case EXCLUSIVE:
case EXPIRE:
case EXPORT:
case EXTENDED:
case EXTENT_SIZE:
case FAILED_LOGIN_ATTEMPTS:
case FAST:
case FAULTS:
case FIELDS:
case FILE_BLOCK_SIZE:
case FILTER:
case FIRST:
case FIXED:
case FLUSH:
case FOLLOWS:
case FOUND:
case FULL:
case FUNCTION:
case GENERAL:
case GLOBAL:
case GRANTS:
case GROUP_REPLICATION:
case HANDLER:
case HASH:
case HELP:
case HISTORY:
case HOST:
case HOSTS:
case IDENTIFIED:
case IGNORE_SERVER_IDS:
case IMPORT:
case INDEXES:
case INITIAL_SIZE:
case INPLACE:
case INSERT_METHOD:
case INSTALL:
case INSTANCE:
case INSTANT:
case INVISIBLE:
case INVOKER:
case IO:
case IO_THREAD:
case IPC:
case ISOLATION:
case ISSUER:
case JSON:
case KEY_BLOCK_SIZE:
case LANGUAGE:
case LAST:
case LEAVES:
case LESS:
case LEVEL:
case LIST:
case LOCAL:
case LOGFILE:
case LOGS:
case MASTER:
case MASTER_AUTO_POSITION:
case MASTER_CONNECT_RETRY:
case MASTER_DELAY:
case MASTER_HEARTBEAT_PERIOD:
case MASTER_HOST:
case MASTER_LOG_FILE:
case MASTER_LOG_POS:
case MASTER_PASSWORD:
case MASTER_PORT:
case MASTER_RETRY_COUNT:
case MASTER_SSL:
case MASTER_SSL_CA:
case MASTER_SSL_CAPATH:
case MASTER_SSL_CERT:
case MASTER_SSL_CIPHER:
case MASTER_SSL_CRL:
case MASTER_SSL_CRLPATH:
case MASTER_SSL_KEY:
case MASTER_TLS_VERSION:
case MASTER_USER:
case MAX_CONNECTIONS_PER_HOUR:
case MAX_QUERIES_PER_HOUR:
case MAX_ROWS:
case MAX_SIZE:
case MAX_UPDATES_PER_HOUR:
case MAX_USER_CONNECTIONS:
case MEDIUM:
case MEMBER:
case MERGE:
case MESSAGE_TEXT:
case MID:
case MIGRATE:
case MIN_ROWS:
case MODE:
case MODIFY:
case MUTEX:
case MYSQL:
case MYSQL_ERRNO:
case NAME:
case NAMES:
case NCHAR:
case NEVER:
case NEXT:
case NO:
case NOCOPY:
case NOWAIT:
case NODEGROUP:
case NONE:
case ODBC:
case OFFLINE:
case OFFSET:
case OF:
case OJ:
case OLD_PASSWORD:
case ONE:
case ONLINE:
case ONLY:
case OPEN:
case OPTIMIZER_COSTS:
case OPTIONS:
case OWNER:
case PACK_KEYS:
case PAGE:
case PARSER:
case PARTIAL:
case PARTITIONING:
case PARTITIONS:
case PASSWORD:
case PASSWORD_LOCK_TIME:
case PHASE:
case PLUGIN:
case PLUGIN_DIR:
case PLUGINS:
case PORT:
case PRECEDES:
case PREPARE:
case PRESERVE:
case PREV:
case PROCESSLIST:
case PROFILE:
case PROFILES:
case PROXY:
case QUERY:
case QUICK:
case REBUILD:
case RECOVER:
case RECURSIVE:
case REDO_BUFFER_SIZE:
case REDUNDANT:
case RELAY:
case RELAY_LOG_FILE:
case RELAY_LOG_POS:
case RELAYLOG:
case REMOVE:
case REORGANIZE:
case REPAIR:
case REPLICATE_DO_DB:
case REPLICATE_DO_TABLE:
case REPLICATE_IGNORE_DB:
case REPLICATE_IGNORE_TABLE:
case REPLICATE_REWRITE_DB:
case REPLICATE_WILD_DO_TABLE:
case REPLICATE_WILD_IGNORE_TABLE:
case REPLICATION:
case RESET:
case RESUME:
case RETURNED_SQLSTATE:
case RETURNS:
case REUSE:
case ROLE:
case ROLLBACK:
case ROLLUP:
case ROTATE:
case ROW:
case ROWS:
case ROW_FORMAT:
case RTREE:
case SAVEPOINT:
case SCHEDULE:
case SECURITY:
case SERVER:
case SESSION:
case SHARE:
case SHARED:
case SIGNED:
case SIMPLE:
case SLAVE:
case SLOW:
case SNAPSHOT:
case SOCKET:
case SOME:
case SONAME:
case SOUNDS:
case SOURCE:
case SQL_AFTER_GTIDS:
case SQL_AFTER_MTS_GAPS:
case SQL_BEFORE_GTIDS:
case SQL_BUFFER_RESULT:
case SQL_CACHE:
case SQL_NO_CACHE:
case SQL_THREAD:
case START:
case STARTS:
case STATS_AUTO_RECALC:
case STATS_PERSISTENT:
case STATS_SAMPLE_PAGES:
case STATUS:
case STOP:
case STORAGE:
case STRING:
case SUBCLASS_ORIGIN:
case SUBJECT:
case SUBPARTITION:
case SUBPARTITIONS:
case SUSPEND:
case SWAPS:
case SWITCHES:
case TABLE_NAME:
case TABLESPACE:
case TABLE_TYPE:
case TEMPORARY:
case TEMPTABLE:
case THAN:
case TRADITIONAL:
case TRANSACTION:
case TRANSACTIONAL:
case TRIGGERS:
case TRUNCATE:
case UNBOUNDED:
case UNDEFINED:
case UNDOFILE:
case UNDO_BUFFER_SIZE:
case UNINSTALL:
case UNKNOWN:
case UNTIL:
case UPGRADE:
case USER:
case USE_FRM:
case USER_RESOURCES:
case VALIDATION:
case VALUE:
case VARIABLES:
case VIEW:
case VIRTUAL:
case VISIBLE:
case WAIT:
case WARNINGS:
case WITHOUT:
case WORK:
case WRAPPER:
case X509:
case XA:
case XML:
case EUR:
case USA:
case JIS:
case ISO:
case INTERNAL:
case QUARTER:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case WEEK:
case SECOND:
case MICROSECOND:
case ADMIN:
case AUDIT_ABORT_EXEMPT:
case AUDIT_ADMIN:
case AUTHENTICATION_POLICY_ADMIN:
case BACKUP_ADMIN:
case BINLOG_ADMIN:
case BINLOG_ENCRYPTION_ADMIN:
case CLONE_ADMIN:
case CONNECTION_ADMIN:
case ENCRYPTION_KEY_ADMIN:
case EXECUTE:
case FILE:
case FIREWALL_ADMIN:
case FIREWALL_EXEMPT:
case FIREWALL_USER:
case GROUP_REPLICATION_ADMIN:
case INNODB_REDO_LOG_ARCHIVE:
case INVOKE:
case LAMBDA:
case NDB_STORED_USER:
case PASSWORDLESS_USER_ADMIN:
case PERSIST_RO_VARIABLES_ADMIN:
case PRIVILEGES:
case PROCESS:
case RELOAD:
case REPLICATION_APPLIER:
case REPLICATION_SLAVE_ADMIN:
case RESOURCE_GROUP_ADMIN:
case RESOURCE_GROUP_USER:
case ROLE_ADMIN:
case ROUTINE:
case S3:
case SESSION_VARIABLES_ADMIN:
case SET_USER_ID:
case SHOW_ROUTINE:
case SHUTDOWN:
case SUPER:
case SYSTEM_VARIABLES_ADMIN:
case TABLES:
case TABLE_ENCRYPTION_ADMIN:
case VERSION_TOKEN_ADMIN:
case XA_RECOVER_ADMIN:
case ARMSCII8:
case ASCII:
case BIG5:
case CP1250:
case CP1251:
case CP1256:
case CP1257:
case CP850:
case CP852:
case CP866:
case CP932:
case DEC8:
case EUCJPMS:
case EUCKR:
case GB18030:
case GB2312:
case GBK:
case GEOSTD8:
case GREEK:
case HEBREW:
case HP8:
case KEYBCS2:
case KOI8R:
case KOI8U:
case LATIN1:
case LATIN2:
case LATIN5:
case LATIN7:
case MACCE:
case MACROMAN:
case SJIS:
case SWE7:
case TIS620:
case UCS2:
case UJIS:
case UTF16:
case UTF16LE:
case UTF32:
case UTF8:
case UTF8MB3:
case UTF8MB4:
case ARCHIVE:
case BLACKHOLE:
case CSV:
case FEDERATED:
case INNODB:
case MEMORY:
case MRG_MYISAM:
case MYISAM:
case NDB:
case NDBCLUSTER:
case PERFORMANCE_SCHEMA:
case TOKUDB:
case REPEATABLE:
case COMMITTED:
case UNCOMMITTED:
case SERIALIZABLE:
case GEOMETRYCOLLECTION:
case LINESTRING:
case MULTILINESTRING:
case MULTIPOINT:
case MULTIPOLYGON:
case POINT:
case POLYGON:
case ABS:
case ACOS:
case ADDDATE:
case ADDTIME:
case AES_DECRYPT:
case AES_ENCRYPT:
case AREA:
case ASBINARY:
case ASIN:
case ASTEXT:
case ASWKB:
case ASWKT:
case ASYMMETRIC_DECRYPT:
case ASYMMETRIC_DERIVE:
case ASYMMETRIC_ENCRYPT:
case ASYMMETRIC_SIGN:
case ASYMMETRIC_VERIFY:
case ATAN:
case ATAN2:
case BENCHMARK:
case BIN:
case BIT_COUNT:
case BIT_LENGTH:
case BUFFER:
case CATALOG_NAME:
case CEIL:
case CEILING:
case CENTROID:
case CHARACTER_LENGTH:
case CHARSET:
case CHAR_LENGTH:
case COERCIBILITY:
case COLLATION:
case COMPRESS:
case CONCAT:
case CONCAT_WS:
case CONNECTION_ID:
case CONV:
case CONVERT_TZ:
case COS:
case COT:
case CRC32:
case CREATE_ASYMMETRIC_PRIV_KEY:
case CREATE_ASYMMETRIC_PUB_KEY:
case CREATE_DH_PARAMETERS:
case CREATE_DIGEST:
case CROSSES:
case DATEDIFF:
case DATE_FORMAT:
case DAYNAME:
case DAYOFMONTH:
case DAYOFWEEK:
case DAYOFYEAR:
case DECODE:
case DEGREES:
case DES_DECRYPT:
case DES_ENCRYPT:
case DIMENSION:
case DISJOINT:
case ELT:
case ENCODE:
case ENCRYPT:
case ENDPOINT:
case ENGINE_ATTRIBUTE:
case ENVELOPE:
case EQUALS:
case EXP:
case EXPORT_SET:
case EXTERIORRING:
case EXTRACTVALUE:
case FIELD:
case FIND_IN_SET:
case FLOOR:
case FORMAT:
case FOUND_ROWS:
case FROM_BASE64:
case FROM_DAYS:
case FROM_UNIXTIME:
case GEOMCOLLFROMTEXT:
case GEOMCOLLFROMWKB:
case GEOMETRYCOLLECTIONFROMTEXT:
case GEOMETRYCOLLECTIONFROMWKB:
case GEOMETRYFROMTEXT:
case GEOMETRYFROMWKB:
case GEOMETRYN:
case GEOMETRYTYPE:
case GEOMFROMTEXT:
case GEOMFROMWKB:
case GET_FORMAT:
case GET_LOCK:
case GLENGTH:
case GREATEST:
case GTID_SUBSET:
case GTID_SUBTRACT:
case HEX:
case IFNULL:
case INET6_ATON:
case INET6_NTOA:
case INET_ATON:
case INET_NTOA:
case INSTR:
case INTERIORRINGN:
case INTERSECTS:
case ISCLOSED:
case ISEMPTY:
case ISNULL:
case ISSIMPLE:
case IS_FREE_LOCK:
case IS_IPV4:
case IS_IPV4_COMPAT:
case IS_IPV4_MAPPED:
case IS_IPV6:
case IS_USED_LOCK:
case LAST_INSERT_ID:
case LCASE:
case LEAST:
case LENGTH:
case LINEFROMTEXT:
case LINEFROMWKB:
case LINESTRINGFROMTEXT:
case LINESTRINGFROMWKB:
case LN:
case LOAD_FILE:
case LOCATE:
case LOG:
case LOG10:
case LOG2:
case LOWER:
case LPAD:
case LTRIM:
case MAKEDATE:
case MAKETIME:
case MAKE_SET:
case MASTER_POS_WAIT:
case MBRCONTAINS:
case MBRDISJOINT:
case MBREQUAL:
case MBRINTERSECTS:
case MBROVERLAPS:
case MBRTOUCHES:
case MBRWITHIN:
case MD5:
case MLINEFROMTEXT:
case MLINEFROMWKB:
case MONTHNAME:
case MPOINTFROMTEXT:
case MPOINTFROMWKB:
case MPOLYFROMTEXT:
case MPOLYFROMWKB:
case MULTILINESTRINGFROMTEXT:
case MULTILINESTRINGFROMWKB:
case MULTIPOINTFROMTEXT:
case MULTIPOINTFROMWKB:
case MULTIPOLYGONFROMTEXT:
case MULTIPOLYGONFROMWKB:
case NAME_CONST:
case NULLIF:
case NUMGEOMETRIES:
case NUMINTERIORRINGS:
case NUMPOINTS:
case OCT:
case OCTET_LENGTH:
case ORD:
case OVERLAPS:
case PERIOD_ADD:
case PERIOD_DIFF:
case PI:
case POINTFROMTEXT:
case POINTFROMWKB:
case POINTN:
case POLYFROMTEXT:
case POLYFROMWKB:
case POLYGONFROMTEXT:
case POLYGONFROMWKB:
case POW:
case POWER:
case QUOTE:
case RADIANS:
case RAND:
case RANDOM:
case RANDOM_BYTES:
case RELEASE_LOCK:
case REVERSE:
case ROUND:
case ROW_COUNT:
case RPAD:
case RTRIM:
case SEC_TO_TIME:
case SECONDARY_ENGINE_ATTRIBUTE:
case SESSION_USER:
case SHA:
case SHA1:
case SHA2:
case SCHEMA_NAME:
case SIGN:
case SIN:
case SLEEP:
case SOUNDEX:
case SQL_THREAD_WAIT_AFTER_GTIDS:
case SQRT:
case SRID:
case STARTPOINT:
case STRCMP:
case STR_TO_DATE:
case ST_AREA:
case ST_ASBINARY:
case ST_ASTEXT:
case ST_ASWKB:
case ST_ASWKT:
case ST_BUFFER:
case ST_CENTROID:
case ST_CONTAINS:
case ST_CROSSES:
case ST_DIFFERENCE:
case ST_DIMENSION:
case ST_DISJOINT:
case ST_DISTANCE:
case ST_ENDPOINT:
case ST_ENVELOPE:
case ST_EQUALS:
case ST_EXTERIORRING:
case ST_GEOMCOLLFROMTEXT:
case ST_GEOMCOLLFROMTXT:
case ST_GEOMCOLLFROMWKB:
case ST_GEOMETRYCOLLECTIONFROMTEXT:
case ST_GEOMETRYCOLLECTIONFROMWKB:
case ST_GEOMETRYFROMTEXT:
case ST_GEOMETRYFROMWKB:
case ST_GEOMETRYN:
case ST_GEOMETRYTYPE:
case ST_GEOMFROMTEXT:
case ST_GEOMFROMWKB:
case ST_INTERIORRINGN:
case ST_INTERSECTION:
case ST_INTERSECTS:
case ST_ISCLOSED:
case ST_ISEMPTY:
case ST_ISSIMPLE:
case ST_LINEFROMTEXT:
case ST_LINEFROMWKB:
case ST_LINESTRINGFROMTEXT:
case ST_LINESTRINGFROMWKB:
case ST_NUMGEOMETRIES:
case ST_NUMINTERIORRING:
case ST_NUMINTERIORRINGS:
case ST_NUMPOINTS:
case ST_OVERLAPS:
case ST_POINTFROMTEXT:
case ST_POINTFROMWKB:
case ST_POINTN:
case ST_POLYFROMTEXT:
case ST_POLYFROMWKB:
case ST_POLYGONFROMTEXT:
case ST_POLYGONFROMWKB:
case ST_SRID:
case ST_STARTPOINT:
case ST_SYMDIFFERENCE:
case ST_TOUCHES:
case ST_UNION:
case ST_WITHIN:
case ST_X:
case ST_Y:
case SUBDATE:
case SUBSTRING_INDEX:
case SUBTIME:
case SYSTEM_USER:
case TAN:
case TIMEDIFF:
case TIMESTAMPADD:
case TIMESTAMPDIFF:
case TIME_FORMAT:
case TIME_TO_SEC:
case TOUCHES:
case TO_BASE64:
case TO_DAYS:
case TO_SECONDS:
case TP_CONNECTION_ADMIN:
case UCASE:
case UNCOMPRESS:
case UNCOMPRESSED_LENGTH:
case UNHEX:
case UNIX_TIMESTAMP:
case UPDATEXML:
case UPPER:
case UUID:
case UUID_SHORT:
case VALIDATE_PASSWORD_STRENGTH:
case VERSION:
case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS:
case WEEKDAY:
case WEEKOFYEAR:
case WEIGHT_STRING:
case WITHIN:
case YEARWEEK:
case Y_FUNCTION:
case X_FUNCTION:
case MOD:
case LR_BRACKET:
case CHARSET_REVERSE_QOUTE_STRING:
case STRING_LITERAL:
case ID:
{
setState(1090);
routineBody();
}
break;
case RETURN:
{
setState(1091);
returnStatement();
}
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 CreateRoleContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); }
public List roleName() {
return getRuleContexts(RoleNameContext.class);
}
public RoleNameContext roleName(int i) {
return getRuleContext(RoleNameContext.class,i);
}
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public CreateRoleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createRole; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateRole(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateRole(this);
else return visitor.visitChildren(this);
}
}
public final CreateRoleContext createRole() throws RecognitionException {
CreateRoleContext _localctx = new CreateRoleContext(_ctx, getState());
enterRule(_localctx, 36, RULE_createRole);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1094);
match(CREATE);
setState(1095);
match(ROLE);
setState(1097);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
{
setState(1096);
ifNotExists();
}
break;
}
setState(1099);
roleName();
setState(1104);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1100);
match(COMMA);
setState(1101);
roleName();
}
}
setState(1106);
_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 CreateServerContext extends ParserRuleContext {
public Token wrapperName;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); }
public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); }
public TerminalNode WRAPPER() { return getToken(MySqlParser.WRAPPER, 0); }
public TerminalNode OPTIONS() { return getToken(MySqlParser.OPTIONS, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List serverOption() {
return getRuleContexts(ServerOptionContext.class);
}
public ServerOptionContext serverOption(int i) {
return getRuleContext(ServerOptionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode MYSQL() { return getToken(MySqlParser.MYSQL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public CreateServerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createServer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateServer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateServer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateServer(this);
else return visitor.visitChildren(this);
}
}
public final CreateServerContext createServer() throws RecognitionException {
CreateServerContext _localctx = new CreateServerContext(_ctx, getState());
enterRule(_localctx, 38, RULE_createServer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1107);
match(CREATE);
setState(1108);
match(SERVER);
setState(1109);
uid();
setState(1110);
match(FOREIGN);
setState(1111);
match(DATA);
setState(1112);
match(WRAPPER);
setState(1113);
((CreateServerContext)_localctx).wrapperName = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==MYSQL || _la==STRING_LITERAL) ) {
((CreateServerContext)_localctx).wrapperName = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1114);
match(OPTIONS);
setState(1115);
match(LR_BRACKET);
setState(1116);
serverOption();
setState(1121);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1117);
match(COMMA);
setState(1118);
serverOption();
}
}
setState(1123);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1124);
match(RR_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTableContext extends ParserRuleContext {
public CreateTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTable; }
public CreateTableContext() { }
public void copyFrom(CreateTableContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CopyCreateTableContext extends CreateTableContext {
public TableNameContext parenthesisTable;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); }
public List tableName() {
return getRuleContexts(TableNameContext.class);
}
public TableNameContext tableName(int i) {
return getRuleContext(TableNameContext.class,i);
}
public TerminalNode LIKE() { return getToken(MySqlParser.LIKE, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); }
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public CopyCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCopyCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCopyCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCopyCreateTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnCreateTableContext extends CreateTableContext {
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); }
public TableNameContext tableName() {
return getRuleContext(TableNameContext.class,0);
}
public CreateDefinitionsContext createDefinitions() {
return getRuleContext(CreateDefinitionsContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); }
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public List tableOption() {
return getRuleContexts(TableOptionContext.class);
}
public TableOptionContext tableOption(int i) {
return getRuleContext(TableOptionContext.class,i);
}
public PartitionDefinitionsContext partitionDefinitions() {
return getRuleContext(PartitionDefinitionsContext.class,0);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public ColumnCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitColumnCreateTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QueryCreateTableContext extends CreateTableContext {
public Token keyViolate;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); }
public TableNameContext tableName() {
return getRuleContext(TableNameContext.class,0);
}
public SelectStatementContext selectStatement() {
return getRuleContext(SelectStatementContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); }
public IfNotExistsContext ifNotExists() {
return getRuleContext(IfNotExistsContext.class,0);
}
public CreateDefinitionsContext createDefinitions() {
return getRuleContext(CreateDefinitionsContext.class,0);
}
public List tableOption() {
return getRuleContexts(TableOptionContext.class);
}
public TableOptionContext tableOption(int i) {
return getRuleContext(TableOptionContext.class,i);
}
public PartitionDefinitionsContext partitionDefinitions() {
return getRuleContext(PartitionDefinitionsContext.class,0);
}
public TerminalNode AS() { return getToken(MySqlParser.AS, 0); }
public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); }
public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public QueryCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQueryCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQueryCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitQueryCreateTable(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableContext createTable() throws RecognitionException {
CreateTableContext _localctx = new CreateTableContext(_ctx, getState());
enterRule(_localctx, 40, RULE_createTable);
int _la;
try {
int _alt;
setState(1204);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
_localctx = new CopyCreateTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1126);
match(CREATE);
setState(1128);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(1127);
match(TEMPORARY);
}
}
setState(1130);
match(TABLE);
setState(1132);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
setState(1131);
ifNotExists();
}
break;
}
setState(1134);
tableName();
setState(1142);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIKE:
{
setState(1135);
match(LIKE);
setState(1136);
tableName();
}
break;
case LR_BRACKET:
{
setState(1137);
match(LR_BRACKET);
setState(1138);
match(LIKE);
setState(1139);
((CopyCreateTableContext)_localctx).parenthesisTable = tableName();
setState(1140);
match(RR_BRACKET);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
_localctx = new QueryCreateTableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1144);
match(CREATE);
setState(1146);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(1145);
match(TEMPORARY);
}
}
setState(1148);
match(TABLE);
setState(1150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(1149);
ifNotExists();
}
break;
}
setState(1152);
tableName();
setState(1154);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(1153);
createDefinitions();
}
break;
}
setState(1166);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 25)) & ~0x3f) == 0 && ((1L << (_la - 25)) & 72057594038059013L) != 0) || _la==UNION || _la==CHAR || ((((_la - 341)) & ~0x3f) == 0 && ((1L << (_la - 341)) & 4644375904747527L) != 0) || ((((_la - 405)) & ~0x3f) == 0 && ((1L << (_la - 405)) & 4612811918334230547L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 2366149022974977L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & 4609173815820289L) != 0) || _la==CHARSET || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE || _la==STRING_LITERAL) {
{
setState(1156);
tableOption();
setState(1163);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 25)) & ~0x3f) == 0 && ((1L << (_la - 25)) & 72057594038059013L) != 0) || _la==UNION || _la==CHAR || ((((_la - 341)) & ~0x3f) == 0 && ((1L << (_la - 341)) & 4644375904747527L) != 0) || ((((_la - 405)) & ~0x3f) == 0 && ((1L << (_la - 405)) & 4612811918334230547L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 2366149022974977L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & 4609173815820289L) != 0) || _la==CHARSET || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE || _la==COMMA || _la==STRING_LITERAL) {
{
{
setState(1158);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1157);
match(COMMA);
}
}
setState(1160);
tableOption();
}
}
setState(1165);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1168);
partitionDefinitions();
}
}
setState(1172);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IGNORE || _la==REPLACE) {
{
setState(1171);
((QueryCreateTableContext)_localctx).keyViolate = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==IGNORE || _la==REPLACE) ) {
((QueryCreateTableContext)_localctx).keyViolate = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1174);
match(AS);
}
}
setState(1177);
selectStatement();
}
break;
case 3:
_localctx = new ColumnCreateTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1179);
match(CREATE);
setState(1181);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(1180);
match(TEMPORARY);
}
}
setState(1183);
match(TABLE);
setState(1185);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
case 1:
{
setState(1184);
ifNotExists();
}
break;
}
setState(1187);
tableName();
setState(1188);
createDefinitions();
setState(1199);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
{
setState(1189);
tableOption();
setState(1196);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1191);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1190);
match(COMMA);
}
}
setState(1193);
tableOption();
}
}
}
setState(1198);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
}
}
break;
}
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1201);
partitionDefinitions();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTablespaceInnodbContext extends ParserRuleContext {
public Token datafile;
public FileSizeLiteralContext fileBlockSize;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); }
public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode FILE_BLOCK_SIZE() { return getToken(MySqlParser.FILE_BLOCK_SIZE, 0); }
public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); }
public TerminalNode EQUAL_SYMBOL(int i) {
return getToken(MySqlParser.EQUAL_SYMBOL, i);
}
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public FileSizeLiteralContext fileSizeLiteral() {
return getRuleContext(FileSizeLiteralContext.class,0);
}
public CreateTablespaceInnodbContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTablespaceInnodb; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTablespaceInnodb(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTablespaceInnodb(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateTablespaceInnodb(this);
else return visitor.visitChildren(this);
}
}
public final CreateTablespaceInnodbContext createTablespaceInnodb() throws RecognitionException {
CreateTablespaceInnodbContext _localctx = new CreateTablespaceInnodbContext(_ctx, getState());
enterRule(_localctx, 42, RULE_createTablespaceInnodb);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1206);
match(CREATE);
setState(1207);
match(TABLESPACE);
setState(1208);
uid();
setState(1209);
match(ADD);
setState(1210);
match(DATAFILE);
setState(1211);
((CreateTablespaceInnodbContext)_localctx).datafile = match(STRING_LITERAL);
setState(1215);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FILE_BLOCK_SIZE) {
{
setState(1212);
match(FILE_BLOCK_SIZE);
setState(1213);
match(EQUAL_SYMBOL);
setState(1214);
((CreateTablespaceInnodbContext)_localctx).fileBlockSize = fileSizeLiteral();
}
}
setState(1222);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENGINE) {
{
setState(1217);
match(ENGINE);
setState(1219);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1218);
match(EQUAL_SYMBOL);
}
}
setState(1221);
engineName();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTablespaceNdbContext extends ParserRuleContext {
public Token datafile;
public FileSizeLiteralContext extentSize;
public FileSizeLiteralContext initialSize;
public FileSizeLiteralContext autoextendSize;
public FileSizeLiteralContext maxSize;
public Token comment;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); }
public List uid() {
return getRuleContexts(UidContext.class);
}
public UidContext uid(int i) {
return getRuleContext(UidContext.class,i);
}
public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); }
public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); }
public TerminalNode USE() { return getToken(MySqlParser.USE, 0); }
public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); }
public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); }
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(MySqlParser.STRING_LITERAL, i);
}
public TerminalNode EXTENT_SIZE() { return getToken(MySqlParser.EXTENT_SIZE, 0); }
public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); }
public TerminalNode AUTOEXTEND_SIZE() { return getToken(MySqlParser.AUTOEXTEND_SIZE, 0); }
public TerminalNode MAX_SIZE() { return getToken(MySqlParser.MAX_SIZE, 0); }
public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); }
public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); }
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); }
public TerminalNode EQUAL_SYMBOL(int i) {
return getToken(MySqlParser.EQUAL_SYMBOL, i);
}
public List fileSizeLiteral() {
return getRuleContexts(FileSizeLiteralContext.class);
}
public FileSizeLiteralContext fileSizeLiteral(int i) {
return getRuleContext(FileSizeLiteralContext.class,i);
}
public CreateTablespaceNdbContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTablespaceNdb; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTablespaceNdb(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTablespaceNdb(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateTablespaceNdb(this);
else return visitor.visitChildren(this);
}
}
public final CreateTablespaceNdbContext createTablespaceNdb() throws RecognitionException {
CreateTablespaceNdbContext _localctx = new CreateTablespaceNdbContext(_ctx, getState());
enterRule(_localctx, 44, RULE_createTablespaceNdb);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1224);
match(CREATE);
setState(1225);
match(TABLESPACE);
setState(1226);
uid();
setState(1227);
match(ADD);
setState(1228);
match(DATAFILE);
setState(1229);
((CreateTablespaceNdbContext)_localctx).datafile = match(STRING_LITERAL);
setState(1230);
match(USE);
setState(1231);
match(LOGFILE);
setState(1232);
match(GROUP);
setState(1233);
uid();
setState(1239);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENT_SIZE) {
{
setState(1234);
match(EXTENT_SIZE);
setState(1236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1235);
match(EQUAL_SYMBOL);
}
}
setState(1238);
((CreateTablespaceNdbContext)_localctx).extentSize = fileSizeLiteral();
}
}
setState(1246);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIAL_SIZE) {
{
setState(1241);
match(INITIAL_SIZE);
setState(1243);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1242);
match(EQUAL_SYMBOL);
}
}
setState(1245);
((CreateTablespaceNdbContext)_localctx).initialSize = fileSizeLiteral();
}
}
setState(1253);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AUTOEXTEND_SIZE) {
{
setState(1248);
match(AUTOEXTEND_SIZE);
setState(1250);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1249);
match(EQUAL_SYMBOL);
}
}
setState(1252);
((CreateTablespaceNdbContext)_localctx).autoextendSize = fileSizeLiteral();
}
}
setState(1260);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MAX_SIZE) {
{
setState(1255);
match(MAX_SIZE);
setState(1257);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1256);
match(EQUAL_SYMBOL);
}
}
setState(1259);
((CreateTablespaceNdbContext)_localctx).maxSize = fileSizeLiteral();
}
}
setState(1267);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NODEGROUP) {
{
setState(1262);
match(NODEGROUP);
setState(1264);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1263);
match(EQUAL_SYMBOL);
}
}
setState(1266);
uid();
}
}
setState(1270);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WAIT) {
{
setState(1269);
match(WAIT);
}
}
setState(1277);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(1272);
match(COMMENT);
setState(1274);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1273);
match(EQUAL_SYMBOL);
}
}
setState(1276);
((CreateTablespaceNdbContext)_localctx).comment = match(STRING_LITERAL);
}
}
setState(1279);
match(ENGINE);
setState(1281);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1280);
match(EQUAL_SYMBOL);
}
}
setState(1283);
engineName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateTriggerContext extends ParserRuleContext {
public FullIdContext thisTrigger;
public Token triggerTime;
public Token triggerEvent;
public Token triggerPlace;
public FullIdContext otherTrigger;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode TRIGGER() { return getToken(MySqlParser.TRIGGER, 0); }
public TerminalNode ON() { return getToken(MySqlParser.ON, 0); }
public TableNameContext tableName() {
return getRuleContext(TableNameContext.class,0);
}
public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); }
public TerminalNode EACH() { return getToken(MySqlParser.EACH, 0); }
public TerminalNode ROW() { return getToken(MySqlParser.ROW, 0); }
public RoutineBodyContext routineBody() {
return getRuleContext(RoutineBodyContext.class,0);
}
public List fullId() {
return getRuleContexts(FullIdContext.class);
}
public FullIdContext fullId(int i) {
return getRuleContext(FullIdContext.class,i);
}
public TerminalNode BEFORE() { return getToken(MySqlParser.BEFORE, 0); }
public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); }
public TerminalNode INSERT() { return getToken(MySqlParser.INSERT, 0); }
public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); }
public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); }
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public TerminalNode FOLLOWS() { return getToken(MySqlParser.FOLLOWS, 0); }
public TerminalNode PRECEDES() { return getToken(MySqlParser.PRECEDES, 0); }
public CreateTriggerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTrigger; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTrigger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTrigger(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateTrigger(this);
else return visitor.visitChildren(this);
}
}
public final CreateTriggerContext createTrigger() throws RecognitionException {
CreateTriggerContext _localctx = new CreateTriggerContext(_ctx, getState());
enterRule(_localctx, 46, RULE_createTrigger);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1285);
match(CREATE);
setState(1287);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(1286);
ownerStatement();
}
}
setState(1289);
match(TRIGGER);
setState(1290);
((CreateTriggerContext)_localctx).thisTrigger = fullId();
setState(1291);
((CreateTriggerContext)_localctx).triggerTime = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BEFORE || _la==AFTER) ) {
((CreateTriggerContext)_localctx).triggerTime = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1292);
((CreateTriggerContext)_localctx).triggerEvent = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DELETE || _la==INSERT || _la==UPDATE) ) {
((CreateTriggerContext)_localctx).triggerEvent = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1293);
match(ON);
setState(1294);
tableName();
setState(1295);
match(FOR);
setState(1296);
match(EACH);
setState(1297);
match(ROW);
setState(1300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(1298);
((CreateTriggerContext)_localctx).triggerPlace = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FOLLOWS || _la==PRECEDES) ) {
((CreateTriggerContext)_localctx).triggerPlace = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1299);
((CreateTriggerContext)_localctx).otherTrigger = fullId();
}
break;
}
setState(1302);
routineBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithClauseContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); }
public CommonTableExpressionsContext commonTableExpressions() {
return getRuleContext(CommonTableExpressionsContext.class,0);
}
public TerminalNode RECURSIVE() { return getToken(MySqlParser.RECURSIVE, 0); }
public WithClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWithClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWithClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitWithClause(this);
else return visitor.visitChildren(this);
}
}
public final WithClauseContext withClause() throws RecognitionException {
WithClauseContext _localctx = new WithClauseContext(_ctx, getState());
enterRule(_localctx, 48, RULE_withClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1304);
match(WITH);
setState(1306);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1305);
match(RECURSIVE);
}
break;
}
setState(1308);
commonTableExpressions();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommonTableExpressionsContext extends ParserRuleContext {
public CteNameContext cteName() {
return getRuleContext(CteNameContext.class,0);
}
public TerminalNode AS() { return getToken(MySqlParser.AS, 0); }
public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(MySqlParser.LR_BRACKET, i);
}
public DmlStatementContext dmlStatement() {
return getRuleContext(DmlStatementContext.class,0);
}
public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(MySqlParser.RR_BRACKET, i);
}
public List cteColumnName() {
return getRuleContexts(CteColumnNameContext.class);
}
public CteColumnNameContext cteColumnName(int i) {
return getRuleContext(CteColumnNameContext.class,i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public CommonTableExpressionsContext commonTableExpressions() {
return getRuleContext(CommonTableExpressionsContext.class,0);
}
public CommonTableExpressionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commonTableExpressions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCommonTableExpressions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCommonTableExpressions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCommonTableExpressions(this);
else return visitor.visitChildren(this);
}
}
public final CommonTableExpressionsContext commonTableExpressions() throws RecognitionException {
CommonTableExpressionsContext _localctx = new CommonTableExpressionsContext(_ctx, getState());
enterRule(_localctx, 50, RULE_commonTableExpressions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1310);
cteName();
setState(1322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(1311);
match(LR_BRACKET);
setState(1312);
cteColumnName();
setState(1317);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1313);
match(COMMA);
setState(1314);
cteColumnName();
}
}
setState(1319);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1320);
match(RR_BRACKET);
}
}
setState(1324);
match(AS);
setState(1325);
match(LR_BRACKET);
setState(1326);
dmlStatement();
setState(1327);
match(RR_BRACKET);
setState(1330);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(1328);
match(COMMA);
setState(1329);
commonTableExpressions();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CteNameContext extends ParserRuleContext {
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public CteNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cteName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCteName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCteName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCteName(this);
else return visitor.visitChildren(this);
}
}
public final CteNameContext cteName() throws RecognitionException {
CteNameContext _localctx = new CteNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_cteName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1332);
uid();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CteColumnNameContext extends ParserRuleContext {
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public CteColumnNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cteColumnName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCteColumnName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCteColumnName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCteColumnName(this);
else return visitor.visitChildren(this);
}
}
public final CteColumnNameContext cteColumnName() throws RecognitionException {
CteColumnNameContext _localctx = new CteColumnNameContext(_ctx, getState());
enterRule(_localctx, 54, RULE_cteColumnName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1334);
uid();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateViewContext extends ParserRuleContext {
public Token algType;
public Token secContext;
public Token checkOption;
public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); }
public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public TerminalNode AS() { return getToken(MySqlParser.AS, 0); }
public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(MySqlParser.LR_BRACKET, i);
}
public SelectStatementContext selectStatement() {
return getRuleContext(SelectStatementContext.class,0);
}
public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(MySqlParser.RR_BRACKET, i);
}
public OrReplaceContext orReplace() {
return getRuleContext(OrReplaceContext.class,0);
}
public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); }
public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); }
public UidListContext uidList() {
return getRuleContext(UidListContext.class,0);
}
public TerminalNode UNDEFINED() { return getToken(MySqlParser.UNDEFINED, 0); }
public TerminalNode MERGE() { return getToken(MySqlParser.MERGE, 0); }
public TerminalNode TEMPTABLE() { return getToken(MySqlParser.TEMPTABLE, 0); }
public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); }
public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); }
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); }
public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); }
public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); }
public TerminalNode CASCADED() { return getToken(MySqlParser.CASCADED, 0); }
public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); }
public CreateViewContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createView; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateView(this);
else return visitor.visitChildren(this);
}
}
public final CreateViewContext createView() throws RecognitionException {
CreateViewContext _localctx = new CreateViewContext(_ctx, getState());
enterRule(_localctx, 56, RULE_createView);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1336);
match(CREATE);
setState(1338);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1337);
orReplace();
}
}
setState(1343);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALGORITHM) {
{
setState(1340);
match(ALGORITHM);
setState(1341);
match(EQUAL_SYMBOL);
setState(1342);
((CreateViewContext)_localctx).algType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==MERGE || _la==TEMPTABLE || _la==UNDEFINED) ) {
((CreateViewContext)_localctx).algType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(1345);
ownerStatement();
}
}
setState(1351);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SQL) {
{
setState(1348);
match(SQL);
setState(1349);
match(SECURITY);
setState(1350);
((CreateViewContext)_localctx).secContext = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFINER || _la==INVOKER) ) {
((CreateViewContext)_localctx).secContext = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1353);
match(VIEW);
setState(1354);
fullId();
setState(1359);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(1355);
match(LR_BRACKET);
setState(1356);
uidList();
setState(1357);
match(RR_BRACKET);
}
}
setState(1361);
match(AS);
setState(1381);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(1362);
match(LR_BRACKET);
setState(1364);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1363);
withClause();
}
}
setState(1366);
selectStatement();
setState(1367);
match(RR_BRACKET);
}
break;
case 2:
{
setState(1370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1369);
withClause();
}
}
setState(1372);
selectStatement();
setState(1379);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
setState(1373);
match(WITH);
setState(1375);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CASCADED || _la==LOCAL) {
{
setState(1374);
((CreateViewContext)_localctx).checkOption = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==CASCADED || _la==LOCAL) ) {
((CreateViewContext)_localctx).checkOption = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1377);
match(CHECK);
setState(1378);
match(OPTION);
}
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 CreateDatabaseOptionContext extends ParserRuleContext {
public CharSetContext charSet() {
return getRuleContext(CharSetContext.class,0);
}
public CharsetNameContext charsetName() {
return getRuleContext(CharsetNameContext.class,0);
}
public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); }
public TerminalNode DEFAULT(int i) {
return getToken(MySqlParser.DEFAULT, i);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); }
public CollationNameContext collationName() {
return getRuleContext(CollationNameContext.class,0);
}
public TerminalNode ENCRYPTION() { return getToken(MySqlParser.ENCRYPTION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode READ() { return getToken(MySqlParser.READ, 0); }
public TerminalNode ONLY() { return getToken(MySqlParser.ONLY, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public CreateDatabaseOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createDatabaseOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDatabaseOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDatabaseOption(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateDatabaseOption(this);
else return visitor.visitChildren(this);
}
}
public final CreateDatabaseOptionContext createDatabaseOption() throws RecognitionException {
CreateDatabaseOptionContext _localctx = new CreateDatabaseOptionContext(_ctx, getState());
enterRule(_localctx, 58, RULE_createDatabaseOption);
int _la;
try {
setState(1416);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1384);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1383);
match(DEFAULT);
}
}
setState(1386);
charSet();
setState(1388);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1387);
match(EQUAL_SYMBOL);
}
}
setState(1392);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BINARY:
case ARMSCII8:
case ASCII:
case BIG5:
case CP1250:
case CP1251:
case CP1256:
case CP1257:
case CP850:
case CP852:
case CP866:
case CP932:
case DEC8:
case EUCJPMS:
case EUCKR:
case GB18030:
case GB2312:
case GBK:
case GEOSTD8:
case GREEK:
case HEBREW:
case HP8:
case KEYBCS2:
case KOI8R:
case KOI8U:
case LATIN1:
case LATIN2:
case LATIN5:
case LATIN7:
case MACCE:
case MACROMAN:
case SJIS:
case SWE7:
case TIS620:
case UCS2:
case UJIS:
case UTF16:
case UTF16LE:
case UTF32:
case UTF8:
case UTF8MB3:
case UTF8MB4:
case CHARSET_REVERSE_QOUTE_STRING:
case STRING_LITERAL:
{
setState(1390);
charsetName();
}
break;
case DEFAULT:
{
setState(1391);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1394);
match(DEFAULT);
}
}
setState(1397);
match(COLLATE);
setState(1399);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1398);
match(EQUAL_SYMBOL);
}
}
setState(1401);
collationName();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1403);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1402);
match(DEFAULT);
}
}
setState(1405);
match(ENCRYPTION);
setState(1407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1406);
match(EQUAL_SYMBOL);
}
}
setState(1409);
match(STRING_LITERAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1410);
match(READ);
setState(1411);
match(ONLY);
setState(1413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1412);
match(EQUAL_SYMBOL);
}
}
setState(1415);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
_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 CharSetContext extends ParserRuleContext {
public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); }
public TerminalNode SET() { return getToken(MySqlParser.SET, 0); }
public TerminalNode CHARSET() { return getToken(MySqlParser.CHARSET, 0); }
public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); }
public CharSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_charSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCharSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCharSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCharSet(this);
else return visitor.visitChildren(this);
}
}
public final CharSetContext charSet() throws RecognitionException {
CharSetContext _localctx = new CharSetContext(_ctx, getState());
enterRule(_localctx, 60, RULE_charSet);
try {
setState(1423);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHARACTER:
enterOuterAlt(_localctx, 1);
{
setState(1418);
match(CHARACTER);
setState(1419);
match(SET);
}
break;
case CHARSET:
enterOuterAlt(_localctx, 2);
{
setState(1420);
match(CHARSET);
}
break;
case CHAR:
enterOuterAlt(_localctx, 3);
{
setState(1421);
match(CHAR);
setState(1422);
match(SET);
}
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 CurrentUserExpressionContext extends ParserRuleContext {
public TerminalNode CURRENT_USER() { return getToken(MySqlParser.CURRENT_USER, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public CurrentUserExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_currentUserExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCurrentUserExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCurrentUserExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCurrentUserExpression(this);
else return visitor.visitChildren(this);
}
}
public final CurrentUserExpressionContext currentUserExpression() throws RecognitionException {
CurrentUserExpressionContext _localctx = new CurrentUserExpressionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_currentUserExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1425);
match(CURRENT_USER);
setState(1428);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1426);
match(LR_BRACKET);
setState(1427);
match(RR_BRACKET);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OwnerStatementContext extends ParserRuleContext {
public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public UserNameContext userName() {
return getRuleContext(UserNameContext.class,0);
}
public CurrentUserExpressionContext currentUserExpression() {
return getRuleContext(CurrentUserExpressionContext.class,0);
}
public OwnerStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ownerStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOwnerStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOwnerStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitOwnerStatement(this);
else return visitor.visitChildren(this);
}
}
public final OwnerStatementContext ownerStatement() throws RecognitionException {
OwnerStatementContext _localctx = new OwnerStatementContext(_ctx, getState());
enterRule(_localctx, 64, RULE_ownerStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1430);
match(DEFINER);
setState(1431);
match(EQUAL_SYMBOL);
setState(1434);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1432);
userName();
}
break;
case 2:
{
setState(1433);
currentUserExpression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ScheduleExpressionContext extends ParserRuleContext {
public ScheduleExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scheduleExpression; }
public ScheduleExpressionContext() { }
public void copyFrom(ScheduleExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PreciseScheduleContext extends ScheduleExpressionContext {
public TerminalNode AT() { return getToken(MySqlParser.AT, 0); }
public TimestampValueContext timestampValue() {
return getRuleContext(TimestampValueContext.class,0);
}
public List intervalExpr() {
return getRuleContexts(IntervalExprContext.class);
}
public IntervalExprContext intervalExpr(int i) {
return getRuleContext(IntervalExprContext.class,i);
}
public PreciseScheduleContext(ScheduleExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPreciseSchedule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPreciseSchedule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPreciseSchedule(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalScheduleContext extends ScheduleExpressionContext {
public TimestampValueContext startTimestamp;
public IntervalExprContext intervalExpr;
public List startIntervals = new ArrayList();
public TimestampValueContext endTimestamp;
public List endIntervals = new ArrayList();
public TerminalNode EVERY() { return getToken(MySqlParser.EVERY, 0); }
public IntervalTypeContext intervalType() {
return getRuleContext(IntervalTypeContext.class,0);
}
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode STARTS() { return getToken(MySqlParser.STARTS, 0); }
public TerminalNode ENDS() { return getToken(MySqlParser.ENDS, 0); }
public List timestampValue() {
return getRuleContexts(TimestampValueContext.class);
}
public TimestampValueContext timestampValue(int i) {
return getRuleContext(TimestampValueContext.class,i);
}
public List intervalExpr() {
return getRuleContexts(IntervalExprContext.class);
}
public IntervalExprContext intervalExpr(int i) {
return getRuleContext(IntervalExprContext.class,i);
}
public IntervalScheduleContext(ScheduleExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalSchedule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalSchedule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIntervalSchedule(this);
else return visitor.visitChildren(this);
}
}
public final ScheduleExpressionContext scheduleExpression() throws RecognitionException {
ScheduleExpressionContext _localctx = new ScheduleExpressionContext(_ctx, getState());
enterRule(_localctx, 66, RULE_scheduleExpression);
int _la;
try {
setState(1470);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
_localctx = new PreciseScheduleContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1436);
match(AT);
setState(1437);
timestampValue();
setState(1441);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PLUS) {
{
{
setState(1438);
intervalExpr();
}
}
setState(1443);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case EVERY:
_localctx = new IntervalScheduleContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1444);
match(EVERY);
setState(1447);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1445);
decimalLiteral();
}
break;
case 2:
{
setState(1446);
expression(0);
}
break;
}
setState(1449);
intervalType();
setState(1458);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STARTS) {
{
setState(1450);
match(STARTS);
setState(1451);
((IntervalScheduleContext)_localctx).startTimestamp = timestampValue();
setState(1455);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PLUS) {
{
{
setState(1452);
((IntervalScheduleContext)_localctx).intervalExpr = intervalExpr();
((IntervalScheduleContext)_localctx).startIntervals.add(((IntervalScheduleContext)_localctx).intervalExpr);
}
}
setState(1457);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1468);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENDS) {
{
setState(1460);
match(ENDS);
setState(1461);
((IntervalScheduleContext)_localctx).endTimestamp = timestampValue();
setState(1465);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PLUS) {
{
{
setState(1462);
((IntervalScheduleContext)_localctx).intervalExpr = intervalExpr();
((IntervalScheduleContext)_localctx).endIntervals.add(((IntervalScheduleContext)_localctx).intervalExpr);
}
}
setState(1467);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
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 TimestampValueContext extends ParserRuleContext {
public TerminalNode CURRENT_TIMESTAMP() { return getToken(MySqlParser.CURRENT_TIMESTAMP, 0); }
public StringLiteralContext stringLiteral() {
return getRuleContext(StringLiteralContext.class,0);
}
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TimestampValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timestampValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTimestampValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTimestampValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTimestampValue(this);
else return visitor.visitChildren(this);
}
}
public final TimestampValueContext timestampValue() throws RecognitionException {
TimestampValueContext _localctx = new TimestampValueContext(_ctx, getState());
enterRule(_localctx, 68, RULE_timestampValue);
try {
setState(1476);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1472);
match(CURRENT_TIMESTAMP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1473);
stringLiteral();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1474);
decimalLiteral();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1475);
expression(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 IntervalExprContext extends ParserRuleContext {
public TerminalNode PLUS() { return getToken(MySqlParser.PLUS, 0); }
public TerminalNode INTERVAL() { return getToken(MySqlParser.INTERVAL, 0); }
public IntervalTypeContext intervalType() {
return getRuleContext(IntervalTypeContext.class,0);
}
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IntervalExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intervalExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIntervalExpr(this);
else return visitor.visitChildren(this);
}
}
public final IntervalExprContext intervalExpr() throws RecognitionException {
IntervalExprContext _localctx = new IntervalExprContext(_ctx, getState());
enterRule(_localctx, 70, RULE_intervalExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1478);
match(PLUS);
setState(1479);
match(INTERVAL);
setState(1482);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(1480);
decimalLiteral();
}
break;
case 2:
{
setState(1481);
expression(0);
}
break;
}
setState(1484);
intervalType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalTypeContext extends ParserRuleContext {
public IntervalTypeBaseContext intervalTypeBase() {
return getRuleContext(IntervalTypeBaseContext.class,0);
}
public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); }
public TerminalNode YEAR_MONTH() { return getToken(MySqlParser.YEAR_MONTH, 0); }
public TerminalNode DAY_HOUR() { return getToken(MySqlParser.DAY_HOUR, 0); }
public TerminalNode DAY_MINUTE() { return getToken(MySqlParser.DAY_MINUTE, 0); }
public TerminalNode DAY_SECOND() { return getToken(MySqlParser.DAY_SECOND, 0); }
public TerminalNode HOUR_MINUTE() { return getToken(MySqlParser.HOUR_MINUTE, 0); }
public TerminalNode HOUR_SECOND() { return getToken(MySqlParser.HOUR_SECOND, 0); }
public TerminalNode MINUTE_SECOND() { return getToken(MySqlParser.MINUTE_SECOND, 0); }
public TerminalNode SECOND_MICROSECOND() { return getToken(MySqlParser.SECOND_MICROSECOND, 0); }
public TerminalNode MINUTE_MICROSECOND() { return getToken(MySqlParser.MINUTE_MICROSECOND, 0); }
public TerminalNode HOUR_MICROSECOND() { return getToken(MySqlParser.HOUR_MICROSECOND, 0); }
public TerminalNode DAY_MICROSECOND() { return getToken(MySqlParser.DAY_MICROSECOND, 0); }
public IntervalTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intervalType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIntervalType(this);
else return visitor.visitChildren(this);
}
}
public final IntervalTypeContext intervalType() throws RecognitionException {
IntervalTypeContext _localctx = new IntervalTypeContext(_ctx, getState());
enterRule(_localctx, 72, RULE_intervalType);
try {
setState(1499);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUARTER:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case WEEK:
case SECOND:
case MICROSECOND:
enterOuterAlt(_localctx, 1);
{
setState(1486);
intervalTypeBase();
}
break;
case YEAR:
enterOuterAlt(_localctx, 2);
{
setState(1487);
match(YEAR);
}
break;
case YEAR_MONTH:
enterOuterAlt(_localctx, 3);
{
setState(1488);
match(YEAR_MONTH);
}
break;
case DAY_HOUR:
enterOuterAlt(_localctx, 4);
{
setState(1489);
match(DAY_HOUR);
}
break;
case DAY_MINUTE:
enterOuterAlt(_localctx, 5);
{
setState(1490);
match(DAY_MINUTE);
}
break;
case DAY_SECOND:
enterOuterAlt(_localctx, 6);
{
setState(1491);
match(DAY_SECOND);
}
break;
case HOUR_MINUTE:
enterOuterAlt(_localctx, 7);
{
setState(1492);
match(HOUR_MINUTE);
}
break;
case HOUR_SECOND:
enterOuterAlt(_localctx, 8);
{
setState(1493);
match(HOUR_SECOND);
}
break;
case MINUTE_SECOND:
enterOuterAlt(_localctx, 9);
{
setState(1494);
match(MINUTE_SECOND);
}
break;
case SECOND_MICROSECOND:
enterOuterAlt(_localctx, 10);
{
setState(1495);
match(SECOND_MICROSECOND);
}
break;
case MINUTE_MICROSECOND:
enterOuterAlt(_localctx, 11);
{
setState(1496);
match(MINUTE_MICROSECOND);
}
break;
case HOUR_MICROSECOND:
enterOuterAlt(_localctx, 12);
{
setState(1497);
match(HOUR_MICROSECOND);
}
break;
case DAY_MICROSECOND:
enterOuterAlt(_localctx, 13);
{
setState(1498);
match(DAY_MICROSECOND);
}
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 EnableTypeContext extends ParserRuleContext {
public TerminalNode ENABLE() { return getToken(MySqlParser.ENABLE, 0); }
public TerminalNode DISABLE() { return getToken(MySqlParser.DISABLE, 0); }
public TerminalNode ON() { return getToken(MySqlParser.ON, 0); }
public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); }
public EnableTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enableType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEnableType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEnableType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitEnableType(this);
else return visitor.visitChildren(this);
}
}
public final EnableTypeContext enableType() throws RecognitionException {
EnableTypeContext _localctx = new EnableTypeContext(_ctx, getState());
enterRule(_localctx, 74, RULE_enableType);
try {
setState(1506);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1501);
match(ENABLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1502);
match(DISABLE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1503);
match(DISABLE);
setState(1504);
match(ON);
setState(1505);
match(SLAVE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IndexTypeContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(MySqlParser.USING, 0); }
public TerminalNode BTREE() { return getToken(MySqlParser.BTREE, 0); }
public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); }
public IndexTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIndexType(this);
else return visitor.visitChildren(this);
}
}
public final IndexTypeContext indexType() throws RecognitionException {
IndexTypeContext _localctx = new IndexTypeContext(_ctx, getState());
enterRule(_localctx, 76, RULE_indexType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1508);
match(USING);
setState(1509);
_la = _input.LA(1);
if ( !(_la==BTREE || _la==HASH) ) {
_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 IndexOptionContext extends ParserRuleContext {
public TerminalNode KEY_BLOCK_SIZE() { return getToken(MySqlParser.KEY_BLOCK_SIZE, 0); }
public FileSizeLiteralContext fileSizeLiteral() {
return getRuleContext(FileSizeLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); }
public TerminalNode PARSER() { return getToken(MySqlParser.PARSER, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); }
public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); }
public TerminalNode ENGINE_ATTRIBUTE() { return getToken(MySqlParser.ENGINE_ATTRIBUTE, 0); }
public TerminalNode SECONDARY_ENGINE_ATTRIBUTE() { return getToken(MySqlParser.SECONDARY_ENGINE_ATTRIBUTE, 0); }
public IndexOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexOption(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIndexOption(this);
else return visitor.visitChildren(this);
}
}
public final IndexOptionContext indexOption() throws RecognitionException {
IndexOptionContext _localctx = new IndexOptionContext(_ctx, getState());
enterRule(_localctx, 78, RULE_indexOption);
int _la;
try {
setState(1533);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KEY_BLOCK_SIZE:
enterOuterAlt(_localctx, 1);
{
setState(1511);
match(KEY_BLOCK_SIZE);
setState(1513);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1512);
match(EQUAL_SYMBOL);
}
}
setState(1515);
fileSizeLiteral();
}
break;
case USING:
enterOuterAlt(_localctx, 2);
{
setState(1516);
indexType();
}
break;
case WITH:
enterOuterAlt(_localctx, 3);
{
setState(1517);
match(WITH);
setState(1518);
match(PARSER);
setState(1519);
uid();
}
break;
case COMMENT:
enterOuterAlt(_localctx, 4);
{
setState(1520);
match(COMMENT);
setState(1521);
match(STRING_LITERAL);
}
break;
case INVISIBLE:
case VISIBLE:
enterOuterAlt(_localctx, 5);
{
setState(1522);
_la = _input.LA(1);
if ( !(_la==INVISIBLE || _la==VISIBLE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case ENGINE_ATTRIBUTE:
enterOuterAlt(_localctx, 6);
{
setState(1523);
match(ENGINE_ATTRIBUTE);
setState(1525);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1524);
match(EQUAL_SYMBOL);
}
}
setState(1527);
match(STRING_LITERAL);
}
break;
case SECONDARY_ENGINE_ATTRIBUTE:
enterOuterAlt(_localctx, 7);
{
setState(1528);
match(SECONDARY_ENGINE_ATTRIBUTE);
setState(1530);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1529);
match(EQUAL_SYMBOL);
}
}
setState(1532);
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 ProcedureParameterContext extends ParserRuleContext {
public Token direction;
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public TerminalNode IN() { return getToken(MySqlParser.IN, 0); }
public TerminalNode OUT() { return getToken(MySqlParser.OUT, 0); }
public TerminalNode INOUT() { return getToken(MySqlParser.INOUT, 0); }
public ProcedureParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_procedureParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterProcedureParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitProcedureParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitProcedureParameter(this);
else return visitor.visitChildren(this);
}
}
public final ProcedureParameterContext procedureParameter() throws RecognitionException {
ProcedureParameterContext _localctx = new ProcedureParameterContext(_ctx, getState());
enterRule(_localctx, 80, RULE_procedureParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1536);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & 35184372088849L) != 0)) {
{
setState(1535);
((ProcedureParameterContext)_localctx).direction = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & 35184372088849L) != 0)) ) {
((ProcedureParameterContext)_localctx).direction = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1538);
uid();
setState(1539);
dataType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionParameterContext extends ParserRuleContext {
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public FunctionParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitFunctionParameter(this);
else return visitor.visitChildren(this);
}
}
public final FunctionParameterContext functionParameter() throws RecognitionException {
FunctionParameterContext _localctx = new FunctionParameterContext(_ctx, getState());
enterRule(_localctx, 82, RULE_functionParameter);
try {
enterOuterAlt(_localctx, 1);
{
setState(1541);
uid();
setState(1542);
dataType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineOptionContext extends ParserRuleContext {
public RoutineOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routineOption; }
public RoutineOptionContext() { }
public void copyFrom(RoutineOptionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineBehaviorContext extends RoutineOptionContext {
public TerminalNode DETERMINISTIC() { return getToken(MySqlParser.DETERMINISTIC, 0); }
public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); }
public RoutineBehaviorContext(RoutineOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoutineBehavior(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineLanguageContext extends RoutineOptionContext {
public TerminalNode LANGUAGE() { return getToken(MySqlParser.LANGUAGE, 0); }
public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); }
public RoutineLanguageContext(RoutineOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineLanguage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineLanguage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoutineLanguage(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineCommentContext extends RoutineOptionContext {
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public RoutineCommentContext(RoutineOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoutineComment(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineSecurityContext extends RoutineOptionContext {
public Token context;
public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); }
public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); }
public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); }
public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); }
public RoutineSecurityContext(RoutineOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineSecurity(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineSecurity(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoutineSecurity(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RoutineDataContext extends RoutineOptionContext {
public TerminalNode CONTAINS() { return getToken(MySqlParser.CONTAINS, 0); }
public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); }
public TerminalNode NO() { return getToken(MySqlParser.NO, 0); }
public TerminalNode READS() { return getToken(MySqlParser.READS, 0); }
public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); }
public TerminalNode MODIFIES() { return getToken(MySqlParser.MODIFIES, 0); }
public RoutineDataContext(RoutineOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitRoutineData(this);
else return visitor.visitChildren(this);
}
}
public final RoutineOptionContext routineOption() throws RecognitionException {
RoutineOptionContext _localctx = new RoutineOptionContext(_ctx, getState());
enterRule(_localctx, 84, RULE_routineOption);
int _la;
try {
setState(1567);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
_localctx = new RoutineCommentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1544);
match(COMMENT);
setState(1545);
match(STRING_LITERAL);
}
break;
case LANGUAGE:
_localctx = new RoutineLanguageContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1546);
match(LANGUAGE);
setState(1547);
match(SQL);
}
break;
case DETERMINISTIC:
case NOT:
_localctx = new RoutineBehaviorContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1549);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1548);
match(NOT);
}
}
setState(1551);
match(DETERMINISTIC);
}
break;
case MODIFIES:
case READS:
case CONTAINS:
case NO:
_localctx = new RoutineDataContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1562);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CONTAINS:
{
setState(1552);
match(CONTAINS);
setState(1553);
match(SQL);
}
break;
case NO:
{
setState(1554);
match(NO);
setState(1555);
match(SQL);
}
break;
case READS:
{
setState(1556);
match(READS);
setState(1557);
match(SQL);
setState(1558);
match(DATA);
}
break;
case MODIFIES:
{
setState(1559);
match(MODIFIES);
setState(1560);
match(SQL);
setState(1561);
match(DATA);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case SQL:
_localctx = new RoutineSecurityContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1564);
match(SQL);
setState(1565);
match(SECURITY);
setState(1566);
((RoutineSecurityContext)_localctx).context = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFINER || _la==INVOKER) ) {
((RoutineSecurityContext)_localctx).context = (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 ServerOptionContext extends ParserRuleContext {
public TerminalNode HOST() { return getToken(MySqlParser.HOST, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); }
public TerminalNode USER() { return getToken(MySqlParser.USER, 0); }
public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); }
public TerminalNode SOCKET() { return getToken(MySqlParser.SOCKET, 0); }
public TerminalNode OWNER() { return getToken(MySqlParser.OWNER, 0); }
public TerminalNode PORT() { return getToken(MySqlParser.PORT, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public ServerOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serverOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterServerOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitServerOption(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitServerOption(this);
else return visitor.visitChildren(this);
}
}
public final ServerOptionContext serverOption() throws RecognitionException {
ServerOptionContext _localctx = new ServerOptionContext(_ctx, getState());
enterRule(_localctx, 86, RULE_serverOption);
try {
setState(1583);
_errHandler.sync(this);
switch (_input.LA(1)) {
case HOST:
enterOuterAlt(_localctx, 1);
{
setState(1569);
match(HOST);
setState(1570);
match(STRING_LITERAL);
}
break;
case DATABASE:
enterOuterAlt(_localctx, 2);
{
setState(1571);
match(DATABASE);
setState(1572);
match(STRING_LITERAL);
}
break;
case USER:
enterOuterAlt(_localctx, 3);
{
setState(1573);
match(USER);
setState(1574);
match(STRING_LITERAL);
}
break;
case PASSWORD:
enterOuterAlt(_localctx, 4);
{
setState(1575);
match(PASSWORD);
setState(1576);
match(STRING_LITERAL);
}
break;
case SOCKET:
enterOuterAlt(_localctx, 5);
{
setState(1577);
match(SOCKET);
setState(1578);
match(STRING_LITERAL);
}
break;
case OWNER:
enterOuterAlt(_localctx, 6);
{
setState(1579);
match(OWNER);
setState(1580);
match(STRING_LITERAL);
}
break;
case PORT:
enterOuterAlt(_localctx, 7);
{
setState(1581);
match(PORT);
setState(1582);
decimalLiteral();
}
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 CreateDefinitionsContext extends ParserRuleContext {
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List createDefinition() {
return getRuleContexts(CreateDefinitionContext.class);
}
public CreateDefinitionContext createDefinition(int i) {
return getRuleContext(CreateDefinitionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public CreateDefinitionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createDefinitions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDefinitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDefinitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCreateDefinitions(this);
else return visitor.visitChildren(this);
}
}
public final CreateDefinitionsContext createDefinitions() throws RecognitionException {
CreateDefinitionsContext _localctx = new CreateDefinitionsContext(_ctx, getState());
enterRule(_localctx, 88, RULE_createDefinitions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1585);
match(LR_BRACKET);
setState(1586);
createDefinition();
setState(1591);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1587);
match(COMMA);
setState(1588);
createDefinition();
}
}
setState(1593);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1594);
match(RR_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateDefinitionContext extends ParserRuleContext {
public CreateDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createDefinition; }
public CreateDefinitionContext() { }
public void copyFrom(CreateDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnDeclarationContext extends CreateDefinitionContext {
public FullColumnNameContext fullColumnName() {
return getRuleContext(FullColumnNameContext.class,0);
}
public ColumnDefinitionContext columnDefinition() {
return getRuleContext(ColumnDefinitionContext.class,0);
}
public ColumnDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitColumnDeclaration(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConstraintDeclarationContext extends CreateDefinitionContext {
public TableConstraintContext tableConstraint() {
return getRuleContext(TableConstraintContext.class,0);
}
public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); }
public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); }
public ConstraintDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConstraintDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConstraintDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitConstraintDeclaration(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexDeclarationContext extends CreateDefinitionContext {
public IndexColumnDefinitionContext indexColumnDefinition() {
return getRuleContext(IndexColumnDefinitionContext.class,0);
}
public IndexDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitIndexDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final CreateDefinitionContext createDefinition() throws RecognitionException {
CreateDefinitionContext _localctx = new CreateDefinitionContext(_ctx, getState());
enterRule(_localctx, 90, RULE_createDefinition);
int _la;
try {
setState(1607);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
_localctx = new ColumnDeclarationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1596);
fullColumnName();
setState(1597);
columnDefinition();
}
break;
case 2:
_localctx = new ConstraintDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1599);
tableConstraint();
setState(1601);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1600);
match(NOT);
}
}
setState(1604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENFORCED) {
{
setState(1603);
match(ENFORCED);
}
}
}
break;
case 3:
_localctx = new IndexDeclarationContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1606);
indexColumnDefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnDefinitionContext extends ParserRuleContext {
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public List columnConstraint() {
return getRuleContexts(ColumnConstraintContext.class);
}
public ColumnConstraintContext columnConstraint(int i) {
return getRuleContext(ColumnConstraintContext.class,i);
}
public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); }
public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); }
public ColumnDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitColumnDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ColumnDefinitionContext columnDefinition() throws RecognitionException {
ColumnDefinitionContext _localctx = new ColumnDefinitionContext(_ctx, getState());
enterRule(_localctx, 92, RULE_columnDefinition);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1609);
dataType();
setState(1613);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,148,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1610);
columnConstraint();
}
}
}
setState(1615);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,148,_ctx);
}
setState(1617);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1616);
match(NOT);
}
}
setState(1620);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENFORCED) {
{
setState(1619);
match(ENFORCED);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnConstraintContext extends ParserRuleContext {
public ColumnConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnConstraint; }
public ColumnConstraintContext() { }
public void copyFrom(ColumnConstraintContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StorageColumnConstraintContext extends ColumnConstraintContext {
public Token storageval;
public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); }
public TerminalNode DISK() { return getToken(MySqlParser.DISK, 0); }
public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public StorageColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStorageColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStorageColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitStorageColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VisibilityColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); }
public VisibilityColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterVisibilityColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitVisibilityColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitVisibilityColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AutoIncrementColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode AUTO_INCREMENT() { return getToken(MySqlParser.AUTO_INCREMENT, 0); }
public TerminalNode ON() { return getToken(MySqlParser.ON, 0); }
public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); }
public CurrentTimestampContext currentTimestamp() {
return getRuleContext(CurrentTimestampContext.class,0);
}
public AutoIncrementColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAutoIncrementColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAutoIncrementColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAutoIncrementColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CommentColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public CommentColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCommentColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCommentColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCommentColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UniqueKeyColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public UniqueKeyColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUniqueKeyColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUniqueKeyColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitUniqueKeyColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SerialDefaultColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode SERIAL() { return getToken(MySqlParser.SERIAL, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); }
public SerialDefaultColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSerialDefaultColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSerialDefaultColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSerialDefaultColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GeneratedColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode AS() { return getToken(MySqlParser.AS, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode GENERATED() { return getToken(MySqlParser.GENERATED, 0); }
public TerminalNode ALWAYS() { return getToken(MySqlParser.ALWAYS, 0); }
public TerminalNode VIRTUAL() { return getToken(MySqlParser.VIRTUAL, 0); }
public TerminalNode STORED() { return getToken(MySqlParser.STORED, 0); }
public GeneratedColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGeneratedColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGeneratedColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitGeneratedColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FormatColumnConstraintContext extends ColumnConstraintContext {
public Token colformat;
public TerminalNode COLUMN_FORMAT() { return getToken(MySqlParser.COLUMN_FORMAT, 0); }
public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); }
public TerminalNode DYNAMIC() { return getToken(MySqlParser.DYNAMIC, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public FormatColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFormatColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFormatColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitFormatColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CollateColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); }
public CollationNameContext collationName() {
return getRuleContext(CollationNameContext.class,0);
}
public CollateColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollateColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollateColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCollateColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryKeyColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); }
public PrimaryKeyColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrimaryKeyColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrimaryKeyColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPrimaryKeyColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CheckColumnConstraintContext extends ColumnConstraintContext {
public UidContext name;
public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public CheckColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCheckColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullColumnConstraintContext extends ColumnConstraintContext {
public NullNotnullContext nullNotnull() {
return getRuleContext(NullNotnullContext.class,0);
}
public NullColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNullColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNullColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitNullColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DefaultColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class,0);
}
public DefaultColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefaultColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefaultColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitDefaultColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReferenceColumnConstraintContext extends ColumnConstraintContext {
public ReferenceDefinitionContext referenceDefinition() {
return getRuleContext(ReferenceDefinitionContext.class,0);
}
public ReferenceColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitReferenceColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InvisibilityColumnConstraintContext extends ColumnConstraintContext {
public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); }
public InvisibilityColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInvisibilityColumnConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInvisibilityColumnConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitInvisibilityColumnConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ColumnConstraintContext columnConstraint() throws RecognitionException {
ColumnConstraintContext _localctx = new ColumnConstraintContext(_ctx, getState());
enterRule(_localctx, 94, RULE_columnConstraint);
int _la;
try {
setState(1675);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case NULL_LITERAL:
case NULL_SPEC_LITERAL:
_localctx = new NullColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1622);
nullNotnull();
}
break;
case DEFAULT:
_localctx = new DefaultColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1623);
match(DEFAULT);
setState(1624);
defaultValue();
}
break;
case VISIBLE:
_localctx = new VisibilityColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1625);
match(VISIBLE);
}
break;
case INVISIBLE:
_localctx = new InvisibilityColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1626);
match(INVISIBLE);
}
break;
case ON:
case AUTO_INCREMENT:
_localctx = new AutoIncrementColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1631);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AUTO_INCREMENT:
{
setState(1627);
match(AUTO_INCREMENT);
}
break;
case ON:
{
setState(1628);
match(ON);
setState(1629);
match(UPDATE);
setState(1630);
currentTimestamp();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case KEY:
case PRIMARY:
_localctx = new PrimaryKeyColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1634);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRIMARY) {
{
setState(1633);
match(PRIMARY);
}
}
setState(1636);
match(KEY);
}
break;
case UNIQUE:
_localctx = new UniqueKeyColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1637);
match(UNIQUE);
setState(1639);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
{
setState(1638);
match(KEY);
}
break;
}
}
break;
case COMMENT:
_localctx = new CommentColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(1641);
match(COMMENT);
setState(1642);
match(STRING_LITERAL);
}
break;
case COLUMN_FORMAT:
_localctx = new FormatColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(1643);
match(COLUMN_FORMAT);
setState(1644);
((FormatColumnConstraintContext)_localctx).colformat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==DYNAMIC || _la==FIXED) ) {
((FormatColumnConstraintContext)_localctx).colformat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case STORAGE:
_localctx = new StorageColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(1645);
match(STORAGE);
setState(1646);
((StorageColumnConstraintContext)_localctx).storageval = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==DISK || _la==MEMORY) ) {
((StorageColumnConstraintContext)_localctx).storageval = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case REFERENCES:
_localctx = new ReferenceColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(1647);
referenceDefinition();
}
break;
case COLLATE:
_localctx = new CollateColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(1648);
match(COLLATE);
setState(1649);
collationName();
}
break;
case AS:
case GENERATED:
_localctx = new GeneratedColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(1652);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GENERATED) {
{
setState(1650);
match(GENERATED);
setState(1651);
match(ALWAYS);
}
}
setState(1654);
match(AS);
setState(1655);
match(LR_BRACKET);
setState(1656);
expression(0);
setState(1657);
match(RR_BRACKET);
setState(1659);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORED || _la==VIRTUAL) {
{
setState(1658);
_la = _input.LA(1);
if ( !(_la==STORED || _la==VIRTUAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
case SERIAL:
_localctx = new SerialDefaultColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(1661);
match(SERIAL);
setState(1662);
match(DEFAULT);
setState(1663);
match(VALUE);
}
break;
case CHECK:
case CONSTRAINT:
_localctx = new CheckColumnConstraintContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(1668);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT) {
{
setState(1664);
match(CONSTRAINT);
setState(1666);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1665);
((CheckColumnConstraintContext)_localctx).name = uid();
}
}
}
}
setState(1670);
match(CHECK);
setState(1671);
match(LR_BRACKET);
setState(1672);
expression(0);
setState(1673);
match(RR_BRACKET);
}
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 TableConstraintContext extends ParserRuleContext {
public TableConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableConstraint; }
public TableConstraintContext() { }
public void copyFrom(TableConstraintContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UniqueKeyTableConstraintContext extends TableConstraintContext {
public UidContext name;
public Token indexFormat;
public UidContext index;
public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); }
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); }
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public List indexOption() {
return getRuleContexts(IndexOptionContext.class);
}
public IndexOptionContext indexOption(int i) {
return getRuleContext(IndexOptionContext.class,i);
}
public List uid() {
return getRuleContexts(UidContext.class);
}
public UidContext uid(int i) {
return getRuleContext(UidContext.class,i);
}
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public UniqueKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUniqueKeyTableConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUniqueKeyTableConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitUniqueKeyTableConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CheckTableConstraintContext extends TableConstraintContext {
public UidContext name;
public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public CheckTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckTableConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckTableConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitCheckTableConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryKeyTableConstraintContext extends TableConstraintContext {
public UidContext name;
public UidContext index;
public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); }
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public List indexOption() {
return getRuleContexts(IndexOptionContext.class);
}
public IndexOptionContext indexOption(int i) {
return getRuleContext(IndexOptionContext.class,i);
}
public List uid() {
return getRuleContexts(UidContext.class);
}
public UidContext uid(int i) {
return getRuleContext(UidContext.class,i);
}
public PrimaryKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrimaryKeyTableConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrimaryKeyTableConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPrimaryKeyTableConstraint(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ForeignKeyTableConstraintContext extends TableConstraintContext {
public UidContext name;
public UidContext index;
public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public ReferenceDefinitionContext referenceDefinition() {
return getRuleContext(ReferenceDefinitionContext.class,0);
}
public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); }
public List uid() {
return getRuleContexts(UidContext.class);
}
public UidContext uid(int i) {
return getRuleContext(UidContext.class,i);
}
public ForeignKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterForeignKeyTableConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitForeignKeyTableConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitForeignKeyTableConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TableConstraintContext tableConstraint() throws RecognitionException {
TableConstraintContext _localctx = new TableConstraintContext(_ctx, getState());
enterRule(_localctx, 96, RULE_tableConstraint);
int _la;
try {
setState(1746);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
_localctx = new PrimaryKeyTableConstraintContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1681);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT) {
{
setState(1677);
match(CONSTRAINT);
setState(1679);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1678);
((PrimaryKeyTableConstraintContext)_localctx).name = uid();
}
break;
}
}
}
setState(1683);
match(PRIMARY);
setState(1684);
match(KEY);
setState(1686);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1685);
((PrimaryKeyTableConstraintContext)_localctx).index = uid();
}
}
setState(1689);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1688);
indexType();
}
}
setState(1691);
indexColumnNames();
setState(1695);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) {
{
{
setState(1692);
indexOption();
}
}
setState(1697);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
_localctx = new UniqueKeyTableConstraintContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1702);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT) {
{
setState(1698);
match(CONSTRAINT);
setState(1700);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1699);
((UniqueKeyTableConstraintContext)_localctx).name = uid();
}
}
}
}
setState(1704);
match(UNIQUE);
setState(1706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INDEX || _la==KEY) {
{
setState(1705);
((UniqueKeyTableConstraintContext)_localctx).indexFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INDEX || _la==KEY) ) {
((UniqueKeyTableConstraintContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1709);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1708);
((UniqueKeyTableConstraintContext)_localctx).index = uid();
}
}
setState(1712);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1711);
indexType();
}
}
setState(1714);
indexColumnNames();
setState(1718);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) {
{
{
setState(1715);
indexOption();
}
}
setState(1720);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 3:
_localctx = new ForeignKeyTableConstraintContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1725);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT) {
{
setState(1721);
match(CONSTRAINT);
setState(1723);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1722);
((ForeignKeyTableConstraintContext)_localctx).name = uid();
}
}
}
}
setState(1727);
match(FOREIGN);
setState(1728);
match(KEY);
setState(1730);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1729);
((ForeignKeyTableConstraintContext)_localctx).index = uid();
}
}
setState(1732);
indexColumnNames();
setState(1733);
referenceDefinition();
}
break;
case 4:
_localctx = new CheckTableConstraintContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1739);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT) {
{
setState(1735);
match(CONSTRAINT);
setState(1737);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1736);
((CheckTableConstraintContext)_localctx).name = uid();
}
}
}
}
setState(1741);
match(CHECK);
setState(1742);
match(LR_BRACKET);
setState(1743);
expression(0);
setState(1744);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReferenceDefinitionContext extends ParserRuleContext {
public Token matchType;
public TerminalNode REFERENCES() { return getToken(MySqlParser.REFERENCES, 0); }
public TableNameContext tableName() {
return getRuleContext(TableNameContext.class,0);
}
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public TerminalNode MATCH() { return getToken(MySqlParser.MATCH, 0); }
public ReferenceActionContext referenceAction() {
return getRuleContext(ReferenceActionContext.class,0);
}
public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); }
public TerminalNode PARTIAL() { return getToken(MySqlParser.PARTIAL, 0); }
public TerminalNode SIMPLE() { return getToken(MySqlParser.SIMPLE, 0); }
public ReferenceDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referenceDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitReferenceDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ReferenceDefinitionContext referenceDefinition() throws RecognitionException {
ReferenceDefinitionContext _localctx = new ReferenceDefinitionContext(_ctx, getState());
enterRule(_localctx, 98, RULE_referenceDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1748);
match(REFERENCES);
setState(1749);
tableName();
setState(1751);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(1750);
indexColumnNames();
}
break;
}
setState(1755);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MATCH) {
{
setState(1753);
match(MATCH);
setState(1754);
((ReferenceDefinitionContext)_localctx).matchType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FULL || _la==PARTIAL || _la==SIMPLE) ) {
((ReferenceDefinitionContext)_localctx).matchType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1758);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1757);
referenceAction();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReferenceActionContext extends ParserRuleContext {
public ReferenceControlTypeContext onDelete;
public ReferenceControlTypeContext onUpdate;
public List ON() { return getTokens(MySqlParser.ON); }
public TerminalNode ON(int i) {
return getToken(MySqlParser.ON, i);
}
public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); }
public List referenceControlType() {
return getRuleContexts(ReferenceControlTypeContext.class);
}
public ReferenceControlTypeContext referenceControlType(int i) {
return getRuleContext(ReferenceControlTypeContext.class,i);
}
public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); }
public ReferenceActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referenceAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitReferenceAction(this);
else return visitor.visitChildren(this);
}
}
public final ReferenceActionContext referenceAction() throws RecognitionException {
ReferenceActionContext _localctx = new ReferenceActionContext(_ctx, getState());
enterRule(_localctx, 100, RULE_referenceAction);
try {
setState(1776);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1760);
match(ON);
setState(1761);
match(DELETE);
setState(1762);
((ReferenceActionContext)_localctx).onDelete = referenceControlType();
setState(1766);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
{
setState(1763);
match(ON);
setState(1764);
match(UPDATE);
setState(1765);
((ReferenceActionContext)_localctx).onUpdate = referenceControlType();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1768);
match(ON);
setState(1769);
match(UPDATE);
setState(1770);
((ReferenceActionContext)_localctx).onUpdate = referenceControlType();
setState(1774);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
{
setState(1771);
match(ON);
setState(1772);
match(DELETE);
setState(1773);
((ReferenceActionContext)_localctx).onDelete = referenceControlType();
}
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 ReferenceControlTypeContext extends ParserRuleContext {
public TerminalNode RESTRICT() { return getToken(MySqlParser.RESTRICT, 0); }
public TerminalNode CASCADE() { return getToken(MySqlParser.CASCADE, 0); }
public TerminalNode SET() { return getToken(MySqlParser.SET, 0); }
public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); }
public TerminalNode NO() { return getToken(MySqlParser.NO, 0); }
public TerminalNode ACTION() { return getToken(MySqlParser.ACTION, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public ReferenceControlTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referenceControlType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceControlType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceControlType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitReferenceControlType(this);
else return visitor.visitChildren(this);
}
}
public final ReferenceControlTypeContext referenceControlType() throws RecognitionException {
ReferenceControlTypeContext _localctx = new ReferenceControlTypeContext(_ctx, getState());
enterRule(_localctx, 102, RULE_referenceControlType);
try {
setState(1786);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1778);
match(RESTRICT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1779);
match(CASCADE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1780);
match(SET);
setState(1781);
match(NULL_LITERAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1782);
match(NO);
setState(1783);
match(ACTION);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1784);
match(SET);
setState(1785);
match(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 IndexColumnDefinitionContext extends ParserRuleContext {
public IndexColumnDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexColumnDefinition; }
public IndexColumnDefinitionContext() { }
public void copyFrom(IndexColumnDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SpecialIndexDeclarationContext extends IndexColumnDefinitionContext {
public Token indexFormat;
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public TerminalNode FULLTEXT() { return getToken(MySqlParser.FULLTEXT, 0); }
public TerminalNode SPATIAL() { return getToken(MySqlParser.SPATIAL, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public List indexOption() {
return getRuleContexts(IndexOptionContext.class);
}
public IndexOptionContext indexOption(int i) {
return getRuleContext(IndexOptionContext.class,i);
}
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public SpecialIndexDeclarationContext(IndexColumnDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSpecialIndexDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSpecialIndexDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSpecialIndexDeclaration(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleIndexDeclarationContext extends IndexColumnDefinitionContext {
public Token indexFormat;
public IndexColumnNamesContext indexColumnNames() {
return getRuleContext(IndexColumnNamesContext.class,0);
}
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public List indexOption() {
return getRuleContexts(IndexOptionContext.class);
}
public IndexOptionContext indexOption(int i) {
return getRuleContext(IndexOptionContext.class,i);
}
public SimpleIndexDeclarationContext(IndexColumnDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleIndexDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleIndexDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSimpleIndexDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final IndexColumnDefinitionContext indexColumnDefinition() throws RecognitionException {
IndexColumnDefinitionContext _localctx = new IndexColumnDefinitionContext(_ctx, getState());
enterRule(_localctx, 104, RULE_indexColumnDefinition);
int _la;
try {
setState(1816);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INDEX:
case KEY:
_localctx = new SimpleIndexDeclarationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1788);
((SimpleIndexDeclarationContext)_localctx).indexFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INDEX || _la==KEY) ) {
((SimpleIndexDeclarationContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1790);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1789);
uid();
}
}
setState(1793);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1792);
indexType();
}
}
setState(1795);
indexColumnNames();
setState(1799);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) {
{
{
setState(1796);
indexOption();
}
}
setState(1801);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case FULLTEXT:
case SPATIAL:
_localctx = new SpecialIndexDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1802);
_la = _input.LA(1);
if ( !(_la==FULLTEXT || _la==SPATIAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1804);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INDEX || _la==KEY) {
{
setState(1803);
((SpecialIndexDeclarationContext)_localctx).indexFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INDEX || _la==KEY) ) {
((SpecialIndexDeclarationContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1807);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(1806);
uid();
}
}
setState(1809);
indexColumnNames();
setState(1813);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) {
{
{
setState(1810);
indexOption();
}
}
setState(1815);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
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 TableOptionContext extends ParserRuleContext {
public TableOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableOption; }
public TableOptionContext() { }
public void copyFrom(TableOptionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionEngineContext extends TableOptionContext {
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public TableOptionEngineContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEngine(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEngine(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionEngine(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionMaxRowsContext extends TableOptionContext {
public TerminalNode MAX_ROWS() { return getToken(MySqlParser.MAX_ROWS, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionMaxRowsContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionMaxRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionMaxRows(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionMaxRows(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionCollateContext extends TableOptionContext {
public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); }
public CollationNameContext collationName() {
return getRuleContext(CollationNameContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionCollateContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCollate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCollate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionCollate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionPersistentContext extends TableOptionContext {
public Token extBoolValue;
public TerminalNode STATS_PERSISTENT() { return getToken(MySqlParser.STATS_PERSISTENT, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionPersistentContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPersistent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPersistent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionPersistent(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionTablespaceContext extends TableOptionContext {
public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TablespaceStorageContext tablespaceStorage() {
return getRuleContext(TablespaceStorageContext.class,0);
}
public TableOptionTablespaceContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTablespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTablespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionTablespace(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionAutoextendSizeContext extends TableOptionContext {
public TerminalNode AUTOEXTEND_SIZE() { return getToken(MySqlParser.AUTOEXTEND_SIZE, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionAutoextendSizeContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAutoextendSize(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAutoextendSize(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionAutoextendSize(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionPageCompressedContext extends TableOptionContext {
public TerminalNode PAGE_COMPRESSED() { return getToken(MySqlParser.PAGE_COMPRESSED, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionPageCompressedContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPageCompressed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPageCompressed(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionPageCompressed(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionStartTransactionContext extends TableOptionContext {
public TerminalNode START() { return getToken(MySqlParser.START, 0); }
public TerminalNode TRANSACTION() { return getToken(MySqlParser.TRANSACTION, 0); }
public TableOptionStartTransactionContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionStartTransaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionStartTransaction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionStartTransaction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionPackKeysContext extends TableOptionContext {
public Token extBoolValue;
public TerminalNode PACK_KEYS() { return getToken(MySqlParser.PACK_KEYS, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionPackKeysContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPackKeys(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPackKeys(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionPackKeys(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionPasswordContext extends TableOptionContext {
public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionPasswordContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPassword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPassword(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionPassword(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionUnionContext extends TableOptionContext {
public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TablesContext tables() {
return getRuleContext(TablesContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionUnionContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionUnion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionUnion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionUnion(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionSamplePageContext extends TableOptionContext {
public TerminalNode STATS_SAMPLE_PAGES() { return getToken(MySqlParser.STATS_SAMPLE_PAGES, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionSamplePageContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionSamplePage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionSamplePage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionSamplePage(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionCharsetContext extends TableOptionContext {
public CharSetContext charSet() {
return getRuleContext(CharSetContext.class,0);
}
public CharsetNameContext charsetName() {
return getRuleContext(CharsetNameContext.class,0);
}
public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); }
public TerminalNode DEFAULT(int i) {
return getToken(MySqlParser.DEFAULT, i);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionCharsetContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCharset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCharset(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionCharset(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionIndexDirectoryContext extends TableOptionContext {
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionIndexDirectoryContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionIndexDirectory(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionIndexDirectory(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionIndexDirectory(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionTableTypeContext extends TableOptionContext {
public TerminalNode TABLE_TYPE() { return getToken(MySqlParser.TABLE_TYPE, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableTypeContext tableType() {
return getRuleContext(TableTypeContext.class,0);
}
public TableOptionTableTypeContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTableType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTableType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionTableType(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionKeyBlockSizeContext extends TableOptionContext {
public TerminalNode KEY_BLOCK_SIZE() { return getToken(MySqlParser.KEY_BLOCK_SIZE, 0); }
public FileSizeLiteralContext fileSizeLiteral() {
return getRuleContext(FileSizeLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionKeyBlockSizeContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionKeyBlockSize(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionKeyBlockSize(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionKeyBlockSize(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionEncryptionContext extends TableOptionContext {
public TerminalNode ENCRYPTION() { return getToken(MySqlParser.ENCRYPTION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionEncryptionContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEncryption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEncryption(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionEncryption(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionDataDirectoryContext extends TableOptionContext {
public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); }
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionDataDirectoryContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionDataDirectory(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionDataDirectory(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionDataDirectory(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionRecalculationContext extends TableOptionContext {
public Token extBoolValue;
public TerminalNode STATS_AUTO_RECALC() { return getToken(MySqlParser.STATS_AUTO_RECALC, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionRecalculationContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionRecalculation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionRecalculation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionRecalculation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionAutoIncrementContext extends TableOptionContext {
public TerminalNode AUTO_INCREMENT() { return getToken(MySqlParser.AUTO_INCREMENT, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionAutoIncrementContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAutoIncrement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAutoIncrement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionAutoIncrement(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionEncryptionKeyIdContext extends TableOptionContext {
public TerminalNode ENCRYPTION_KEY_ID() { return getToken(MySqlParser.ENCRYPTION_KEY_ID, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionEncryptionKeyIdContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEncryptionKeyId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEncryptionKeyId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionEncryptionKeyId(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionChecksumContext extends TableOptionContext {
public Token boolValue;
public TerminalNode CHECKSUM() { return getToken(MySqlParser.CHECKSUM, 0); }
public TerminalNode PAGE_CHECKSUM() { return getToken(MySqlParser.PAGE_CHECKSUM, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionChecksumContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionChecksum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionChecksum(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionChecksum(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionDelayContext extends TableOptionContext {
public Token boolValue;
public TerminalNode DELAY_KEY_WRITE() { return getToken(MySqlParser.DELAY_KEY_WRITE, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionDelayContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionDelay(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionDelay(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionDelay(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionConnectionContext extends TableOptionContext {
public TerminalNode CONNECTION() { return getToken(MySqlParser.CONNECTION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionConnectionContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionConnection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionConnection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionConnection(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionTransactionalContext extends TableOptionContext {
public TerminalNode TRANSACTIONAL() { return getToken(MySqlParser.TRANSACTIONAL, 0); }
public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionTransactionalContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTransactional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTransactional(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionTransactional(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionPageCompressionLevelContext extends TableOptionContext {
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode PAGE_COMPRESSION_LEVEL() { return getToken(MySqlParser.PAGE_COMPRESSION_LEVEL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionPageCompressionLevelContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPageCompressionLevel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPageCompressionLevel(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionPageCompressionLevel(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionSecondaryEngineAttributeContext extends TableOptionContext {
public TerminalNode SECONDARY_ENGINE_ATTRIBUTE() { return getToken(MySqlParser.SECONDARY_ENGINE_ATTRIBUTE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionSecondaryEngineAttributeContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionSecondaryEngineAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionSecondaryEngineAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionSecondaryEngineAttribute(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionCommentContext extends TableOptionContext {
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionCommentContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionComment(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionAverageContext extends TableOptionContext {
public TerminalNode AVG_ROW_LENGTH() { return getToken(MySqlParser.AVG_ROW_LENGTH, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionAverageContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAverage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAverage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionAverage(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionRowFormatContext extends TableOptionContext {
public Token rowFormat;
public TerminalNode ROW_FORMAT() { return getToken(MySqlParser.ROW_FORMAT, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode DYNAMIC() { return getToken(MySqlParser.DYNAMIC, 0); }
public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); }
public TerminalNode COMPRESSED() { return getToken(MySqlParser.COMPRESSED, 0); }
public TerminalNode REDUNDANT() { return getToken(MySqlParser.REDUNDANT, 0); }
public TerminalNode COMPACT() { return getToken(MySqlParser.COMPACT, 0); }
public TerminalNode ID() { return getToken(MySqlParser.ID, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionRowFormatContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionRowFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionRowFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionRowFormat(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionCompressionContext extends TableOptionContext {
public TerminalNode COMPRESSION() { return getToken(MySqlParser.COMPRESSION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode ID() { return getToken(MySqlParser.ID, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionCompressionContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCompression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCompression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionCompression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionInsertMethodContext extends TableOptionContext {
public Token insertMethod;
public TerminalNode INSERT_METHOD() { return getToken(MySqlParser.INSERT_METHOD, 0); }
public TerminalNode NO() { return getToken(MySqlParser.NO, 0); }
public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(MySqlParser.LAST, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionInsertMethodContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionInsertMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionInsertMethod(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionInsertMethod(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionEngineAttributeContext extends TableOptionContext {
public TerminalNode ENGINE_ATTRIBUTE() { return getToken(MySqlParser.ENGINE_ATTRIBUTE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionEngineAttributeContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEngineAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEngineAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionEngineAttribute(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableOptionMinRowsContext extends TableOptionContext {
public TerminalNode MIN_ROWS() { return getToken(MySqlParser.MIN_ROWS, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TableOptionMinRowsContext(TableOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionMinRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionMinRows(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableOptionMinRows(this);
else return visitor.visitChildren(this);
}
}
public final TableOptionContext tableOption() throws RecognitionException {
TableOptionContext _localctx = new TableOptionContext(_ctx, getState());
enterRule(_localctx, 106, RULE_tableOption);
int _la;
try {
setState(2003);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
_localctx = new TableOptionEngineContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1818);
match(ENGINE);
setState(1820);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1819);
match(EQUAL_SYMBOL);
}
}
setState(1823);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(1822);
engineName();
}
break;
}
}
break;
case 2:
_localctx = new TableOptionEngineAttributeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1825);
match(ENGINE_ATTRIBUTE);
setState(1827);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1826);
match(EQUAL_SYMBOL);
}
}
setState(1829);
match(STRING_LITERAL);
}
break;
case 3:
_localctx = new TableOptionAutoextendSizeContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1830);
match(AUTOEXTEND_SIZE);
setState(1832);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1831);
match(EQUAL_SYMBOL);
}
}
setState(1834);
decimalLiteral();
}
break;
case 4:
_localctx = new TableOptionAutoIncrementContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1835);
match(AUTO_INCREMENT);
setState(1837);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1836);
match(EQUAL_SYMBOL);
}
}
setState(1839);
decimalLiteral();
}
break;
case 5:
_localctx = new TableOptionAverageContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1840);
match(AVG_ROW_LENGTH);
setState(1842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1841);
match(EQUAL_SYMBOL);
}
}
setState(1844);
decimalLiteral();
}
break;
case 6:
_localctx = new TableOptionCharsetContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1846);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1845);
match(DEFAULT);
}
}
setState(1848);
charSet();
setState(1850);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1849);
match(EQUAL_SYMBOL);
}
}
setState(1854);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BINARY:
case ARMSCII8:
case ASCII:
case BIG5:
case CP1250:
case CP1251:
case CP1256:
case CP1257:
case CP850:
case CP852:
case CP866:
case CP932:
case DEC8:
case EUCJPMS:
case EUCKR:
case GB18030:
case GB2312:
case GBK:
case GEOSTD8:
case GREEK:
case HEBREW:
case HP8:
case KEYBCS2:
case KOI8R:
case KOI8U:
case LATIN1:
case LATIN2:
case LATIN5:
case LATIN7:
case MACCE:
case MACROMAN:
case SJIS:
case SWE7:
case TIS620:
case UCS2:
case UJIS:
case UTF16:
case UTF16LE:
case UTF32:
case UTF8:
case UTF8MB3:
case UTF8MB4:
case CHARSET_REVERSE_QOUTE_STRING:
case STRING_LITERAL:
{
setState(1852);
charsetName();
}
break;
case DEFAULT:
{
setState(1853);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
_localctx = new TableOptionChecksumContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1856);
_la = _input.LA(1);
if ( !(_la==CHECKSUM || _la==PAGE_CHECKSUM) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1858);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1857);
match(EQUAL_SYMBOL);
}
}
setState(1860);
((TableOptionChecksumContext)_localctx).boolValue = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
((TableOptionChecksumContext)_localctx).boolValue = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 8:
_localctx = new TableOptionCollateContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(1862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1861);
match(DEFAULT);
}
}
setState(1864);
match(COLLATE);
setState(1866);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1865);
match(EQUAL_SYMBOL);
}
}
setState(1868);
collationName();
}
break;
case 9:
_localctx = new TableOptionCommentContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(1869);
match(COMMENT);
setState(1871);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1870);
match(EQUAL_SYMBOL);
}
}
setState(1873);
match(STRING_LITERAL);
}
break;
case 10:
_localctx = new TableOptionCompressionContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(1874);
match(COMPRESSION);
setState(1876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1875);
match(EQUAL_SYMBOL);
}
}
setState(1878);
_la = _input.LA(1);
if ( !(_la==STRING_LITERAL || _la==ID) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 11:
_localctx = new TableOptionConnectionContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(1879);
match(CONNECTION);
setState(1881);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1880);
match(EQUAL_SYMBOL);
}
}
setState(1883);
match(STRING_LITERAL);
}
break;
case 12:
_localctx = new TableOptionDataDirectoryContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(1884);
_la = _input.LA(1);
if ( !(_la==INDEX || _la==DATA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1885);
match(DIRECTORY);
setState(1887);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1886);
match(EQUAL_SYMBOL);
}
}
setState(1889);
match(STRING_LITERAL);
}
break;
case 13:
_localctx = new TableOptionDelayContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(1890);
match(DELAY_KEY_WRITE);
setState(1892);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1891);
match(EQUAL_SYMBOL);
}
}
setState(1894);
((TableOptionDelayContext)_localctx).boolValue = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
((TableOptionDelayContext)_localctx).boolValue = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 14:
_localctx = new TableOptionEncryptionContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(1895);
match(ENCRYPTION);
setState(1897);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1896);
match(EQUAL_SYMBOL);
}
}
setState(1899);
match(STRING_LITERAL);
}
break;
case 15:
_localctx = new TableOptionPageCompressedContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(1900);
_la = _input.LA(1);
if ( !(_la==PAGE_COMPRESSED || _la==STRING_LITERAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1902);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1901);
match(EQUAL_SYMBOL);
}
}
setState(1904);
_la = _input.LA(1);
if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 16:
_localctx = new TableOptionPageCompressionLevelContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(1905);
_la = _input.LA(1);
if ( !(_la==PAGE_COMPRESSION_LEVEL || _la==STRING_LITERAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1907);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1906);
match(EQUAL_SYMBOL);
}
}
setState(1909);
decimalLiteral();
}
break;
case 17:
_localctx = new TableOptionEncryptionKeyIdContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(1910);
match(ENCRYPTION_KEY_ID);
setState(1912);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1911);
match(EQUAL_SYMBOL);
}
}
setState(1914);
decimalLiteral();
}
break;
case 18:
_localctx = new TableOptionIndexDirectoryContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(1915);
match(INDEX);
setState(1916);
match(DIRECTORY);
setState(1918);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1917);
match(EQUAL_SYMBOL);
}
}
setState(1920);
match(STRING_LITERAL);
}
break;
case 19:
_localctx = new TableOptionInsertMethodContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(1921);
match(INSERT_METHOD);
setState(1923);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1922);
match(EQUAL_SYMBOL);
}
}
setState(1925);
((TableOptionInsertMethodContext)_localctx).insertMethod = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST || _la==NO) ) {
((TableOptionInsertMethodContext)_localctx).insertMethod = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 20:
_localctx = new TableOptionKeyBlockSizeContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(1926);
match(KEY_BLOCK_SIZE);
setState(1928);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1927);
match(EQUAL_SYMBOL);
}
}
setState(1930);
fileSizeLiteral();
}
break;
case 21:
_localctx = new TableOptionMaxRowsContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(1931);
match(MAX_ROWS);
setState(1933);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1932);
match(EQUAL_SYMBOL);
}
}
setState(1935);
decimalLiteral();
}
break;
case 22:
_localctx = new TableOptionMinRowsContext(_localctx);
enterOuterAlt(_localctx, 22);
{
setState(1936);
match(MIN_ROWS);
setState(1938);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1937);
match(EQUAL_SYMBOL);
}
}
setState(1940);
decimalLiteral();
}
break;
case 23:
_localctx = new TableOptionPackKeysContext(_localctx);
enterOuterAlt(_localctx, 23);
{
setState(1941);
match(PACK_KEYS);
setState(1943);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1942);
match(EQUAL_SYMBOL);
}
}
setState(1945);
((TableOptionPackKeysContext)_localctx).extBoolValue = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
((TableOptionPackKeysContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 24:
_localctx = new TableOptionPasswordContext(_localctx);
enterOuterAlt(_localctx, 24);
{
setState(1946);
match(PASSWORD);
setState(1948);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1947);
match(EQUAL_SYMBOL);
}
}
setState(1950);
match(STRING_LITERAL);
}
break;
case 25:
_localctx = new TableOptionRowFormatContext(_localctx);
enterOuterAlt(_localctx, 25);
{
setState(1951);
match(ROW_FORMAT);
setState(1953);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1952);
match(EQUAL_SYMBOL);
}
}
setState(1955);
((TableOptionRowFormatContext)_localctx).rowFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || ((((_la - 370)) & ~0x3f) == 0 && ((1L << (_la - 370)) & 2305843013508661253L) != 0) || _la==REDUNDANT || _la==ID) ) {
((TableOptionRowFormatContext)_localctx).rowFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 26:
_localctx = new TableOptionStartTransactionContext(_localctx);
enterOuterAlt(_localctx, 26);
{
setState(1956);
match(START);
setState(1957);
match(TRANSACTION);
}
break;
case 27:
_localctx = new TableOptionSecondaryEngineAttributeContext(_localctx);
enterOuterAlt(_localctx, 27);
{
setState(1958);
match(SECONDARY_ENGINE_ATTRIBUTE);
setState(1960);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1959);
match(EQUAL_SYMBOL);
}
}
setState(1962);
match(STRING_LITERAL);
}
break;
case 28:
_localctx = new TableOptionRecalculationContext(_localctx);
enterOuterAlt(_localctx, 28);
{
setState(1963);
match(STATS_AUTO_RECALC);
setState(1965);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1964);
match(EQUAL_SYMBOL);
}
}
setState(1967);
((TableOptionRecalculationContext)_localctx).extBoolValue = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
((TableOptionRecalculationContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 29:
_localctx = new TableOptionPersistentContext(_localctx);
enterOuterAlt(_localctx, 29);
{
setState(1968);
match(STATS_PERSISTENT);
setState(1970);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1969);
match(EQUAL_SYMBOL);
}
}
setState(1972);
((TableOptionPersistentContext)_localctx).extBoolValue = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
((TableOptionPersistentContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 30:
_localctx = new TableOptionSamplePageContext(_localctx);
enterOuterAlt(_localctx, 30);
{
setState(1973);
match(STATS_SAMPLE_PAGES);
setState(1975);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1974);
match(EQUAL_SYMBOL);
}
}
setState(1979);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
{
setState(1977);
match(DEFAULT);
}
break;
case ZERO_DECIMAL:
case ONE_DECIMAL:
case TWO_DECIMAL:
case DECIMAL_LITERAL:
case REAL_LITERAL:
{
setState(1978);
decimalLiteral();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 31:
_localctx = new TableOptionTablespaceContext(_localctx);
enterOuterAlt(_localctx, 31);
{
setState(1981);
match(TABLESPACE);
setState(1982);
uid();
setState(1984);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
case 1:
{
setState(1983);
tablespaceStorage();
}
break;
}
}
break;
case 32:
_localctx = new TableOptionTableTypeContext(_localctx);
enterOuterAlt(_localctx, 32);
{
setState(1986);
match(TABLE_TYPE);
setState(1987);
match(EQUAL_SYMBOL);
setState(1988);
tableType();
}
break;
case 33:
_localctx = new TableOptionTablespaceContext(_localctx);
enterOuterAlt(_localctx, 33);
{
setState(1989);
tablespaceStorage();
}
break;
case 34:
_localctx = new TableOptionTransactionalContext(_localctx);
enterOuterAlt(_localctx, 34);
{
setState(1990);
match(TRANSACTIONAL);
setState(1992);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1991);
match(EQUAL_SYMBOL);
}
}
setState(1994);
_la = _input.LA(1);
if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 35:
_localctx = new TableOptionUnionContext(_localctx);
enterOuterAlt(_localctx, 35);
{
setState(1995);
match(UNION);
setState(1997);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(1996);
match(EQUAL_SYMBOL);
}
}
setState(1999);
match(LR_BRACKET);
setState(2000);
tables();
setState(2001);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableTypeContext extends ParserRuleContext {
public TerminalNode MYSQL() { return getToken(MySqlParser.MYSQL, 0); }
public TerminalNode ODBC() { return getToken(MySqlParser.ODBC, 0); }
public TableTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTableType(this);
else return visitor.visitChildren(this);
}
}
public final TableTypeContext tableType() throws RecognitionException {
TableTypeContext _localctx = new TableTypeContext(_ctx, getState());
enterRule(_localctx, 108, RULE_tableType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2005);
_la = _input.LA(1);
if ( !(_la==MYSQL || _la==ODBC) ) {
_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 TablespaceStorageContext extends ParserRuleContext {
public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); }
public TerminalNode DISK() { return getToken(MySqlParser.DISK, 0); }
public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); }
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TablespaceStorageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tablespaceStorage; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTablespaceStorage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTablespaceStorage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitTablespaceStorage(this);
else return visitor.visitChildren(this);
}
}
public final TablespaceStorageContext tablespaceStorage() throws RecognitionException {
TablespaceStorageContext _localctx = new TablespaceStorageContext(_ctx, getState());
enterRule(_localctx, 110, RULE_tablespaceStorage);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2007);
match(STORAGE);
setState(2008);
_la = _input.LA(1);
if ( !(_la==DEFAULT || _la==DISK || _la==MEMORY) ) {
_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 PartitionDefinitionsContext extends ParserRuleContext {
public DecimalLiteralContext count;
public DecimalLiteralContext subCount;
public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); }
public List BY() { return getTokens(MySqlParser.BY); }
public TerminalNode BY(int i) {
return getToken(MySqlParser.BY, i);
}
public PartitionFunctionDefinitionContext partitionFunctionDefinition() {
return getRuleContext(PartitionFunctionDefinitionContext.class,0);
}
public TerminalNode PARTITIONS() { return getToken(MySqlParser.PARTITIONS, 0); }
public TerminalNode SUBPARTITION() { return getToken(MySqlParser.SUBPARTITION, 0); }
public SubpartitionFunctionDefinitionContext subpartitionFunctionDefinition() {
return getRuleContext(SubpartitionFunctionDefinitionContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List partitionDefinition() {
return getRuleContexts(PartitionDefinitionContext.class);
}
public PartitionDefinitionContext partitionDefinition(int i) {
return getRuleContext(PartitionDefinitionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public List decimalLiteral() {
return getRuleContexts(DecimalLiteralContext.class);
}
public DecimalLiteralContext decimalLiteral(int i) {
return getRuleContext(DecimalLiteralContext.class,i);
}
public TerminalNode SUBPARTITIONS() { return getToken(MySqlParser.SUBPARTITIONS, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public PartitionDefinitionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionDefinitions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionDefinitions(this);
else return visitor.visitChildren(this);
}
}
public final PartitionDefinitionsContext partitionDefinitions() throws RecognitionException {
PartitionDefinitionsContext _localctx = new PartitionDefinitionsContext(_ctx, getState());
enterRule(_localctx, 112, RULE_partitionDefinitions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2010);
match(PARTITION);
setState(2011);
match(BY);
setState(2012);
partitionFunctionDefinition();
setState(2015);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITIONS) {
{
setState(2013);
match(PARTITIONS);
setState(2014);
((PartitionDefinitionsContext)_localctx).count = decimalLiteral();
}
}
setState(2024);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBPARTITION) {
{
setState(2017);
match(SUBPARTITION);
setState(2018);
match(BY);
setState(2019);
subpartitionFunctionDefinition();
setState(2022);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBPARTITIONS) {
{
setState(2020);
match(SUBPARTITIONS);
setState(2021);
((PartitionDefinitionsContext)_localctx).subCount = decimalLiteral();
}
}
}
}
setState(2037);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
case 1:
{
setState(2026);
match(LR_BRACKET);
setState(2027);
partitionDefinition();
setState(2032);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2028);
match(COMMA);
setState(2029);
partitionDefinition();
}
}
setState(2034);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2035);
match(RR_BRACKET);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionFunctionDefinitionContext extends ParserRuleContext {
public PartitionFunctionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionFunctionDefinition; }
public PartitionFunctionDefinitionContext() { }
public void copyFrom(PartitionFunctionDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionFunctionKeyContext extends PartitionFunctionDefinitionContext {
public Token algType;
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); }
public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public UidListContext uidList() {
return getRuleContext(UidListContext.class,0);
}
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode TWO_DECIMAL() { return getToken(MySqlParser.TWO_DECIMAL, 0); }
public PartitionFunctionKeyContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionFunctionKey(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionFunctionHashContext extends PartitionFunctionDefinitionContext {
public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); }
public PartitionFunctionHashContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionFunctionHash(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionFunctionListContext extends PartitionFunctionDefinitionContext {
public TerminalNode LIST() { return getToken(MySqlParser.LIST, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); }
public UidListContext uidList() {
return getRuleContext(UidListContext.class,0);
}
public PartitionFunctionListContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionFunctionList(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionFunctionRangeContext extends PartitionFunctionDefinitionContext {
public TerminalNode RANGE() { return getToken(MySqlParser.RANGE, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); }
public UidListContext uidList() {
return getRuleContext(UidListContext.class,0);
}
public PartitionFunctionRangeContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionRange(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionFunctionRange(this);
else return visitor.visitChildren(this);
}
}
public final PartitionFunctionDefinitionContext partitionFunctionDefinition() throws RecognitionException {
PartitionFunctionDefinitionContext _localctx = new PartitionFunctionDefinitionContext(_ctx, getState());
enterRule(_localctx, 114, RULE_partitionFunctionDefinition);
int _la;
try {
setState(2085);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) {
case 1:
_localctx = new PartitionFunctionHashContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2040);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LINEAR) {
{
setState(2039);
match(LINEAR);
}
}
setState(2042);
match(HASH);
setState(2043);
match(LR_BRACKET);
setState(2044);
expression(0);
setState(2045);
match(RR_BRACKET);
}
break;
case 2:
_localctx = new PartitionFunctionKeyContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2048);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LINEAR) {
{
setState(2047);
match(LINEAR);
}
}
setState(2050);
match(KEY);
setState(2054);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALGORITHM) {
{
setState(2051);
match(ALGORITHM);
setState(2052);
match(EQUAL_SYMBOL);
setState(2053);
((PartitionFunctionKeyContext)_localctx).algType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ONE_DECIMAL || _la==TWO_DECIMAL) ) {
((PartitionFunctionKeyContext)_localctx).algType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2056);
match(LR_BRACKET);
setState(2058);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 756891332513122304L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 146666055071174737L) != 0) || ((((_la - 140)) & ~0x3f) == 0 && ((1L << (_la - 140)) & 268698883L) != 0) || ((((_la - 217)) & ~0x3f) == 0 && ((1L << (_la - 217)) & -17174494689L) != 0) || ((((_la - 281)) & ~0x3f) == 0 && ((1L << (_la - 281)) & -1099511627777L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & -2882305960540372993L) != 0) || ((((_la - 409)) & ~0x3f) == 0 && ((1L << (_la - 409)) & -4398063288321L) != 0) || ((((_la - 473)) & ~0x3f) == 0 && ((1L << (_la - 473)) & -16325548649218049L) != 0) || ((((_la - 537)) & ~0x3f) == 0 && ((1L << (_la - 537)) & -81064793296864001L) != 0) || ((((_la - 601)) & ~0x3f) == 0 && ((1L << (_la - 601)) & -68719476801L) != 0) || ((((_la - 665)) & ~0x3f) == 0 && ((1L << (_la - 665)) & -22236531750340609L) != 0) || ((((_la - 729)) & ~0x3f) == 0 && ((1L << (_la - 729)) & -65L) != 0) || ((((_la - 793)) & ~0x3f) == 0 && ((1L << (_la - 793)) & -6145L) != 0) || ((((_la - 857)) & ~0x3f) == 0 && ((1L << (_la - 857)) & -1L) != 0) || ((((_la - 921)) & ~0x3f) == 0 && ((1L << (_la - 921)) & -1L) != 0) || ((((_la - 985)) & ~0x3f) == 0 && ((1L << (_la - 985)) & -1L) != 0) || ((((_la - 1049)) & ~0x3f) == 0 && ((1L << (_la - 1049)) & 576460752303423487L) != 0) || ((((_la - 1123)) & ~0x3f) == 0 && ((1L << (_la - 1123)) & 8627683329L) != 0)) {
{
setState(2057);
uidList();
}
}
setState(2060);
match(RR_BRACKET);
}
break;
case 3:
_localctx = new PartitionFunctionRangeContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2061);
match(RANGE);
setState(2071);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LR_BRACKET:
{
setState(2062);
match(LR_BRACKET);
setState(2063);
expression(0);
setState(2064);
match(RR_BRACKET);
}
break;
case COLUMNS:
{
setState(2066);
match(COLUMNS);
setState(2067);
match(LR_BRACKET);
setState(2068);
uidList();
setState(2069);
match(RR_BRACKET);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
_localctx = new PartitionFunctionListContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2073);
match(LIST);
setState(2083);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LR_BRACKET:
{
setState(2074);
match(LR_BRACKET);
setState(2075);
expression(0);
setState(2076);
match(RR_BRACKET);
}
break;
case COLUMNS:
{
setState(2078);
match(COLUMNS);
setState(2079);
match(LR_BRACKET);
setState(2080);
uidList();
setState(2081);
match(RR_BRACKET);
}
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 SubpartitionFunctionDefinitionContext extends ParserRuleContext {
public SubpartitionFunctionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subpartitionFunctionDefinition; }
public SubpartitionFunctionDefinitionContext() { }
public void copyFrom(SubpartitionFunctionDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubPartitionFunctionHashContext extends SubpartitionFunctionDefinitionContext {
public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); }
public SubPartitionFunctionHashContext(SubpartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubPartitionFunctionHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubPartitionFunctionHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSubPartitionFunctionHash(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubPartitionFunctionKeyContext extends SubpartitionFunctionDefinitionContext {
public Token algType;
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public UidListContext uidList() {
return getRuleContext(UidListContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); }
public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); }
public TerminalNode TWO_DECIMAL() { return getToken(MySqlParser.TWO_DECIMAL, 0); }
public SubPartitionFunctionKeyContext(SubpartitionFunctionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubPartitionFunctionKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubPartitionFunctionKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSubPartitionFunctionKey(this);
else return visitor.visitChildren(this);
}
}
public final SubpartitionFunctionDefinitionContext subpartitionFunctionDefinition() throws RecognitionException {
SubpartitionFunctionDefinitionContext _localctx = new SubpartitionFunctionDefinitionContext(_ctx, getState());
enterRule(_localctx, 116, RULE_subpartitionFunctionDefinition);
int _la;
try {
setState(2108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) {
case 1:
_localctx = new SubPartitionFunctionHashContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2088);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LINEAR) {
{
setState(2087);
match(LINEAR);
}
}
setState(2090);
match(HASH);
setState(2091);
match(LR_BRACKET);
setState(2092);
expression(0);
setState(2093);
match(RR_BRACKET);
}
break;
case 2:
_localctx = new SubPartitionFunctionKeyContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2096);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LINEAR) {
{
setState(2095);
match(LINEAR);
}
}
setState(2098);
match(KEY);
setState(2102);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALGORITHM) {
{
setState(2099);
match(ALGORITHM);
setState(2100);
match(EQUAL_SYMBOL);
setState(2101);
((SubPartitionFunctionKeyContext)_localctx).algType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ONE_DECIMAL || _la==TWO_DECIMAL) ) {
((SubPartitionFunctionKeyContext)_localctx).algType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2104);
match(LR_BRACKET);
setState(2105);
uidList();
setState(2106);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionDefinitionContext extends ParserRuleContext {
public PartitionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionDefinition; }
public PartitionDefinitionContext() { }
public void copyFrom(PartitionDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionComparisonContext extends PartitionDefinitionContext {
public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); }
public TerminalNode LESS() { return getToken(MySqlParser.LESS, 0); }
public TerminalNode THAN() { return getToken(MySqlParser.THAN, 0); }
public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(MySqlParser.LR_BRACKET, i);
}
public List partitionDefinerAtom() {
return getRuleContexts(PartitionDefinerAtomContext.class);
}
public PartitionDefinerAtomContext partitionDefinerAtom(int i) {
return getRuleContext(PartitionDefinerAtomContext.class,i);
}
public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(MySqlParser.RR_BRACKET, i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public List partitionOption() {
return getRuleContexts(PartitionOptionContext.class);
}
public PartitionOptionContext partitionOption(int i) {
return getRuleContext(PartitionOptionContext.class,i);
}
public List subpartitionDefinition() {
return getRuleContexts(SubpartitionDefinitionContext.class);
}
public SubpartitionDefinitionContext subpartitionDefinition(int i) {
return getRuleContext(SubpartitionDefinitionContext.class,i);
}
public PartitionComparisonContext(PartitionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionComparison(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionListAtomContext extends PartitionDefinitionContext {
public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); }
public TerminalNode IN() { return getToken(MySqlParser.IN, 0); }
public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(MySqlParser.LR_BRACKET, i);
}
public List partitionDefinerAtom() {
return getRuleContexts(PartitionDefinerAtomContext.class);
}
public PartitionDefinerAtomContext partitionDefinerAtom(int i) {
return getRuleContext(PartitionDefinerAtomContext.class,i);
}
public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(MySqlParser.RR_BRACKET, i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public List partitionOption() {
return getRuleContexts(PartitionOptionContext.class);
}
public PartitionOptionContext partitionOption(int i) {
return getRuleContext(PartitionOptionContext.class,i);
}
public List subpartitionDefinition() {
return getRuleContexts(SubpartitionDefinitionContext.class);
}
public SubpartitionDefinitionContext subpartitionDefinition(int i) {
return getRuleContext(SubpartitionDefinitionContext.class,i);
}
public PartitionListAtomContext(PartitionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionListAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionListAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionListAtom(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionListVectorContext extends PartitionDefinitionContext {
public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); }
public TerminalNode IN() { return getToken(MySqlParser.IN, 0); }
public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(MySqlParser.LR_BRACKET, i);
}
public List partitionDefinerVector() {
return getRuleContexts(PartitionDefinerVectorContext.class);
}
public PartitionDefinerVectorContext partitionDefinerVector(int i) {
return getRuleContext(PartitionDefinerVectorContext.class,i);
}
public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(MySqlParser.RR_BRACKET, i);
}
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public List partitionOption() {
return getRuleContexts(PartitionOptionContext.class);
}
public PartitionOptionContext partitionOption(int i) {
return getRuleContext(PartitionOptionContext.class,i);
}
public List subpartitionDefinition() {
return getRuleContexts(SubpartitionDefinitionContext.class);
}
public SubpartitionDefinitionContext subpartitionDefinition(int i) {
return getRuleContext(SubpartitionDefinitionContext.class,i);
}
public PartitionListVectorContext(PartitionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionListVector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionListVector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionListVector(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionSimpleContext extends PartitionDefinitionContext {
public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public List partitionOption() {
return getRuleContexts(PartitionOptionContext.class);
}
public PartitionOptionContext partitionOption(int i) {
return getRuleContext(PartitionOptionContext.class,i);
}
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List subpartitionDefinition() {
return getRuleContexts(SubpartitionDefinitionContext.class);
}
public SubpartitionDefinitionContext subpartitionDefinition(int i) {
return getRuleContext(SubpartitionDefinitionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public PartitionSimpleContext(PartitionDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionSimple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionSimple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionSimple(this);
else return visitor.visitChildren(this);
}
}
public final PartitionDefinitionContext partitionDefinition() throws RecognitionException {
PartitionDefinitionContext _localctx = new PartitionDefinitionContext(_ctx, getState());
enterRule(_localctx, 118, RULE_partitionDefinition);
int _la;
try {
setState(2256);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
case 1:
_localctx = new PartitionComparisonContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2110);
match(PARTITION);
setState(2111);
uid();
setState(2112);
match(VALUES);
setState(2113);
match(LESS);
setState(2114);
match(THAN);
setState(2115);
match(LR_BRACKET);
setState(2116);
partitionDefinerAtom();
setState(2121);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2117);
match(COMMA);
setState(2118);
partitionDefinerAtom();
}
}
setState(2123);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2124);
match(RR_BRACKET);
setState(2128);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2125);
partitionOption();
}
}
setState(2130);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2142);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(2131);
match(LR_BRACKET);
setState(2132);
subpartitionDefinition();
setState(2137);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2133);
match(COMMA);
setState(2134);
subpartitionDefinition();
}
}
setState(2139);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2140);
match(RR_BRACKET);
}
}
}
break;
case 2:
_localctx = new PartitionComparisonContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2144);
match(PARTITION);
setState(2145);
uid();
setState(2146);
match(VALUES);
setState(2147);
match(LESS);
setState(2148);
match(THAN);
setState(2149);
partitionDefinerAtom();
setState(2153);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2150);
partitionOption();
}
}
setState(2155);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2167);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(2156);
match(LR_BRACKET);
setState(2157);
subpartitionDefinition();
setState(2162);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2158);
match(COMMA);
setState(2159);
subpartitionDefinition();
}
}
setState(2164);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2165);
match(RR_BRACKET);
}
}
}
break;
case 3:
_localctx = new PartitionListAtomContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2169);
match(PARTITION);
setState(2170);
uid();
setState(2171);
match(VALUES);
setState(2172);
match(IN);
setState(2173);
match(LR_BRACKET);
setState(2174);
partitionDefinerAtom();
setState(2179);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2175);
match(COMMA);
setState(2176);
partitionDefinerAtom();
}
}
setState(2181);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2182);
match(RR_BRACKET);
setState(2186);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2183);
partitionOption();
}
}
setState(2188);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2200);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(2189);
match(LR_BRACKET);
setState(2190);
subpartitionDefinition();
setState(2195);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2191);
match(COMMA);
setState(2192);
subpartitionDefinition();
}
}
setState(2197);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2198);
match(RR_BRACKET);
}
}
}
break;
case 4:
_localctx = new PartitionListVectorContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2202);
match(PARTITION);
setState(2203);
uid();
setState(2204);
match(VALUES);
setState(2205);
match(IN);
setState(2206);
match(LR_BRACKET);
setState(2207);
partitionDefinerVector();
setState(2212);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2208);
match(COMMA);
setState(2209);
partitionDefinerVector();
}
}
setState(2214);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2215);
match(RR_BRACKET);
setState(2219);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2216);
partitionOption();
}
}
setState(2221);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2233);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(2222);
match(LR_BRACKET);
setState(2223);
subpartitionDefinition();
setState(2228);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2224);
match(COMMA);
setState(2225);
subpartitionDefinition();
}
}
setState(2230);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2231);
match(RR_BRACKET);
}
}
}
break;
case 5:
_localctx = new PartitionSimpleContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2235);
match(PARTITION);
setState(2236);
uid();
setState(2240);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2237);
partitionOption();
}
}
setState(2242);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(2243);
match(LR_BRACKET);
setState(2244);
subpartitionDefinition();
setState(2249);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2245);
match(COMMA);
setState(2246);
subpartitionDefinition();
}
}
setState(2251);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2252);
match(RR_BRACKET);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionDefinerAtomContext extends ParserRuleContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode MAXVALUE() { return getToken(MySqlParser.MAXVALUE, 0); }
public PartitionDefinerAtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionDefinerAtom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinerAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinerAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionDefinerAtom(this);
else return visitor.visitChildren(this);
}
}
public final PartitionDefinerAtomContext partitionDefinerAtom() throws RecognitionException {
PartitionDefinerAtomContext _localctx = new PartitionDefinerAtomContext(_ctx, getState());
enterRule(_localctx, 120, RULE_partitionDefinerAtom);
try {
setState(2261);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2258);
constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2259);
expression(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2260);
match(MAXVALUE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionDefinerVectorContext extends ParserRuleContext {
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List partitionDefinerAtom() {
return getRuleContexts(PartitionDefinerAtomContext.class);
}
public PartitionDefinerAtomContext partitionDefinerAtom(int i) {
return getRuleContext(PartitionDefinerAtomContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); }
public List COMMA() { return getTokens(MySqlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MySqlParser.COMMA, i);
}
public PartitionDefinerVectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionDefinerVector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinerVector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinerVector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionDefinerVector(this);
else return visitor.visitChildren(this);
}
}
public final PartitionDefinerVectorContext partitionDefinerVector() throws RecognitionException {
PartitionDefinerVectorContext _localctx = new PartitionDefinerVectorContext(_ctx, getState());
enterRule(_localctx, 122, RULE_partitionDefinerVector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2263);
match(LR_BRACKET);
setState(2264);
partitionDefinerAtom();
setState(2267);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2265);
match(COMMA);
setState(2266);
partitionDefinerAtom();
}
}
setState(2269);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(2271);
match(RR_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubpartitionDefinitionContext extends ParserRuleContext {
public TerminalNode SUBPARTITION() { return getToken(MySqlParser.SUBPARTITION, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public List partitionOption() {
return getRuleContexts(PartitionOptionContext.class);
}
public PartitionOptionContext partitionOption(int i) {
return getRuleContext(PartitionOptionContext.class,i);
}
public SubpartitionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subpartitionDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubpartitionDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubpartitionDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitSubpartitionDefinition(this);
else return visitor.visitChildren(this);
}
}
public final SubpartitionDefinitionContext subpartitionDefinition() throws RecognitionException {
SubpartitionDefinitionContext _localctx = new SubpartitionDefinitionContext(_ctx, getState());
enterRule(_localctx, 124, RULE_subpartitionDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2273);
match(SUBPARTITION);
setState(2274);
uid();
setState(2278);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==INDEX || ((((_la - 368)) & ~0x3f) == 0 && ((1L << (_la - 368)) & 2199024304129L) != 0) || ((((_la - 500)) & ~0x3f) == 0 && ((1L << (_la - 500)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) {
{
{
setState(2275);
partitionOption();
}
}
setState(2280);
_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 PartitionOptionContext extends ParserRuleContext {
public PartitionOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionOption; }
public PartitionOptionContext() { }
public void copyFrom(PartitionOptionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionCommentContext extends PartitionOptionContext {
public Token comment;
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionCommentContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionComment(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionNodeGroupContext extends PartitionOptionContext {
public UidContext nodegroup;
public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionNodeGroupContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionNodeGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionNodeGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionNodeGroup(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionIndexDirectoryContext extends PartitionOptionContext {
public Token indexDirectory;
public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); }
public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionIndexDirectoryContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionIndexDirectory(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionIndexDirectory(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionIndexDirectory(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionMaxRowsContext extends PartitionOptionContext {
public DecimalLiteralContext maxRows;
public TerminalNode MAX_ROWS() { return getToken(MySqlParser.MAX_ROWS, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionMaxRowsContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionMaxRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionMaxRows(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionMaxRows(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionTablespaceContext extends PartitionOptionContext {
public UidContext tablespace;
public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionTablespaceContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionTablespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionTablespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionTablespace(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionEngineContext extends PartitionOptionContext {
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); }
public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionEngineContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionEngine(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionEngine(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionEngine(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionMinRowsContext extends PartitionOptionContext {
public DecimalLiteralContext minRows;
public TerminalNode MIN_ROWS() { return getToken(MySqlParser.MIN_ROWS, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionMinRowsContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionMinRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionMinRows(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionMinRows(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PartitionOptionDataDirectoryContext extends PartitionOptionContext {
public Token dataDirectory;
public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); }
public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); }
public PartitionOptionDataDirectoryContext(PartitionOptionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionDataDirectory(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionDataDirectory(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitPartitionOptionDataDirectory(this);
else return visitor.visitChildren(this);
}
}
public final PartitionOptionContext partitionOption() throws RecognitionException {
PartitionOptionContext _localctx = new PartitionOptionContext(_ctx, getState());
enterRule(_localctx, 126, RULE_partitionOption);
int _la;
try {
setState(2329);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
case ENGINE:
case STORAGE:
_localctx = new PartitionOptionEngineContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(2281);
match(DEFAULT);
}
}
setState(2285);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORAGE) {
{
setState(2284);
match(STORAGE);
}
}
setState(2287);
match(ENGINE);
setState(2289);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2288);
match(EQUAL_SYMBOL);
}
}
setState(2291);
engineName();
}
break;
case COMMENT:
_localctx = new PartitionOptionCommentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2292);
match(COMMENT);
setState(2294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2293);
match(EQUAL_SYMBOL);
}
}
setState(2296);
((PartitionOptionCommentContext)_localctx).comment = match(STRING_LITERAL);
}
break;
case DATA:
_localctx = new PartitionOptionDataDirectoryContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2297);
match(DATA);
setState(2298);
match(DIRECTORY);
setState(2300);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2299);
match(EQUAL_SYMBOL);
}
}
setState(2302);
((PartitionOptionDataDirectoryContext)_localctx).dataDirectory = match(STRING_LITERAL);
}
break;
case INDEX:
_localctx = new PartitionOptionIndexDirectoryContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2303);
match(INDEX);
setState(2304);
match(DIRECTORY);
setState(2306);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2305);
match(EQUAL_SYMBOL);
}
}
setState(2308);
((PartitionOptionIndexDirectoryContext)_localctx).indexDirectory = match(STRING_LITERAL);
}
break;
case MAX_ROWS:
_localctx = new PartitionOptionMaxRowsContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2309);
match(MAX_ROWS);
setState(2311);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2310);
match(EQUAL_SYMBOL);
}
}
setState(2313);
((PartitionOptionMaxRowsContext)_localctx).maxRows = decimalLiteral();
}
break;
case MIN_ROWS:
_localctx = new PartitionOptionMinRowsContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2314);
match(MIN_ROWS);
setState(2316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2315);
match(EQUAL_SYMBOL);
}
}
setState(2318);
((PartitionOptionMinRowsContext)_localctx).minRows = decimalLiteral();
}
break;
case TABLESPACE:
_localctx = new PartitionOptionTablespaceContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2319);
match(TABLESPACE);
setState(2321);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2320);
match(EQUAL_SYMBOL);
}
}
setState(2323);
((PartitionOptionTablespaceContext)_localctx).tablespace = uid();
}
break;
case NODEGROUP:
_localctx = new PartitionOptionNodeGroupContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2324);
match(NODEGROUP);
setState(2326);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2325);
match(EQUAL_SYMBOL);
}
}
setState(2328);
((PartitionOptionNodeGroupContext)_localctx).nodegroup = uid();
}
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 AlterDatabaseContext extends ParserRuleContext {
public AlterDatabaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterDatabase; }
public AlterDatabaseContext() { }
public void copyFrom(AlterDatabaseContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterUpgradeNameContext extends AlterDatabaseContext {
public Token dbFormat;
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode UPGRADE() { return getToken(MySqlParser.UPGRADE, 0); }
public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); }
public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); }
public TerminalNode NAME() { return getToken(MySqlParser.NAME, 0); }
public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); }
public AlterUpgradeNameContext(AlterDatabaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterUpgradeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterUpgradeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterUpgradeName(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AlterSimpleDatabaseContext extends AlterDatabaseContext {
public Token dbFormat;
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public List createDatabaseOption() {
return getRuleContexts(CreateDatabaseOptionContext.class);
}
public CreateDatabaseOptionContext createDatabaseOption(int i) {
return getRuleContext(CreateDatabaseOptionContext.class,i);
}
public AlterSimpleDatabaseContext(AlterDatabaseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterSimpleDatabase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterSimpleDatabase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterSimpleDatabase(this);
else return visitor.visitChildren(this);
}
}
public final AlterDatabaseContext alterDatabase() throws RecognitionException {
AlterDatabaseContext _localctx = new AlterDatabaseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_alterDatabase);
int _la;
try {
setState(2349);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,279,_ctx) ) {
case 1:
_localctx = new AlterSimpleDatabaseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2331);
match(ALTER);
setState(2332);
((AlterSimpleDatabaseContext)_localctx).dbFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
((AlterSimpleDatabaseContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,277,_ctx) ) {
case 1:
{
setState(2333);
uid();
}
break;
}
setState(2337);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2336);
createDatabaseOption();
}
}
setState(2339);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 4398214283264L) != 0) || _la==READ || _la==CHAR || _la==ENCRYPTION || _la==CHARSET );
}
break;
case 2:
_localctx = new AlterUpgradeNameContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2341);
match(ALTER);
setState(2342);
((AlterUpgradeNameContext)_localctx).dbFormat = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==SCHEMA) ) {
((AlterUpgradeNameContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2343);
uid();
setState(2344);
match(UPGRADE);
setState(2345);
match(DATA);
setState(2346);
match(DIRECTORY);
setState(2347);
match(NAME);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterEventContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); }
public List fullId() {
return getRuleContexts(FullIdContext.class);
}
public FullIdContext fullId(int i) {
return getRuleContext(FullIdContext.class,i);
}
public OwnerStatementContext ownerStatement() {
return getRuleContext(OwnerStatementContext.class,0);
}
public List ON() { return getTokens(MySqlParser.ON); }
public TerminalNode ON(int i) {
return getToken(MySqlParser.ON, i);
}
public TerminalNode SCHEDULE() { return getToken(MySqlParser.SCHEDULE, 0); }
public ScheduleExpressionContext scheduleExpression() {
return getRuleContext(ScheduleExpressionContext.class,0);
}
public TerminalNode COMPLETION() { return getToken(MySqlParser.COMPLETION, 0); }
public TerminalNode PRESERVE() { return getToken(MySqlParser.PRESERVE, 0); }
public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); }
public TerminalNode TO() { return getToken(MySqlParser.TO, 0); }
public EnableTypeContext enableType() {
return getRuleContext(EnableTypeContext.class,0);
}
public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode DO() { return getToken(MySqlParser.DO, 0); }
public RoutineBodyContext routineBody() {
return getRuleContext(RoutineBodyContext.class,0);
}
public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); }
public AlterEventContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterEvent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterEvent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterEvent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterEvent(this);
else return visitor.visitChildren(this);
}
}
public final AlterEventContext alterEvent() throws RecognitionException {
AlterEventContext _localctx = new AlterEventContext(_ctx, getState());
enterRule(_localctx, 130, RULE_alterEvent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2351);
match(ALTER);
setState(2353);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINER) {
{
setState(2352);
ownerStatement();
}
}
setState(2355);
match(EVENT);
setState(2356);
fullId();
setState(2360);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) {
case 1:
{
setState(2357);
match(ON);
setState(2358);
match(SCHEDULE);
setState(2359);
scheduleExpression();
}
break;
}
setState(2368);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(2362);
match(ON);
setState(2363);
match(COMPLETION);
setState(2365);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(2364);
match(NOT);
}
}
setState(2367);
match(PRESERVE);
}
}
setState(2373);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,284,_ctx) ) {
case 1:
{
setState(2370);
match(RENAME);
setState(2371);
match(TO);
setState(2372);
fullId();
}
break;
}
setState(2376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISABLE || _la==ENABLE) {
{
setState(2375);
enableType();
}
}
setState(2380);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(2378);
match(COMMENT);
setState(2379);
match(STRING_LITERAL);
}
}
setState(2384);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) {
case 1:
{
setState(2382);
match(DO);
setState(2383);
routineBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterFunctionContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public List routineOption() {
return getRuleContexts(RoutineOptionContext.class);
}
public RoutineOptionContext routineOption(int i) {
return getRuleContext(RoutineOptionContext.class,i);
}
public AlterFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterFunction(this);
else return visitor.visitChildren(this);
}
}
public final AlterFunctionContext alterFunction() throws RecognitionException {
AlterFunctionContext _localctx = new AlterFunctionContext(_ctx, getState());
enterRule(_localctx, 132, RULE_alterFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2386);
match(ALTER);
setState(2387);
match(FUNCTION);
setState(2388);
fullId();
setState(2392);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DETERMINISTIC || ((((_la - 112)) & ~0x3f) == 0 && ((1L << (_la - 112)) & 281474985099269L) != 0) || _la==COMMENT || _la==CONTAINS || _la==LANGUAGE || _la==NO) {
{
{
setState(2389);
routineOption();
}
}
setState(2394);
_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 AlterInstanceContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode INSTANCE() { return getToken(MySqlParser.INSTANCE, 0); }
public TerminalNode ROTATE() { return getToken(MySqlParser.ROTATE, 0); }
public TerminalNode INNODB() { return getToken(MySqlParser.INNODB, 0); }
public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); }
public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); }
public AlterInstanceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterInstance; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterInstance(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterInstance(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterInstance(this);
else return visitor.visitChildren(this);
}
}
public final AlterInstanceContext alterInstance() throws RecognitionException {
AlterInstanceContext _localctx = new AlterInstanceContext(_ctx, getState());
enterRule(_localctx, 134, RULE_alterInstance);
try {
enterOuterAlt(_localctx, 1);
{
setState(2395);
match(ALTER);
setState(2396);
match(INSTANCE);
setState(2397);
match(ROTATE);
setState(2398);
match(INNODB);
setState(2399);
match(MASTER);
setState(2400);
match(KEY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterLogfileGroupContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); }
public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); }
public TerminalNode UNDOFILE() { return getToken(MySqlParser.UNDOFILE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); }
public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); }
public EngineNameContext engineName() {
return getRuleContext(EngineNameContext.class,0);
}
public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); }
public FileSizeLiteralContext fileSizeLiteral() {
return getRuleContext(FileSizeLiteralContext.class,0);
}
public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); }
public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); }
public TerminalNode EQUAL_SYMBOL(int i) {
return getToken(MySqlParser.EQUAL_SYMBOL, i);
}
public AlterLogfileGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterLogfileGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterLogfileGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterLogfileGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterLogfileGroup(this);
else return visitor.visitChildren(this);
}
}
public final AlterLogfileGroupContext alterLogfileGroup() throws RecognitionException {
AlterLogfileGroupContext _localctx = new AlterLogfileGroupContext(_ctx, getState());
enterRule(_localctx, 136, RULE_alterLogfileGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2402);
match(ALTER);
setState(2403);
match(LOGFILE);
setState(2404);
match(GROUP);
setState(2405);
uid();
setState(2406);
match(ADD);
setState(2407);
match(UNDOFILE);
setState(2408);
match(STRING_LITERAL);
setState(2414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIAL_SIZE) {
{
setState(2409);
match(INITIAL_SIZE);
setState(2411);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2410);
match(EQUAL_SYMBOL);
}
}
setState(2413);
fileSizeLiteral();
}
}
setState(2417);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WAIT) {
{
setState(2416);
match(WAIT);
}
}
setState(2419);
match(ENGINE);
setState(2421);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUAL_SYMBOL) {
{
setState(2420);
match(EQUAL_SYMBOL);
}
}
setState(2423);
engineName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AlterProcedureContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); }
public FullIdContext fullId() {
return getRuleContext(FullIdContext.class,0);
}
public List routineOption() {
return getRuleContexts(RoutineOptionContext.class);
}
public RoutineOptionContext routineOption(int i) {
return getRuleContext(RoutineOptionContext.class,i);
}
public AlterProcedureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alterProcedure; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterProcedure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterProcedure(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof MySqlParserVisitor ) return ((MySqlParserVisitor)visitor).visitAlterProcedure(this);
else return visitor.visitChildren(this);
}
}
public final AlterProcedureContext alterProcedure() throws RecognitionException {
AlterProcedureContext _localctx = new AlterProcedureContext(_ctx, getState());
enterRule(_localctx, 138, RULE_alterProcedure);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2425);
match(ALTER);
setState(2426);
match(PROCEDURE);
setState(2427);
fullId();
setState(2431);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DETERMINISTIC || ((((_la - 112)) & ~0x3f) == 0 && ((1L << (_la - 112)) & 281474985099269L) != 0) || _la==COMMENT || _la==CONTAINS || _la==LANGUAGE || _la==NO) {
{
{
setState(2428);
routineOption();
}
}
setState(2433);
_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 AlterServerContext extends ParserRuleContext {
public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); }
public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); }
public UidContext uid() {
return getRuleContext(UidContext.class,0);
}
public TerminalNode OPTIONS() { return getToken(MySqlParser.OPTIONS, 0); }
public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); }
public List 