mirror of
https://gitee.com/dromara/mayfly-go
synced 2025-11-07 01:40:25 +08:00
136804 lines
3.8 MiB
136804 lines
3.8 MiB
// Code generated from MySqlParser.g4 by ANTLR 4.13.1. DO NOT EDIT.
|
|
|
|
package parser // MySqlParser
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"github.com/antlr4-go/antlr/v4"
|
|
)
|
|
|
|
// Suppress unused import errors
|
|
var _ = fmt.Printf
|
|
var _ = strconv.Itoa
|
|
var _ = sync.Once{}
|
|
|
|
type MySqlParser struct {
|
|
*antlr.BaseParser
|
|
}
|
|
|
|
var MySqlParserParserStaticData struct {
|
|
once sync.Once
|
|
serializedATN []int32
|
|
LiteralNames []string
|
|
SymbolicNames []string
|
|
RuleNames []string
|
|
PredictionContextCache *antlr.PredictionContextCache
|
|
atn *antlr.ATN
|
|
decisionToDFA []*antlr.DFA
|
|
}
|
|
|
|
func mysqlparserParserInit() {
|
|
staticData := &MySqlParserParserStaticData
|
|
staticData.LiteralNames = []string{
|
|
"", "", "", "", "", "'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'", "", "'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'", "'''", "'\"'", "'`'", "':'",
|
|
}
|
|
staticData.SymbolicNames = []string{
|
|
"", "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",
|
|
}
|
|
staticData.RuleNames = []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",
|
|
}
|
|
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
|
|
staticData.serializedATN = []int32{
|
|
4, 1, 1161, 7450, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4,
|
|
7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10,
|
|
7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7,
|
|
15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20,
|
|
2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2,
|
|
26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31,
|
|
7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7,
|
|
36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41,
|
|
2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2,
|
|
47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52,
|
|
7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7,
|
|
57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62,
|
|
2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2,
|
|
68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73,
|
|
7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7,
|
|
78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83,
|
|
2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2,
|
|
89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94,
|
|
7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7,
|
|
99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2,
|
|
104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7,
|
|
108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2,
|
|
113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7,
|
|
117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2,
|
|
122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7,
|
|
126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2,
|
|
131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7,
|
|
135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2,
|
|
140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7,
|
|
144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2,
|
|
149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7,
|
|
153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2,
|
|
158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7,
|
|
162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2,
|
|
167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7,
|
|
171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2,
|
|
176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7,
|
|
180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2,
|
|
185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7,
|
|
189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2,
|
|
194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7,
|
|
198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2,
|
|
203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7,
|
|
207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2,
|
|
212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7,
|
|
216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2,
|
|
221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7,
|
|
225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2,
|
|
230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7,
|
|
234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2,
|
|
239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7,
|
|
243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2,
|
|
248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7,
|
|
252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2,
|
|
257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7,
|
|
261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2,
|
|
266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7,
|
|
270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2,
|
|
275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7,
|
|
279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2,
|
|
284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7,
|
|
288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2,
|
|
293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7,
|
|
297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2,
|
|
302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7,
|
|
306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2,
|
|
311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7,
|
|
315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2,
|
|
320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7,
|
|
324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2,
|
|
329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7,
|
|
333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2,
|
|
338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7,
|
|
342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2,
|
|
347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7,
|
|
351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2,
|
|
356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7,
|
|
360, 1, 0, 3, 0, 724, 8, 0, 1, 0, 1, 0, 3, 0, 728, 8, 0, 1, 0, 1, 0, 1,
|
|
1, 1, 1, 1, 1, 3, 1, 735, 8, 1, 1, 1, 3, 1, 738, 8, 1, 1, 1, 5, 1, 741,
|
|
8, 1, 10, 1, 12, 1, 744, 9, 1, 1, 1, 1, 1, 1, 1, 3, 1, 749, 8, 1, 1, 1,
|
|
3, 1, 752, 8, 1, 1, 1, 3, 1, 755, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
|
|
2, 1, 2, 3, 2, 764, 8, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1,
|
|
4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1,
|
|
4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1,
|
|
4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 806, 8, 4, 1,
|
|
5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1,
|
|
5, 3, 5, 821, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1,
|
|
6, 3, 6, 832, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1,
|
|
7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 849, 8, 7, 1, 8, 1, 8, 1,
|
|
8, 3, 8, 854, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1,
|
|
9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 869, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10,
|
|
1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1,
|
|
10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10,
|
|
3, 10, 896, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3,
|
|
11, 905, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 910, 8, 12, 1, 12, 1, 12, 5,
|
|
12, 914, 8, 12, 10, 12, 12, 12, 917, 9, 12, 1, 13, 1, 13, 3, 13, 921, 8,
|
|
13, 1, 13, 1, 13, 3, 13, 925, 8, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13,
|
|
1, 13, 1, 13, 3, 13, 934, 8, 13, 1, 13, 3, 13, 937, 8, 13, 1, 13, 3, 13,
|
|
940, 8, 13, 1, 13, 1, 13, 3, 13, 944, 8, 13, 1, 13, 1, 13, 1, 13, 1, 14,
|
|
1, 14, 3, 14, 951, 8, 14, 1, 14, 3, 14, 954, 8, 14, 1, 14, 1, 14, 1, 14,
|
|
3, 14, 959, 8, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 965, 8, 14, 10, 14,
|
|
12, 14, 968, 9, 14, 1, 14, 1, 14, 3, 14, 972, 8, 14, 1, 14, 1, 14, 1, 14,
|
|
3, 14, 977, 8, 14, 1, 14, 5, 14, 980, 8, 14, 10, 14, 12, 14, 983, 9, 14,
|
|
1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 994,
|
|
8, 15, 1, 15, 3, 15, 997, 8, 15, 1, 15, 1, 15, 3, 15, 1001, 8, 15, 1, 15,
|
|
3, 15, 1004, 8, 15, 1, 15, 1, 15, 3, 15, 1008, 8, 15, 1, 15, 3, 15, 1011,
|
|
8, 15, 1, 15, 1, 15, 3, 15, 1015, 8, 15, 1, 15, 3, 15, 1018, 8, 15, 1,
|
|
15, 3, 15, 1021, 8, 15, 1, 15, 1, 15, 3, 15, 1025, 8, 15, 1, 15, 3, 15,
|
|
1028, 8, 15, 1, 15, 1, 15, 3, 15, 1032, 8, 15, 1, 15, 1, 15, 1, 16, 1,
|
|
16, 3, 16, 1038, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1044, 8, 16,
|
|
1, 16, 1, 16, 5, 16, 1048, 8, 16, 10, 16, 12, 16, 1051, 9, 16, 1, 16, 1,
|
|
16, 5, 16, 1055, 8, 16, 10, 16, 12, 16, 1058, 9, 16, 1, 16, 1, 16, 1, 17,
|
|
1, 17, 3, 17, 1064, 8, 17, 1, 17, 3, 17, 1067, 8, 17, 1, 17, 1, 17, 3,
|
|
17, 1071, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1076, 8, 17, 1, 17, 1, 17,
|
|
5, 17, 1080, 8, 17, 10, 17, 12, 17, 1083, 9, 17, 1, 17, 1, 17, 1, 17, 1,
|
|
17, 5, 17, 1089, 8, 17, 10, 17, 12, 17, 1092, 9, 17, 1, 17, 1, 17, 3, 17,
|
|
1096, 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 1101, 8, 18, 1, 18, 1, 18, 1,
|
|
18, 5, 18, 1106, 8, 18, 10, 18, 12, 18, 1109, 9, 18, 1, 19, 1, 19, 1, 19,
|
|
1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 1123,
|
|
8, 19, 10, 19, 12, 19, 1126, 9, 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20,
|
|
1132, 8, 20, 1, 20, 1, 20, 3, 20, 1136, 8, 20, 1, 20, 1, 20, 1, 20, 1,
|
|
20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 1146, 8, 20, 1, 20, 1, 20, 3, 20,
|
|
1150, 8, 20, 1, 20, 1, 20, 3, 20, 1154, 8, 20, 1, 20, 1, 20, 3, 20, 1158,
|
|
8, 20, 1, 20, 1, 20, 3, 20, 1162, 8, 20, 1, 20, 5, 20, 1165, 8, 20, 10,
|
|
20, 12, 20, 1168, 9, 20, 3, 20, 1170, 8, 20, 1, 20, 3, 20, 1173, 8, 20,
|
|
1, 20, 3, 20, 1176, 8, 20, 1, 20, 3, 20, 1179, 8, 20, 1, 20, 1, 20, 1,
|
|
20, 1, 20, 3, 20, 1185, 8, 20, 1, 20, 1, 20, 3, 20, 1189, 8, 20, 1, 20,
|
|
1, 20, 1, 20, 1, 20, 3, 20, 1195, 8, 20, 1, 20, 5, 20, 1198, 8, 20, 10,
|
|
20, 12, 20, 1201, 9, 20, 3, 20, 1203, 8, 20, 1, 20, 3, 20, 1206, 8, 20,
|
|
3, 20, 1208, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1,
|
|
21, 1, 21, 3, 21, 1219, 8, 21, 1, 21, 1, 21, 3, 21, 1223, 8, 21, 1, 21,
|
|
3, 21, 1226, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1,
|
|
22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1240, 8, 22, 1, 22, 3, 22, 1243,
|
|
8, 22, 1, 22, 1, 22, 3, 22, 1247, 8, 22, 1, 22, 3, 22, 1250, 8, 22, 1,
|
|
22, 1, 22, 3, 22, 1254, 8, 22, 1, 22, 3, 22, 1257, 8, 22, 1, 22, 1, 22,
|
|
3, 22, 1261, 8, 22, 1, 22, 3, 22, 1264, 8, 22, 1, 22, 1, 22, 3, 22, 1268,
|
|
8, 22, 1, 22, 3, 22, 1271, 8, 22, 1, 22, 3, 22, 1274, 8, 22, 1, 22, 1,
|
|
22, 3, 22, 1278, 8, 22, 1, 22, 3, 22, 1281, 8, 22, 1, 22, 1, 22, 3, 22,
|
|
1285, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 3, 23, 1291, 8, 23, 1, 23, 1,
|
|
23, 3, 23, 1295, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23,
|
|
1, 23, 1, 23, 1, 23, 3, 23, 1307, 8, 23, 1, 23, 1, 23, 1, 24, 1, 24, 3,
|
|
24, 1313, 8, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25,
|
|
1322, 8, 25, 10, 25, 12, 25, 1325, 9, 25, 1, 25, 1, 25, 3, 25, 1329, 8,
|
|
25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1337, 8, 25, 1, 26,
|
|
1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 3, 28, 1345, 8, 28, 1, 28, 1, 28, 1,
|
|
28, 3, 28, 1350, 8, 28, 1, 28, 3, 28, 1353, 8, 28, 1, 28, 1, 28, 1, 28,
|
|
3, 28, 1358, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1366,
|
|
8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1371, 8, 28, 1, 28, 1, 28, 1, 28, 1,
|
|
28, 3, 28, 1377, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1382, 8, 28, 1, 28,
|
|
1, 28, 3, 28, 1386, 8, 28, 3, 28, 1388, 8, 28, 1, 29, 3, 29, 1391, 8, 29,
|
|
1, 29, 1, 29, 3, 29, 1395, 8, 29, 1, 29, 1, 29, 3, 29, 1399, 8, 29, 1,
|
|
29, 3, 29, 1402, 8, 29, 1, 29, 1, 29, 3, 29, 1406, 8, 29, 1, 29, 1, 29,
|
|
3, 29, 1410, 8, 29, 1, 29, 1, 29, 3, 29, 1414, 8, 29, 1, 29, 1, 29, 1,
|
|
29, 1, 29, 3, 29, 1420, 8, 29, 1, 29, 3, 29, 1423, 8, 29, 1, 30, 1, 30,
|
|
1, 30, 1, 30, 1, 30, 3, 30, 1430, 8, 30, 1, 31, 1, 31, 1, 31, 3, 31, 1435,
|
|
8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1441, 8, 32, 1, 33, 1, 33, 1,
|
|
33, 5, 33, 1446, 8, 33, 10, 33, 12, 33, 1449, 9, 33, 1, 33, 1, 33, 1, 33,
|
|
3, 33, 1454, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 1460, 8, 33, 10,
|
|
33, 12, 33, 1463, 9, 33, 3, 33, 1465, 8, 33, 1, 33, 1, 33, 1, 33, 5, 33,
|
|
1470, 8, 33, 10, 33, 12, 33, 1473, 9, 33, 3, 33, 1475, 8, 33, 3, 33, 1477,
|
|
8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1483, 8, 34, 1, 35, 1, 35, 1,
|
|
35, 1, 35, 3, 35, 1489, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36,
|
|
1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1506,
|
|
8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1513, 8, 37, 1, 38, 1,
|
|
38, 1, 38, 1, 39, 1, 39, 3, 39, 1520, 8, 39, 1, 39, 1, 39, 1, 39, 1, 39,
|
|
1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1532, 8, 39, 1, 39, 1,
|
|
39, 1, 39, 3, 39, 1537, 8, 39, 1, 39, 3, 39, 1540, 8, 39, 1, 40, 3, 40,
|
|
1543, 8, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1,
|
|
42, 1, 42, 1, 42, 3, 42, 1556, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42,
|
|
1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1569, 8, 42, 1, 42, 1,
|
|
42, 1, 42, 3, 42, 1574, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43,
|
|
1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1590, 8,
|
|
43, 1, 44, 1, 44, 1, 44, 1, 44, 5, 44, 1596, 8, 44, 10, 44, 12, 44, 1599,
|
|
9, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1608, 8,
|
|
45, 1, 45, 3, 45, 1611, 8, 45, 1, 45, 3, 45, 1614, 8, 45, 1, 46, 1, 46,
|
|
5, 46, 1618, 8, 46, 10, 46, 12, 46, 1621, 9, 46, 1, 46, 3, 46, 1624, 8,
|
|
46, 1, 46, 3, 46, 1627, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47,
|
|
1, 47, 1, 47, 1, 47, 3, 47, 1638, 8, 47, 1, 47, 3, 47, 1641, 8, 47, 1,
|
|
47, 1, 47, 1, 47, 3, 47, 1646, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47,
|
|
1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1659, 8, 47, 1, 47, 1,
|
|
47, 1, 47, 1, 47, 1, 47, 3, 47, 1666, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47,
|
|
1, 47, 3, 47, 1673, 8, 47, 3, 47, 1675, 8, 47, 1, 47, 1, 47, 1, 47, 1,
|
|
47, 1, 47, 3, 47, 1682, 8, 47, 1, 48, 1, 48, 3, 48, 1686, 8, 48, 3, 48,
|
|
1688, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1693, 8, 48, 1, 48, 3, 48, 1696,
|
|
8, 48, 1, 48, 1, 48, 5, 48, 1700, 8, 48, 10, 48, 12, 48, 1703, 9, 48, 1,
|
|
48, 1, 48, 3, 48, 1707, 8, 48, 3, 48, 1709, 8, 48, 1, 48, 1, 48, 3, 48,
|
|
1713, 8, 48, 1, 48, 3, 48, 1716, 8, 48, 1, 48, 3, 48, 1719, 8, 48, 1, 48,
|
|
1, 48, 5, 48, 1723, 8, 48, 10, 48, 12, 48, 1726, 9, 48, 1, 48, 1, 48, 3,
|
|
48, 1730, 8, 48, 3, 48, 1732, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1737,
|
|
8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1744, 8, 48, 3, 48, 1746,
|
|
8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1753, 8, 48, 1, 49, 1,
|
|
49, 1, 49, 3, 49, 1758, 8, 49, 1, 49, 1, 49, 3, 49, 1762, 8, 49, 1, 49,
|
|
3, 49, 1765, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1773,
|
|
8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1781, 8, 50, 3,
|
|
50, 1783, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51,
|
|
3, 51, 1793, 8, 51, 1, 52, 1, 52, 3, 52, 1797, 8, 52, 1, 52, 3, 52, 1800,
|
|
8, 52, 1, 52, 1, 52, 5, 52, 1804, 8, 52, 10, 52, 12, 52, 1807, 9, 52, 1,
|
|
52, 1, 52, 3, 52, 1811, 8, 52, 1, 52, 3, 52, 1814, 8, 52, 1, 52, 1, 52,
|
|
5, 52, 1818, 8, 52, 10, 52, 12, 52, 1821, 9, 52, 3, 52, 1823, 8, 52, 1,
|
|
53, 1, 53, 3, 53, 1827, 8, 53, 1, 53, 3, 53, 1830, 8, 53, 1, 53, 1, 53,
|
|
3, 53, 1834, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1839, 8, 53, 1, 53, 1,
|
|
53, 1, 53, 3, 53, 1844, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1849, 8, 53,
|
|
1, 53, 1, 53, 3, 53, 1853, 8, 53, 1, 53, 1, 53, 3, 53, 1857, 8, 53, 1,
|
|
53, 1, 53, 3, 53, 1861, 8, 53, 1, 53, 1, 53, 3, 53, 1865, 8, 53, 1, 53,
|
|
1, 53, 3, 53, 1869, 8, 53, 1, 53, 1, 53, 3, 53, 1873, 8, 53, 1, 53, 1,
|
|
53, 1, 53, 3, 53, 1878, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1883, 8, 53,
|
|
1, 53, 1, 53, 1, 53, 3, 53, 1888, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3,
|
|
53, 1894, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1899, 8, 53, 1, 53, 1, 53,
|
|
1, 53, 3, 53, 1904, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1909, 8, 53, 1,
|
|
53, 1, 53, 1, 53, 3, 53, 1914, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1919,
|
|
8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1925, 8, 53, 1, 53, 1, 53, 1,
|
|
53, 3, 53, 1930, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1935, 8, 53, 1, 53,
|
|
1, 53, 1, 53, 3, 53, 1940, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1945, 8,
|
|
53, 1, 53, 1, 53, 1, 53, 3, 53, 1950, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53,
|
|
1955, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1960, 8, 53, 1, 53, 1, 53, 1,
|
|
53, 1, 53, 1, 53, 3, 53, 1967, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1972,
|
|
8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1977, 8, 53, 1, 53, 1, 53, 1, 53, 3,
|
|
53, 1982, 8, 53, 1, 53, 1, 53, 3, 53, 1986, 8, 53, 1, 53, 1, 53, 1, 53,
|
|
3, 53, 1991, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1999,
|
|
8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 2004, 8, 53, 1, 53, 1, 53, 1, 53, 1,
|
|
53, 3, 53, 2010, 8, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56,
|
|
1, 56, 1, 56, 1, 56, 3, 56, 2022, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1,
|
|
56, 3, 56, 2029, 8, 56, 3, 56, 2031, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56,
|
|
5, 56, 2037, 8, 56, 10, 56, 12, 56, 2040, 9, 56, 1, 56, 1, 56, 3, 56, 2044,
|
|
8, 56, 1, 57, 3, 57, 2047, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1,
|
|
57, 3, 57, 2055, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2061, 8, 57,
|
|
1, 57, 1, 57, 3, 57, 2065, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1,
|
|
57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2078, 8, 57, 1, 57, 1, 57,
|
|
1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2090, 8,
|
|
57, 3, 57, 2092, 8, 57, 1, 58, 3, 58, 2095, 8, 58, 1, 58, 1, 58, 1, 58,
|
|
1, 58, 1, 58, 1, 58, 3, 58, 2103, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3,
|
|
58, 2109, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2115, 8, 58, 1, 59,
|
|
1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2126, 8,
|
|
59, 10, 59, 12, 59, 2129, 9, 59, 1, 59, 1, 59, 5, 59, 2133, 8, 59, 10,
|
|
59, 12, 59, 2136, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2142, 8, 59,
|
|
10, 59, 12, 59, 2145, 9, 59, 1, 59, 1, 59, 3, 59, 2149, 8, 59, 1, 59, 1,
|
|
59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2158, 8, 59, 10, 59, 12,
|
|
59, 2161, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2167, 8, 59, 10, 59,
|
|
12, 59, 2170, 9, 59, 1, 59, 1, 59, 3, 59, 2174, 8, 59, 1, 59, 1, 59, 1,
|
|
59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2184, 8, 59, 10, 59, 12,
|
|
59, 2187, 9, 59, 1, 59, 1, 59, 5, 59, 2191, 8, 59, 10, 59, 12, 59, 2194,
|
|
9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2200, 8, 59, 10, 59, 12, 59,
|
|
2203, 9, 59, 1, 59, 1, 59, 3, 59, 2207, 8, 59, 1, 59, 1, 59, 1, 59, 1,
|
|
59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2217, 8, 59, 10, 59, 12, 59, 2220,
|
|
9, 59, 1, 59, 1, 59, 5, 59, 2224, 8, 59, 10, 59, 12, 59, 2227, 9, 59, 1,
|
|
59, 1, 59, 1, 59, 1, 59, 5, 59, 2233, 8, 59, 10, 59, 12, 59, 2236, 9, 59,
|
|
1, 59, 1, 59, 3, 59, 2240, 8, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2245, 8,
|
|
59, 10, 59, 12, 59, 2248, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2254,
|
|
8, 59, 10, 59, 12, 59, 2257, 9, 59, 1, 59, 1, 59, 3, 59, 2261, 8, 59, 3,
|
|
59, 2263, 8, 59, 1, 60, 1, 60, 1, 60, 3, 60, 2268, 8, 60, 1, 61, 1, 61,
|
|
1, 61, 1, 61, 4, 61, 2274, 8, 61, 11, 61, 12, 61, 2275, 1, 61, 1, 61, 1,
|
|
62, 1, 62, 1, 62, 5, 62, 2283, 8, 62, 10, 62, 12, 62, 2286, 9, 62, 1, 63,
|
|
3, 63, 2289, 8, 63, 1, 63, 3, 63, 2292, 8, 63, 1, 63, 1, 63, 3, 63, 2296,
|
|
8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2301, 8, 63, 1, 63, 1, 63, 1, 63, 1,
|
|
63, 3, 63, 2307, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2313, 8, 63,
|
|
1, 63, 1, 63, 1, 63, 3, 63, 2318, 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2323,
|
|
8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2328, 8, 63, 1, 63, 1, 63, 1, 63, 3,
|
|
63, 2333, 8, 63, 1, 63, 3, 63, 2336, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64,
|
|
2341, 8, 64, 1, 64, 4, 64, 2344, 8, 64, 11, 64, 12, 64, 2345, 1, 64, 1,
|
|
64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2356, 8, 64, 1, 65,
|
|
1, 65, 3, 65, 2360, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2367,
|
|
8, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2372, 8, 65, 1, 65, 3, 65, 2375, 8,
|
|
65, 1, 65, 1, 65, 1, 65, 3, 65, 2380, 8, 65, 1, 65, 3, 65, 2383, 8, 65,
|
|
1, 65, 1, 65, 3, 65, 2387, 8, 65, 1, 65, 1, 65, 3, 65, 2391, 8, 65, 1,
|
|
66, 1, 66, 1, 66, 1, 66, 5, 66, 2397, 8, 66, 10, 66, 12, 66, 2400, 9, 66,
|
|
1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1,
|
|
68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2418, 8, 68, 1, 68, 3, 68,
|
|
2421, 8, 68, 1, 68, 3, 68, 2424, 8, 68, 1, 68, 1, 68, 3, 68, 2428, 8, 68,
|
|
1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 2436, 8, 69, 10, 69, 12,
|
|
69, 2439, 9, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70,
|
|
5, 70, 2449, 8, 70, 10, 70, 12, 70, 2452, 9, 70, 1, 70, 1, 70, 1, 71, 1,
|
|
71, 3, 71, 2458, 8, 71, 1, 71, 3, 71, 2461, 8, 71, 1, 71, 1, 71, 1, 71,
|
|
3, 71, 2466, 8, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2471, 8, 71, 10, 71, 12,
|
|
71, 2474, 9, 71, 3, 71, 2476, 8, 71, 1, 71, 3, 71, 2479, 8, 71, 1, 72,
|
|
1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 2490, 8,
|
|
72, 1, 72, 3, 72, 2493, 8, 72, 1, 72, 1, 72, 3, 72, 2497, 8, 72, 1, 72,
|
|
1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2505, 8, 73, 1, 73, 3, 73, 2508,
|
|
8, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2513, 8, 73, 1, 73, 1, 73, 1, 73, 1,
|
|
73, 1, 73, 1, 73, 3, 73, 2521, 8, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73,
|
|
2527, 8, 73, 1, 73, 1, 73, 3, 73, 2531, 8, 73, 1, 74, 1, 74, 3, 74, 2535,
|
|
8, 74, 1, 74, 5, 74, 2538, 8, 74, 10, 74, 12, 74, 2541, 9, 74, 1, 74, 1,
|
|
74, 3, 74, 2545, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2552,
|
|
8, 74, 1, 74, 1, 74, 3, 74, 2556, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 5, 74, 2565, 8, 74, 10, 74, 12, 74, 2568, 9, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2575, 8, 74, 1, 74, 3, 74, 2578, 8,
|
|
74, 1, 74, 1, 74, 5, 74, 2582, 8, 74, 10, 74, 12, 74, 2585, 9, 74, 1, 74,
|
|
1, 74, 1, 74, 3, 74, 2590, 8, 74, 3, 74, 2592, 8, 74, 1, 74, 1, 74, 1,
|
|
74, 3, 74, 2597, 8, 74, 1, 74, 3, 74, 2600, 8, 74, 1, 74, 1, 74, 5, 74,
|
|
2604, 8, 74, 10, 74, 12, 74, 2607, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2612,
|
|
8, 74, 3, 74, 2614, 8, 74, 1, 74, 1, 74, 3, 74, 2618, 8, 74, 1, 74, 3,
|
|
74, 2621, 8, 74, 1, 74, 3, 74, 2624, 8, 74, 1, 74, 1, 74, 5, 74, 2628,
|
|
8, 74, 10, 74, 12, 74, 2631, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2636, 8,
|
|
74, 1, 74, 3, 74, 2639, 8, 74, 1, 74, 1, 74, 5, 74, 2643, 8, 74, 10, 74,
|
|
12, 74, 2646, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2651, 8, 74, 3, 74, 2653,
|
|
8, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2658, 8, 74, 1, 74, 1, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 3, 74, 2666, 8, 74, 3, 74, 2668, 8, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2677, 8, 74, 1, 74, 3, 74, 2680,
|
|
8, 74, 1, 74, 3, 74, 2683, 8, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2688, 8,
|
|
74, 3, 74, 2690, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74,
|
|
3, 74, 2699, 8, 74, 1, 74, 3, 74, 2702, 8, 74, 1, 74, 3, 74, 2705, 8, 74,
|
|
1, 74, 1, 74, 1, 74, 3, 74, 2710, 8, 74, 3, 74, 2712, 8, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2721, 8, 74, 1, 74, 1, 74,
|
|
1, 74, 3, 74, 2726, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3,
|
|
74, 2734, 8, 74, 1, 74, 1, 74, 3, 74, 2738, 8, 74, 1, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 3, 74, 2746, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 1, 74, 3, 74, 2756, 8, 74, 1, 74, 1, 74, 1, 74, 3, 74,
|
|
2761, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2768, 8, 74, 1,
|
|
74, 1, 74, 3, 74, 2772, 8, 74, 1, 74, 1, 74, 3, 74, 2776, 8, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2795, 8, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2805, 8, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 3, 74, 2811, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3,
|
|
74, 2828, 8, 74, 1, 74, 1, 74, 3, 74, 2832, 8, 74, 1, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2842, 8, 74, 1, 74, 1, 74, 1,
|
|
74, 3, 74, 2847, 8, 74, 1, 74, 3, 74, 2850, 8, 74, 1, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2859, 8, 74, 1, 74, 1, 74, 1, 74, 1,
|
|
74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2870, 8, 74, 1, 74, 1, 74,
|
|
1, 74, 1, 74, 5, 74, 2876, 8, 74, 10, 74, 12, 74, 2879, 9, 74, 1, 74, 1,
|
|
74, 1, 74, 3, 74, 2884, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
|
|
5, 75, 2892, 8, 75, 10, 75, 12, 75, 2895, 9, 75, 1, 75, 1, 75, 1, 75, 1,
|
|
75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2906, 8, 75, 1, 75, 1, 75,
|
|
1, 75, 1, 75, 1, 75, 3, 75, 2913, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1,
|
|
75, 3, 75, 2920, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
|
|
1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 2933, 8, 75, 10, 75, 12, 75, 2936, 9,
|
|
75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
|
|
3, 75, 2948, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2954, 8, 75, 1,
|
|
75, 1, 75, 1, 75, 1, 75, 3, 75, 2960, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75,
|
|
3, 75, 2966, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2972, 8, 75, 1,
|
|
75, 1, 75, 1, 75, 1, 75, 3, 75, 2978, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75,
|
|
3, 75, 2984, 8, 75, 1, 76, 1, 76, 1, 76, 3, 76, 2989, 8, 76, 1, 76, 1,
|
|
76, 1, 77, 1, 77, 1, 77, 3, 77, 2996, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78,
|
|
1, 78, 3, 78, 3003, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3010,
|
|
8, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3015, 8, 78, 1, 78, 5, 78, 3018, 8,
|
|
78, 10, 78, 12, 78, 3021, 9, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1,
|
|
79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 3, 80, 3034, 8, 80, 1, 80, 1, 80,
|
|
1, 81, 1, 81, 1, 81, 3, 81, 3041, 8, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1,
|
|
82, 3, 82, 3048, 8, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 3054, 8, 83,
|
|
1, 83, 1, 83, 3, 83, 3058, 8, 83, 1, 83, 1, 83, 3, 83, 3062, 8, 83, 1,
|
|
84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 3069, 8, 84, 1, 84, 3, 84, 3072,
|
|
8, 84, 1, 85, 1, 85, 1, 85, 3, 85, 3077, 8, 85, 1, 85, 1, 85, 1, 86, 1,
|
|
86, 1, 86, 3, 86, 3084, 8, 86, 1, 86, 1, 86, 1, 86, 5, 86, 3089, 8, 86,
|
|
10, 86, 12, 86, 3092, 9, 86, 1, 86, 3, 86, 3095, 8, 86, 1, 87, 1, 87, 1,
|
|
87, 3, 87, 3100, 8, 87, 1, 87, 1, 87, 1, 87, 5, 87, 3105, 8, 87, 10, 87,
|
|
12, 87, 3108, 9, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1,
|
|
88, 5, 88, 3118, 8, 88, 10, 88, 12, 88, 3121, 9, 88, 3, 88, 3123, 8, 88,
|
|
1, 88, 1, 88, 1, 88, 3, 88, 3128, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3133,
|
|
8, 88, 5, 88, 3135, 8, 88, 10, 88, 12, 88, 3138, 9, 88, 1, 88, 1, 88, 1,
|
|
88, 3, 88, 3143, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 5, 89, 3150,
|
|
8, 89, 10, 89, 12, 89, 3153, 9, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91,
|
|
1, 91, 3, 91, 3161, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1,
|
|
92, 3, 92, 3170, 8, 92, 1, 92, 3, 92, 3173, 8, 92, 1, 93, 1, 93, 3, 93,
|
|
3177, 8, 93, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 3186,
|
|
8, 95, 1, 96, 1, 96, 3, 96, 3190, 8, 96, 1, 96, 3, 96, 3193, 8, 96, 1,
|
|
96, 3, 96, 3196, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 3202, 8, 96,
|
|
1, 96, 3, 96, 3205, 8, 96, 1, 96, 1, 96, 3, 96, 3209, 8, 96, 1, 96, 3,
|
|
96, 3212, 8, 96, 1, 96, 1, 96, 3, 96, 3216, 8, 96, 1, 96, 3, 96, 3219,
|
|
8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 3225, 8, 96, 10, 96, 12, 96,
|
|
3228, 9, 96, 3, 96, 3230, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1,
|
|
96, 1, 96, 5, 96, 3239, 8, 96, 10, 96, 12, 96, 3242, 9, 96, 3, 96, 3244,
|
|
8, 96, 1, 97, 1, 97, 1, 97, 3, 97, 3249, 8, 97, 1, 97, 3, 97, 3252, 8,
|
|
97, 1, 97, 1, 97, 1, 97, 3, 97, 3257, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97,
|
|
1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3267, 8, 97, 1, 97, 1, 97, 1, 97, 3,
|
|
97, 3272, 8, 97, 1, 97, 1, 97, 4, 97, 3276, 8, 97, 11, 97, 12, 97, 3277,
|
|
3, 97, 3280, 8, 97, 1, 97, 1, 97, 4, 97, 3284, 8, 97, 11, 97, 12, 97, 3285,
|
|
3, 97, 3288, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3294, 8, 97, 1,
|
|
97, 1, 97, 1, 97, 1, 97, 5, 97, 3300, 8, 97, 10, 97, 12, 97, 3303, 9, 97,
|
|
1, 97, 1, 97, 3, 97, 3307, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 5, 97, 3313,
|
|
8, 97, 10, 97, 12, 97, 3316, 9, 97, 3, 97, 3318, 8, 97, 1, 98, 1, 98, 1,
|
|
98, 3, 98, 3323, 8, 98, 1, 98, 3, 98, 3326, 8, 98, 1, 98, 1, 98, 1, 98,
|
|
3, 98, 3331, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3339,
|
|
8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3347, 8, 98, 1,
|
|
98, 1, 98, 1, 98, 1, 98, 3, 98, 3353, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98,
|
|
5, 98, 3359, 8, 98, 10, 98, 12, 98, 3362, 9, 98, 1, 98, 1, 98, 3, 98, 3366,
|
|
8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 5, 98, 3372, 8, 98, 10, 98, 12, 98,
|
|
3375, 9, 98, 3, 98, 3377, 8, 98, 1, 99, 1, 99, 3, 99, 3381, 8, 99, 1, 99,
|
|
3, 99, 3384, 8, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 3392,
|
|
8, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 3398, 8, 99, 1, 99, 1, 99, 1,
|
|
99, 1, 99, 1, 99, 5, 99, 3405, 8, 99, 10, 99, 12, 99, 3408, 9, 99, 3, 99,
|
|
3410, 8, 99, 1, 100, 1, 100, 3, 100, 3414, 8, 100, 1, 100, 1, 100, 3, 100,
|
|
3418, 8, 100, 1, 100, 1, 100, 3, 100, 3422, 8, 100, 1, 100, 4, 100, 3425,
|
|
8, 100, 11, 100, 12, 100, 3426, 1, 100, 1, 100, 3, 100, 3431, 8, 100, 1,
|
|
100, 1, 100, 3, 100, 3435, 8, 100, 3, 100, 3437, 8, 100, 1, 100, 3, 100,
|
|
3440, 8, 100, 1, 100, 3, 100, 3443, 8, 100, 1, 100, 3, 100, 3446, 8, 100,
|
|
1, 100, 1, 100, 4, 100, 3450, 8, 100, 11, 100, 12, 100, 3451, 1, 100, 1,
|
|
100, 3, 100, 3456, 8, 100, 1, 100, 3, 100, 3459, 8, 100, 1, 100, 3, 100,
|
|
3462, 8, 100, 1, 100, 3, 100, 3465, 8, 100, 1, 100, 3, 100, 3468, 8, 100,
|
|
1, 100, 1, 100, 1, 100, 4, 100, 3473, 8, 100, 11, 100, 12, 100, 3474, 3,
|
|
100, 3477, 8, 100, 1, 101, 1, 101, 3, 101, 3481, 8, 101, 1, 102, 1, 102,
|
|
1, 102, 3, 102, 3486, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 3492,
|
|
8, 102, 1, 102, 5, 102, 3495, 8, 102, 10, 102, 12, 102, 3498, 9, 102, 1,
|
|
103, 1, 103, 1, 103, 1, 103, 3, 103, 3504, 8, 103, 1, 103, 1, 103, 1, 103,
|
|
1, 103, 3, 103, 3510, 8, 103, 1, 103, 5, 103, 3513, 8, 103, 10, 103, 12,
|
|
103, 3516, 9, 103, 3, 103, 3518, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104,
|
|
3, 104, 3524, 8, 104, 1, 105, 1, 105, 3, 105, 3528, 8, 105, 1, 106, 1,
|
|
106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3536, 8, 106, 1, 107, 1, 107,
|
|
3, 107, 3540, 8, 107, 1, 107, 3, 107, 3543, 8, 107, 1, 107, 3, 107, 3546,
|
|
8, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3551, 8, 107, 1, 107, 3, 107, 3554,
|
|
8, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3561, 8, 107, 1,
|
|
107, 1, 107, 3, 107, 3565, 8, 107, 1, 107, 3, 107, 3568, 8, 107, 1, 107,
|
|
1, 107, 3, 107, 3572, 8, 107, 1, 108, 1, 108, 3, 108, 3576, 8, 108, 1,
|
|
108, 3, 108, 3579, 8, 108, 1, 108, 3, 108, 3582, 8, 108, 1, 108, 1, 108,
|
|
1, 108, 3, 108, 3587, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3593,
|
|
8, 108, 5, 108, 3595, 8, 108, 10, 108, 12, 108, 3598, 9, 108, 1, 108, 1,
|
|
108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3607, 8, 108, 1, 108,
|
|
1, 108, 1, 108, 1, 108, 3, 108, 3613, 8, 108, 5, 108, 3615, 8, 108, 10,
|
|
108, 12, 108, 3618, 9, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3623, 8, 108,
|
|
1, 108, 1, 108, 3, 108, 3627, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 3,
|
|
109, 3633, 8, 109, 1, 109, 3, 109, 3636, 8, 109, 1, 110, 1, 110, 1, 110,
|
|
1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 3648, 8,
|
|
110, 1, 110, 1, 110, 3, 110, 3652, 8, 110, 1, 110, 1, 110, 3, 110, 3656,
|
|
8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 3664, 8,
|
|
111, 1, 111, 1, 111, 3, 111, 3668, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112,
|
|
1, 113, 1, 113, 3, 113, 3676, 8, 113, 1, 113, 3, 113, 3679, 8, 113, 1,
|
|
113, 1, 113, 3, 113, 3683, 8, 113, 1, 113, 3, 113, 3686, 8, 113, 1, 113,
|
|
1, 113, 1, 113, 1, 113, 5, 113, 3692, 8, 113, 10, 113, 12, 113, 3695, 9,
|
|
113, 1, 113, 1, 113, 3, 113, 3699, 8, 113, 1, 113, 3, 113, 3702, 8, 113,
|
|
1, 113, 3, 113, 3705, 8, 113, 1, 114, 1, 114, 3, 114, 3709, 8, 114, 1,
|
|
114, 3, 114, 3712, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114,
|
|
3719, 8, 114, 10, 114, 12, 114, 3722, 9, 114, 1, 114, 1, 114, 3, 114, 3726,
|
|
8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 3733, 8, 115, 10,
|
|
115, 12, 115, 3736, 9, 115, 1, 116, 1, 116, 3, 116, 3740, 8, 116, 1, 117,
|
|
1, 117, 1, 117, 5, 117, 3745, 8, 117, 10, 117, 12, 117, 3748, 9, 117, 1,
|
|
118, 1, 118, 5, 118, 3752, 8, 118, 10, 118, 12, 118, 3755, 9, 118, 1, 118,
|
|
1, 118, 1, 118, 5, 118, 3760, 8, 118, 10, 118, 12, 118, 3763, 9, 118, 1,
|
|
118, 1, 118, 1, 118, 3, 118, 3768, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119,
|
|
1, 119, 1, 119, 3, 119, 3776, 8, 119, 1, 119, 3, 119, 3779, 8, 119, 1,
|
|
119, 3, 119, 3782, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 3787, 8, 119,
|
|
10, 119, 12, 119, 3790, 9, 119, 3, 119, 3792, 8, 119, 1, 119, 1, 119, 1,
|
|
119, 1, 119, 1, 119, 3, 119, 3799, 8, 119, 1, 119, 3, 119, 3802, 8, 119,
|
|
1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3810, 8, 119, 1,
|
|
120, 1, 120, 1, 120, 1, 120, 3, 120, 3816, 8, 120, 1, 120, 1, 120, 1, 120,
|
|
1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 3827, 8, 121, 1,
|
|
122, 3, 122, 3830, 8, 122, 1, 122, 1, 122, 3, 122, 3834, 8, 122, 1, 122,
|
|
1, 122, 5, 122, 3838, 8, 122, 10, 122, 12, 122, 3841, 9, 122, 1, 122, 1,
|
|
122, 1, 122, 1, 122, 5, 122, 3847, 8, 122, 10, 122, 12, 122, 3850, 9, 122,
|
|
1, 122, 1, 122, 3, 122, 3854, 8, 122, 1, 122, 1, 122, 3, 122, 3858, 8,
|
|
122, 1, 122, 1, 122, 5, 122, 3862, 8, 122, 10, 122, 12, 122, 3865, 9, 122,
|
|
1, 122, 1, 122, 1, 122, 3, 122, 3870, 8, 122, 3, 122, 3872, 8, 122, 1,
|
|
122, 1, 122, 3, 122, 3876, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123,
|
|
1, 123, 1, 123, 3, 123, 3885, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1,
|
|
124, 1, 124, 1, 124, 1, 124, 3, 124, 3895, 8, 124, 1, 125, 1, 125, 1, 125,
|
|
1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 3905, 8, 125, 1, 126, 1,
|
|
126, 5, 126, 3909, 8, 126, 10, 126, 12, 126, 3912, 9, 126, 1, 126, 1, 126,
|
|
3, 126, 3916, 8, 126, 1, 126, 1, 126, 3, 126, 3920, 8, 126, 1, 126, 3,
|
|
126, 3923, 8, 126, 1, 126, 3, 126, 3926, 8, 126, 1, 126, 3, 126, 3929,
|
|
8, 126, 1, 126, 3, 126, 3932, 8, 126, 1, 126, 1, 126, 5, 126, 3936, 8,
|
|
126, 10, 126, 12, 126, 3939, 9, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3944,
|
|
8, 126, 1, 126, 3, 126, 3947, 8, 126, 1, 126, 3, 126, 3950, 8, 126, 1,
|
|
126, 3, 126, 3953, 8, 126, 1, 126, 3, 126, 3956, 8, 126, 1, 126, 3, 126,
|
|
3959, 8, 126, 3, 126, 3961, 8, 126, 1, 127, 1, 127, 5, 127, 3965, 8, 127,
|
|
10, 127, 12, 127, 3968, 9, 127, 1, 127, 1, 127, 1, 127, 3, 127, 3973, 8,
|
|
127, 1, 127, 3, 127, 3976, 8, 127, 1, 127, 3, 127, 3979, 8, 127, 1, 127,
|
|
3, 127, 3982, 8, 127, 1, 127, 3, 127, 3985, 8, 127, 1, 127, 3, 127, 3988,
|
|
8, 127, 1, 128, 1, 128, 3, 128, 3992, 8, 128, 1, 128, 1, 128, 1, 129, 1,
|
|
129, 3, 129, 3998, 8, 129, 1, 129, 1, 129, 3, 129, 4002, 8, 129, 1, 130,
|
|
1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 4010, 8, 130, 1, 130, 1,
|
|
130, 3, 130, 4014, 8, 130, 1, 130, 3, 130, 4017, 8, 130, 3, 130, 4019,
|
|
8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131,
|
|
1, 131, 1, 131, 1, 131, 3, 131, 4032, 8, 131, 1, 131, 3, 131, 4035, 8,
|
|
131, 1, 132, 1, 132, 1, 132, 5, 132, 4040, 8, 132, 10, 132, 12, 132, 4043,
|
|
9, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133,
|
|
4052, 8, 133, 1, 133, 3, 133, 4055, 8, 133, 1, 133, 1, 133, 1, 133, 3,
|
|
133, 4060, 8, 133, 3, 133, 4062, 8, 133, 1, 133, 1, 133, 3, 133, 4066,
|
|
8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 4074, 8,
|
|
133, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 4080, 8, 134, 1, 134, 1, 134,
|
|
1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 4089, 8, 135, 1, 135, 1,
|
|
135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1,
|
|
136, 3, 136, 4102, 8, 136, 1, 137, 1, 137, 3, 137, 4106, 8, 137, 1, 137,
|
|
1, 137, 5, 137, 4110, 8, 137, 10, 137, 12, 137, 4113, 9, 137, 1, 138, 1,
|
|
138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 4121, 8, 138, 1, 138, 3, 138,
|
|
4124, 8, 138, 1, 138, 1, 138, 3, 138, 4128, 8, 138, 1, 138, 3, 138, 4131,
|
|
8, 138, 1, 138, 1, 138, 3, 138, 4135, 8, 138, 1, 138, 1, 138, 3, 138, 4139,
|
|
8, 138, 1, 138, 3, 138, 4142, 8, 138, 3, 138, 4144, 8, 138, 1, 139, 1,
|
|
139, 1, 139, 1, 139, 5, 139, 4150, 8, 139, 10, 139, 12, 139, 4153, 9, 139,
|
|
1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139,
|
|
3, 139, 4164, 8, 139, 1, 139, 1, 139, 4, 139, 4168, 8, 139, 11, 139, 12,
|
|
139, 4169, 3, 139, 4172, 8, 139, 1, 139, 1, 139, 4, 139, 4176, 8, 139,
|
|
11, 139, 12, 139, 4177, 3, 139, 4180, 8, 139, 3, 139, 4182, 8, 139, 1,
|
|
140, 1, 140, 1, 140, 1, 140, 3, 140, 4188, 8, 140, 1, 140, 1, 140, 1, 140,
|
|
1, 140, 1, 140, 1, 140, 3, 140, 4196, 8, 140, 1, 141, 1, 141, 1, 141, 1,
|
|
141, 1, 141, 1, 141, 3, 141, 4204, 8, 141, 1, 142, 1, 142, 3, 142, 4208,
|
|
8, 142, 1, 142, 1, 142, 3, 142, 4212, 8, 142, 1, 143, 1, 143, 1, 143, 1,
|
|
143, 1, 143, 5, 143, 4219, 8, 143, 10, 143, 12, 143, 4222, 9, 143, 1, 143,
|
|
1, 143, 3, 143, 4226, 8, 143, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1,
|
|
145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1,
|
|
145, 1, 145, 5, 145, 4244, 8, 145, 10, 145, 12, 145, 4247, 9, 145, 1, 146,
|
|
1, 146, 3, 146, 4251, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 4257,
|
|
8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 4264, 8, 147, 1,
|
|
148, 1, 148, 1, 148, 3, 148, 4269, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149,
|
|
1, 149, 5, 149, 4276, 8, 149, 10, 149, 12, 149, 4279, 9, 149, 3, 149, 4281,
|
|
8, 149, 1, 150, 1, 150, 3, 150, 4285, 8, 150, 1, 151, 1, 151, 3, 151, 4289,
|
|
8, 151, 1, 151, 1, 151, 3, 151, 4293, 8, 151, 1, 151, 3, 151, 4296, 8,
|
|
151, 1, 151, 3, 151, 4299, 8, 151, 1, 151, 3, 151, 4302, 8, 151, 1, 152,
|
|
1, 152, 3, 152, 4306, 8, 152, 1, 152, 1, 152, 3, 152, 4310, 8, 152, 1,
|
|
152, 3, 152, 4313, 8, 152, 1, 152, 3, 152, 4316, 8, 152, 1, 152, 3, 152,
|
|
4319, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 3, 154, 4326, 8,
|
|
154, 1, 154, 1, 154, 3, 154, 4330, 8, 154, 1, 154, 1, 154, 1, 155, 1, 155,
|
|
1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 4343, 8,
|
|
156, 10, 156, 12, 156, 4346, 9, 156, 1, 156, 3, 156, 4349, 8, 156, 1, 157,
|
|
1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159,
|
|
3, 159, 4361, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 5, 159, 4367, 8,
|
|
159, 10, 159, 12, 159, 4370, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1,
|
|
160, 1, 160, 1, 160, 3, 160, 4379, 8, 160, 1, 161, 1, 161, 3, 161, 4383,
|
|
8, 161, 1, 161, 3, 161, 4386, 8, 161, 1, 161, 1, 161, 1, 162, 1, 162, 3,
|
|
162, 4392, 8, 162, 1, 162, 3, 162, 4395, 8, 162, 1, 162, 3, 162, 4398,
|
|
8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163,
|
|
4407, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3,
|
|
164, 4416, 8, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 5, 165,
|
|
4424, 8, 165, 10, 165, 12, 165, 4427, 9, 165, 1, 165, 3, 165, 4430, 8,
|
|
165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 5, 166, 4438, 8, 166,
|
|
10, 166, 12, 166, 4441, 9, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167,
|
|
1, 167, 1, 167, 3, 167, 4450, 8, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1,
|
|
169, 1, 169, 3, 169, 4458, 8, 169, 1, 169, 3, 169, 4461, 8, 169, 1, 170,
|
|
1, 170, 1, 170, 1, 170, 1, 170, 5, 170, 4468, 8, 170, 10, 170, 12, 170,
|
|
4471, 9, 170, 3, 170, 4473, 8, 170, 1, 170, 1, 170, 3, 170, 4477, 8, 170,
|
|
1, 170, 5, 170, 4480, 8, 170, 10, 170, 12, 170, 4483, 9, 170, 1, 170, 3,
|
|
170, 4486, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 5, 171, 4493,
|
|
8, 171, 10, 171, 12, 171, 4496, 9, 171, 3, 171, 4498, 8, 171, 1, 172, 1,
|
|
172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1,
|
|
174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
|
|
174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 4527,
|
|
8, 174, 10, 174, 12, 174, 4530, 9, 174, 3, 174, 4532, 8, 174, 1, 174, 3,
|
|
174, 4535, 8, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178,
|
|
1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179,
|
|
1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179,
|
|
1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179,
|
|
1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179,
|
|
1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179,
|
|
5, 179, 4589, 8, 179, 10, 179, 12, 179, 4592, 9, 179, 1, 179, 1, 179, 3,
|
|
179, 4596, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181,
|
|
1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182,
|
|
1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182,
|
|
1, 182, 3, 182, 4624, 8, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
|
|
183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 4638, 8, 183,
|
|
1, 184, 1, 184, 1, 184, 5, 184, 4643, 8, 184, 10, 184, 12, 184, 4646, 9,
|
|
184, 1, 184, 3, 184, 4649, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 3, 185,
|
|
4655, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 4663,
|
|
8, 186, 3, 186, 4665, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1,
|
|
188, 1, 188, 1, 188, 1, 188, 3, 188, 4676, 8, 188, 1, 189, 1, 189, 1, 189,
|
|
1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 4686, 8, 190, 1, 191, 1,
|
|
191, 1, 191, 1, 191, 1, 191, 3, 191, 4693, 8, 191, 1, 192, 1, 192, 1, 192,
|
|
1, 192, 3, 192, 4699, 8, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1,
|
|
194, 3, 194, 4707, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 4712, 8, 195,
|
|
1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4718, 8, 195, 10, 195, 12, 195,
|
|
4721, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4726, 8, 195, 10, 195, 12,
|
|
195, 4729, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4734, 8, 195, 10, 195,
|
|
12, 195, 4737, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4742, 8, 195, 10,
|
|
195, 12, 195, 4745, 9, 195, 1, 195, 5, 195, 4748, 8, 195, 10, 195, 12,
|
|
195, 4751, 9, 195, 1, 195, 1, 195, 3, 195, 4755, 8, 195, 1, 196, 1, 196,
|
|
1, 196, 3, 196, 4760, 8, 196, 1, 196, 4, 196, 4763, 8, 196, 11, 196, 12,
|
|
196, 4764, 1, 196, 1, 196, 4, 196, 4769, 8, 196, 11, 196, 12, 196, 4770,
|
|
3, 196, 4773, 8, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1,
|
|
197, 4, 197, 4782, 8, 197, 11, 197, 12, 197, 4783, 1, 197, 5, 197, 4787,
|
|
8, 197, 10, 197, 12, 197, 4790, 9, 197, 1, 197, 1, 197, 4, 197, 4794, 8,
|
|
197, 11, 197, 12, 197, 4795, 3, 197, 4798, 8, 197, 1, 197, 1, 197, 1, 197,
|
|
1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200,
|
|
3, 200, 4812, 8, 200, 1, 200, 1, 200, 4, 200, 4816, 8, 200, 11, 200, 12,
|
|
200, 4817, 1, 200, 1, 200, 1, 200, 3, 200, 4823, 8, 200, 1, 201, 1, 201,
|
|
1, 201, 3, 201, 4828, 8, 201, 1, 201, 1, 201, 4, 201, 4832, 8, 201, 11,
|
|
201, 12, 201, 4833, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 4841,
|
|
8, 201, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 3, 203, 4849, 8,
|
|
203, 1, 203, 1, 203, 1, 203, 1, 203, 4, 203, 4855, 8, 203, 11, 203, 12,
|
|
203, 4856, 1, 203, 1, 203, 1, 203, 3, 203, 4862, 8, 203, 1, 204, 1, 204,
|
|
1, 204, 1, 204, 3, 204, 4868, 8, 204, 1, 204, 3, 204, 4871, 8, 204, 1,
|
|
204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4879, 8, 204, 1, 205,
|
|
1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 4886, 8, 205, 1, 206, 1, 206, 1,
|
|
206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4895, 8, 206, 1, 206, 3, 206,
|
|
4898, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1,
|
|
208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 5, 208, 4913, 8, 208, 10,
|
|
208, 12, 208, 4916, 9, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 3,
|
|
209, 4923, 8, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 3, 209,
|
|
4931, 8, 209, 1, 210, 1, 210, 3, 210, 4935, 8, 210, 1, 210, 1, 210, 1,
|
|
211, 1, 211, 1, 211, 3, 211, 4942, 8, 211, 1, 211, 1, 211, 4, 211, 4946,
|
|
8, 211, 11, 211, 12, 211, 4947, 1, 212, 1, 212, 1, 212, 1, 212, 4, 212,
|
|
4954, 8, 212, 11, 212, 12, 212, 4955, 1, 213, 1, 213, 1, 213, 1, 213, 1,
|
|
213, 5, 213, 4963, 8, 213, 10, 213, 12, 213, 4966, 9, 213, 1, 213, 1, 213,
|
|
1, 213, 3, 213, 4971, 8, 213, 1, 213, 1, 213, 1, 213, 5, 213, 4976, 8,
|
|
213, 10, 213, 12, 213, 4979, 9, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3,
|
|
213, 4985, 8, 213, 1, 213, 5, 213, 4988, 8, 213, 10, 213, 12, 213, 4991,
|
|
9, 213, 3, 213, 4993, 8, 213, 3, 213, 4995, 8, 213, 1, 213, 1, 213, 4,
|
|
213, 4999, 8, 213, 11, 213, 12, 213, 5000, 3, 213, 5003, 8, 213, 1, 213,
|
|
1, 213, 5, 213, 5007, 8, 213, 10, 213, 12, 213, 5010, 9, 213, 1, 213, 1,
|
|
213, 1, 213, 1, 213, 3, 213, 5016, 8, 213, 1, 213, 1, 213, 1, 213, 3, 213,
|
|
5021, 8, 213, 1, 213, 1, 213, 3, 213, 5025, 8, 213, 1, 213, 1, 213, 1,
|
|
213, 1, 213, 3, 213, 5031, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214,
|
|
5, 214, 5038, 8, 214, 10, 214, 12, 214, 5041, 9, 214, 1, 214, 1, 214, 1,
|
|
214, 3, 214, 5046, 8, 214, 1, 214, 1, 214, 1, 214, 5, 214, 5051, 8, 214,
|
|
10, 214, 12, 214, 5054, 9, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5059, 8,
|
|
214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5065, 8, 214, 1, 214, 5, 214,
|
|
5068, 8, 214, 10, 214, 12, 214, 5071, 9, 214, 3, 214, 5073, 8, 214, 3,
|
|
214, 5075, 8, 214, 1, 214, 1, 214, 4, 214, 5079, 8, 214, 11, 214, 12, 214,
|
|
5080, 3, 214, 5083, 8, 214, 1, 214, 1, 214, 5, 214, 5087, 8, 214, 10, 214,
|
|
12, 214, 5090, 9, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5096, 8,
|
|
214, 3, 214, 5098, 8, 214, 1, 215, 1, 215, 1, 215, 3, 215, 5103, 8, 215,
|
|
1, 215, 1, 215, 1, 215, 5, 215, 5108, 8, 215, 10, 215, 12, 215, 5111, 9,
|
|
215, 1, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5117, 8, 216, 10, 216, 12,
|
|
216, 5120, 9, 216, 1, 216, 1, 216, 3, 216, 5124, 8, 216, 1, 216, 1, 216,
|
|
1, 216, 1, 216, 1, 216, 5, 216, 5131, 8, 216, 10, 216, 12, 216, 5134, 9,
|
|
216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5140, 8, 216, 1, 216, 5, 216,
|
|
5143, 8, 216, 10, 216, 12, 216, 5146, 9, 216, 3, 216, 5148, 8, 216, 3,
|
|
216, 5150, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5156, 8, 216,
|
|
10, 216, 12, 216, 5159, 9, 216, 3, 216, 5161, 8, 216, 1, 216, 1, 216, 1,
|
|
216, 1, 216, 1, 216, 1, 216, 3, 216, 5169, 8, 216, 1, 216, 1, 216, 1, 216,
|
|
3, 216, 5174, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5179, 8, 216, 5,
|
|
216, 5181, 8, 216, 10, 216, 12, 216, 5184, 9, 216, 1, 216, 1, 216, 1, 216,
|
|
3, 216, 5189, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5194, 8, 216, 5,
|
|
216, 5196, 8, 216, 10, 216, 12, 216, 5199, 9, 216, 1, 216, 1, 216, 1, 216,
|
|
3, 216, 5204, 8, 216, 3, 216, 5206, 8, 216, 1, 217, 1, 217, 1, 217, 1,
|
|
217, 1, 217, 1, 217, 1, 217, 5, 217, 5215, 8, 217, 10, 217, 12, 217, 5218,
|
|
9, 217, 3, 217, 5220, 8, 217, 1, 217, 1, 217, 1, 217, 5, 217, 5225, 8,
|
|
217, 10, 217, 12, 217, 5228, 9, 217, 3, 217, 5230, 8, 217, 1, 218, 1, 218,
|
|
1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 5, 218, 5240, 8, 218, 10,
|
|
218, 12, 218, 5243, 9, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5248, 8, 218,
|
|
1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 5255, 8, 219, 10, 219,
|
|
12, 219, 5258, 9, 219, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5264, 8,
|
|
220, 10, 220, 12, 220, 5267, 9, 220, 1, 220, 1, 220, 3, 220, 5271, 8, 220,
|
|
1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5278, 8, 220, 10, 220,
|
|
12, 220, 5281, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5286, 8, 220, 1,
|
|
220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5295, 8, 220,
|
|
10, 220, 12, 220, 5298, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5303, 8,
|
|
220, 1, 220, 1, 220, 1, 220, 3, 220, 5308, 8, 220, 5, 220, 5310, 8, 220,
|
|
10, 220, 12, 220, 5313, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5318, 8,
|
|
220, 1, 220, 1, 220, 1, 220, 3, 220, 5323, 8, 220, 5, 220, 5325, 8, 220,
|
|
10, 220, 12, 220, 5328, 9, 220, 3, 220, 5330, 8, 220, 1, 221, 1, 221, 1,
|
|
221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 5, 221, 5340, 8, 221, 10,
|
|
221, 12, 221, 5343, 9, 221, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 5349,
|
|
8, 222, 1, 222, 1, 222, 1, 222, 3, 222, 5354, 8, 222, 1, 223, 1, 223, 1,
|
|
223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1,
|
|
224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1,
|
|
224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5384,
|
|
8, 224, 1, 225, 1, 225, 3, 225, 5388, 8, 225, 1, 225, 1, 225, 1, 225, 3,
|
|
225, 5393, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 5400,
|
|
8, 226, 1, 226, 3, 226, 5403, 8, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3,
|
|
226, 5409, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227,
|
|
1, 227, 3, 227, 5419, 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1,
|
|
228, 1, 228, 1, 228, 3, 228, 5429, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229,
|
|
1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5439, 8, 229, 1, 229, 1, 229, 1,
|
|
229, 1, 229, 3, 229, 5445, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229,
|
|
1, 229, 1, 229, 3, 229, 5454, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3,
|
|
229, 5460, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5467,
|
|
8, 229, 3, 229, 5469, 8, 229, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1,
|
|
231, 1, 231, 1, 231, 3, 231, 5479, 8, 231, 1, 232, 1, 232, 3, 232, 5483,
|
|
8, 232, 1, 232, 1, 232, 3, 232, 5487, 8, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 3, 232, 5497, 8, 232, 1, 232, 1, 232,
|
|
1, 232, 3, 232, 5502, 8, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1,
|
|
232, 1, 232, 3, 232, 5574, 8, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233,
|
|
1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233,
|
|
1, 233, 1, 233, 3, 233, 5592, 8, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1,
|
|
235, 1, 235, 3, 235, 5600, 8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235,
|
|
1, 235, 1, 235, 1, 235, 5, 235, 5610, 8, 235, 10, 235, 12, 235, 5613, 9,
|
|
235, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 5619, 8, 235, 3, 235, 5621,
|
|
8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 5629, 8,
|
|
235, 10, 235, 12, 235, 5632, 9, 235, 3, 235, 5634, 8, 235, 1, 236, 1, 236,
|
|
1, 236, 1, 236, 5, 236, 5640, 8, 236, 10, 236, 12, 236, 5643, 9, 236, 1,
|
|
237, 1, 237, 1, 237, 1, 237, 3, 237, 5649, 8, 237, 1, 238, 1, 238, 3, 238,
|
|
5653, 8, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 3, 239, 5660, 8,
|
|
239, 1, 239, 1, 239, 1, 239, 3, 239, 5665, 8, 239, 1, 239, 3, 239, 5668,
|
|
8, 239, 1, 239, 3, 239, 5671, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1,
|
|
240, 1, 240, 1, 240, 3, 240, 5680, 8, 240, 1, 241, 1, 241, 3, 241, 5684,
|
|
8, 241, 1, 241, 1, 241, 3, 241, 5688, 8, 241, 1, 241, 1, 241, 1, 241, 1,
|
|
241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1,
|
|
243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3,
|
|
244, 5711, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 5718,
|
|
8, 244, 5, 244, 5720, 8, 244, 10, 244, 12, 244, 5723, 9, 244, 1, 244, 1,
|
|
244, 1, 244, 1, 244, 3, 244, 5729, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244,
|
|
1, 244, 3, 244, 5736, 8, 244, 1, 244, 3, 244, 5739, 8, 244, 1, 244, 1,
|
|
244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1,
|
|
244, 1, 244, 5, 244, 5753, 8, 244, 10, 244, 12, 244, 5756, 9, 244, 3, 244,
|
|
5758, 8, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
|
|
245, 3, 245, 5768, 8, 245, 1, 245, 1, 245, 3, 245, 5772, 8, 245, 1, 245,
|
|
1, 245, 1, 245, 1, 245, 3, 245, 5778, 8, 245, 1, 245, 3, 245, 5781, 8,
|
|
245, 1, 245, 1, 245, 1, 245, 3, 245, 5786, 8, 245, 1, 245, 1, 245, 3, 245,
|
|
5790, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5797, 8,
|
|
245, 1, 245, 3, 245, 5800, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245,
|
|
5806, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
|
|
245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
|
|
245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5830, 8, 245, 1, 245,
|
|
3, 245, 5833, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
|
|
245, 1, 245, 1, 245, 1, 245, 3, 245, 5845, 8, 245, 1, 245, 3, 245, 5848,
|
|
8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245,
|
|
3, 245, 5858, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3,
|
|
245, 5866, 8, 245, 1, 245, 1, 245, 3, 245, 5870, 8, 245, 1, 245, 1, 245,
|
|
1, 245, 1, 245, 1, 245, 3, 245, 5877, 8, 245, 1, 245, 3, 245, 5880, 8,
|
|
245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 5, 245, 5887, 8, 245, 10,
|
|
245, 12, 245, 5890, 9, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5895, 8, 245,
|
|
1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5901, 8, 245, 1, 245, 1, 245, 1,
|
|
245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5911, 8, 245, 3, 245,
|
|
5913, 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 5919, 8, 246, 1,
|
|
246, 3, 246, 5922, 8, 246, 1, 246, 3, 246, 5925, 8, 246, 1, 247, 1, 247,
|
|
1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247,
|
|
5937, 8, 247, 1, 247, 3, 247, 5940, 8, 247, 1, 248, 1, 248, 1, 248, 1,
|
|
248, 3, 248, 5946, 8, 248, 1, 249, 3, 249, 5949, 8, 249, 1, 249, 1, 249,
|
|
1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5957, 8, 249, 1, 249, 1, 249, 1,
|
|
249, 1, 249, 1, 249, 1, 249, 3, 249, 5965, 8, 249, 1, 250, 1, 250, 1, 250,
|
|
1, 250, 3, 250, 5971, 8, 250, 1, 250, 1, 250, 3, 250, 5975, 8, 250, 1,
|
|
251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1,
|
|
251, 1, 251, 1, 251, 3, 251, 5989, 8, 251, 1, 252, 1, 252, 1, 252, 1, 253,
|
|
1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 5999, 8, 253, 10, 253, 12, 253,
|
|
6002, 9, 253, 1, 253, 1, 253, 1, 253, 1, 253, 3, 253, 6008, 8, 253, 1,
|
|
253, 3, 253, 6011, 8, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 3, 254,
|
|
6018, 8, 254, 1, 254, 1, 254, 1, 254, 5, 254, 6023, 8, 254, 10, 254, 12,
|
|
254, 6026, 9, 254, 1, 255, 1, 255, 3, 255, 6030, 8, 255, 1, 255, 1, 255,
|
|
1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 6041, 8,
|
|
256, 10, 256, 12, 256, 6044, 9, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1,
|
|
258, 1, 258, 1, 259, 1, 259, 3, 259, 6054, 8, 259, 1, 259, 1, 259, 1, 259,
|
|
1, 259, 3, 259, 6060, 8, 259, 1, 260, 1, 260, 1, 260, 3, 260, 6065, 8,
|
|
260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1,
|
|
260, 1, 260, 1, 260, 3, 260, 6078, 8, 260, 3, 260, 6080, 8, 260, 1, 260,
|
|
1, 260, 1, 260, 3, 260, 6085, 8, 260, 1, 260, 1, 260, 3, 260, 6089, 8,
|
|
260, 1, 260, 3, 260, 6092, 8, 260, 3, 260, 6094, 8, 260, 1, 261, 1, 261,
|
|
1, 261, 1, 261, 1, 261, 3, 261, 6101, 8, 261, 1, 262, 1, 262, 1, 262, 1,
|
|
262, 1, 262, 3, 262, 6108, 8, 262, 1, 262, 3, 262, 6111, 8, 262, 1, 262,
|
|
3, 262, 6114, 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6120, 8,
|
|
262, 1, 262, 1, 262, 3, 262, 6124, 8, 262, 1, 263, 1, 263, 1, 263, 1, 263,
|
|
3, 263, 6130, 8, 263, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 6136, 8,
|
|
264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1,
|
|
267, 1, 267, 1, 267, 3, 267, 6149, 8, 267, 1, 267, 1, 267, 1, 267, 3, 267,
|
|
6154, 8, 267, 1, 267, 1, 267, 1, 267, 1, 267, 5, 267, 6160, 8, 267, 10,
|
|
267, 12, 267, 6163, 9, 267, 3, 267, 6165, 8, 267, 1, 268, 1, 268, 1, 268,
|
|
3, 268, 6170, 8, 268, 1, 268, 1, 268, 1, 268, 3, 268, 6175, 8, 268, 1,
|
|
268, 1, 268, 1, 268, 1, 268, 5, 268, 6181, 8, 268, 10, 268, 12, 268, 6184,
|
|
9, 268, 3, 268, 6186, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1,
|
|
269, 3, 269, 6194, 8, 269, 1, 270, 1, 270, 3, 270, 6198, 8, 270, 1, 270,
|
|
1, 270, 1, 270, 5, 270, 6203, 8, 270, 10, 270, 12, 270, 6206, 9, 270, 1,
|
|
271, 1, 271, 1, 271, 3, 271, 6211, 8, 271, 1, 271, 3, 271, 6214, 8, 271,
|
|
1, 272, 1, 272, 3, 272, 6218, 8, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1,
|
|
272, 1, 272, 1, 272, 1, 272, 1, 272, 5, 272, 6229, 8, 272, 10, 272, 12,
|
|
272, 6232, 9, 272, 1, 272, 1, 272, 1, 272, 3, 272, 6237, 8, 272, 1, 272,
|
|
1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 5, 272, 6247, 8,
|
|
272, 10, 272, 12, 272, 6250, 9, 272, 3, 272, 6252, 8, 272, 1, 273, 1, 273,
|
|
1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 6261, 8, 274, 1, 274, 1,
|
|
274, 1, 274, 3, 274, 6266, 8, 274, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275,
|
|
6272, 8, 275, 1, 276, 1, 276, 1, 277, 1, 277, 3, 277, 6278, 8, 277, 1,
|
|
278, 1, 278, 1, 278, 3, 278, 6283, 8, 278, 3, 278, 6285, 8, 278, 1, 278,
|
|
3, 278, 6288, 8, 278, 1, 278, 1, 278, 3, 278, 6292, 8, 278, 3, 278, 6294,
|
|
8, 278, 1, 279, 1, 279, 3, 279, 6298, 8, 279, 1, 279, 1, 279, 1, 279, 1,
|
|
279, 3, 279, 6304, 8, 279, 1, 279, 3, 279, 6307, 8, 279, 1, 279, 3, 279,
|
|
6310, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 6316, 8, 280, 1,
|
|
281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 6325, 8, 282,
|
|
1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6333, 8, 284, 1,
|
|
285, 1, 285, 3, 285, 6337, 8, 285, 1, 286, 1, 286, 1, 286, 3, 286, 6342,
|
|
8, 286, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288,
|
|
1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 4, 288,
|
|
6360, 8, 288, 11, 288, 12, 288, 6361, 1, 289, 1, 289, 1, 289, 1, 289, 1,
|
|
289, 3, 289, 6369, 8, 289, 3, 289, 6371, 8, 289, 1, 290, 1, 290, 1, 290,
|
|
4, 290, 6376, 8, 290, 11, 290, 12, 290, 6377, 3, 290, 6380, 8, 290, 1,
|
|
291, 1, 291, 3, 291, 6384, 8, 291, 1, 292, 1, 292, 1, 292, 3, 292, 6389,
|
|
8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293,
|
|
1, 293, 3, 293, 6400, 8, 293, 1, 294, 1, 294, 1, 294, 3, 294, 6405, 8,
|
|
294, 1, 295, 1, 295, 1, 296, 1, 296, 3, 296, 6411, 8, 296, 1, 297, 3, 297,
|
|
6414, 8, 297, 1, 297, 1, 297, 3, 297, 6418, 8, 297, 1, 297, 4, 297, 6421,
|
|
8, 297, 11, 297, 12, 297, 6422, 1, 297, 3, 297, 6426, 8, 297, 1, 297, 1,
|
|
297, 3, 297, 6430, 8, 297, 1, 297, 1, 297, 3, 297, 6434, 8, 297, 3, 297,
|
|
6436, 8, 297, 1, 298, 1, 298, 1, 299, 3, 299, 6441, 8, 299, 1, 299, 1,
|
|
299, 1, 300, 3, 300, 6446, 8, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301,
|
|
1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 6459, 8, 301, 1,
|
|
301, 3, 301, 6462, 8, 301, 1, 302, 1, 302, 3, 302, 6466, 8, 302, 1, 302,
|
|
3, 302, 6469, 8, 302, 1, 302, 3, 302, 6472, 8, 302, 1, 302, 1, 302, 1,
|
|
302, 3, 302, 6477, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6482, 8, 302,
|
|
1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6488, 8, 302, 1, 302, 3, 302, 6491,
|
|
8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6496, 8, 302, 1, 302, 3, 302, 6499,
|
|
8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6504, 8, 302, 1, 302, 3, 302, 6507,
|
|
8, 302, 1, 302, 1, 302, 3, 302, 6511, 8, 302, 1, 302, 5, 302, 6514, 8,
|
|
302, 10, 302, 12, 302, 6517, 9, 302, 1, 302, 1, 302, 3, 302, 6521, 8, 302,
|
|
1, 302, 5, 302, 6524, 8, 302, 10, 302, 12, 302, 6527, 9, 302, 1, 302, 1,
|
|
302, 3, 302, 6531, 8, 302, 1, 302, 3, 302, 6534, 8, 302, 1, 302, 5, 302,
|
|
6537, 8, 302, 10, 302, 12, 302, 6540, 9, 302, 1, 302, 1, 302, 3, 302, 6544,
|
|
8, 302, 1, 302, 5, 302, 6547, 8, 302, 10, 302, 12, 302, 6550, 9, 302, 1,
|
|
302, 1, 302, 1, 302, 3, 302, 6555, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302,
|
|
6560, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6565, 8, 302, 1, 302, 1,
|
|
302, 1, 302, 3, 302, 6570, 8, 302, 1, 302, 1, 302, 3, 302, 6574, 8, 302,
|
|
1, 302, 3, 302, 6577, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6582, 8,
|
|
302, 1, 302, 1, 302, 3, 302, 6586, 8, 302, 1, 302, 1, 302, 3, 302, 6590,
|
|
8, 302, 1, 303, 1, 303, 1, 303, 1, 303, 5, 303, 6596, 8, 303, 10, 303,
|
|
12, 303, 6599, 9, 303, 1, 303, 1, 303, 1, 304, 1, 304, 3, 304, 6605, 8,
|
|
304, 1, 304, 1, 304, 3, 304, 6609, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304,
|
|
6614, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304, 6619, 8, 304, 1, 304, 1,
|
|
304, 3, 304, 6623, 8, 304, 3, 304, 6625, 8, 304, 1, 304, 3, 304, 6628,
|
|
8, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306,
|
|
1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6644, 8, 307, 1,
|
|
307, 1, 307, 1, 308, 1, 308, 1, 308, 5, 308, 6651, 8, 308, 10, 308, 12,
|
|
308, 6654, 9, 308, 1, 309, 1, 309, 1, 309, 5, 309, 6659, 8, 309, 10, 309,
|
|
12, 309, 6662, 9, 309, 1, 310, 1, 310, 1, 310, 5, 310, 6667, 8, 310, 10,
|
|
310, 12, 310, 6670, 9, 310, 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, 6676,
|
|
8, 311, 10, 311, 12, 311, 6679, 9, 311, 1, 311, 1, 311, 1, 312, 1, 312,
|
|
1, 312, 5, 312, 6686, 8, 312, 10, 312, 12, 312, 6689, 9, 312, 1, 313, 1,
|
|
313, 1, 313, 5, 313, 6694, 8, 313, 10, 313, 12, 313, 6697, 9, 313, 1, 314,
|
|
1, 314, 1, 314, 5, 314, 6702, 8, 314, 10, 314, 12, 314, 6705, 9, 314, 1,
|
|
315, 1, 315, 1, 315, 5, 315, 6710, 8, 315, 10, 315, 12, 315, 6713, 9, 315,
|
|
1, 316, 1, 316, 1, 316, 5, 316, 6718, 8, 316, 10, 316, 12, 316, 6721, 9,
|
|
316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1,
|
|
317, 3, 317, 6732, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 3, 317,
|
|
6739, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1,
|
|
317, 3, 317, 6749, 8, 317, 1, 318, 1, 318, 1, 318, 3, 318, 6754, 8, 318,
|
|
1, 318, 3, 318, 6757, 8, 318, 1, 318, 1, 318, 1, 318, 3, 318, 6762, 8,
|
|
318, 1, 318, 3, 318, 6765, 8, 318, 1, 319, 1, 319, 3, 319, 6769, 8, 319,
|
|
1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322,
|
|
1, 322, 1, 323, 1, 323, 1, 323, 3, 323, 6784, 8, 323, 1, 324, 1, 324, 1,
|
|
324, 1, 324, 1, 324, 1, 324, 3, 324, 6792, 8, 324, 1, 324, 1, 324, 1, 324,
|
|
1, 324, 1, 324, 3, 324, 6799, 8, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6804,
|
|
8, 324, 1, 325, 1, 325, 1, 325, 3, 325, 6809, 8, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 4, 325, 6841, 8, 325, 11, 325, 12, 325, 6842, 1, 325, 1, 325, 3, 325,
|
|
6847, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 4, 325, 6853, 8, 325, 11,
|
|
325, 12, 325, 6854, 1, 325, 1, 325, 3, 325, 6859, 8, 325, 1, 325, 1, 325,
|
|
1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6868, 8, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6876, 8, 325, 1, 325, 1, 325,
|
|
1, 325, 3, 325, 6881, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 3, 325, 6889, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6894, 8, 325,
|
|
1, 325, 1, 325, 1, 325, 3, 325, 6899, 8, 325, 3, 325, 6901, 8, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6910, 8, 325,
|
|
1, 325, 1, 325, 1, 325, 3, 325, 6915, 8, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 3, 325, 6923, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325,
|
|
6928, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6936,
|
|
8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6944, 8,
|
|
325, 1, 325, 3, 325, 6947, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325,
|
|
1, 325, 1, 325, 1, 325, 3, 325, 6957, 8, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
|
|
325, 1, 325, 1, 325, 1, 325, 3, 325, 6975, 8, 325, 1, 325, 3, 325, 6978,
|
|
8, 325, 1, 325, 3, 325, 6981, 8, 325, 1, 325, 1, 325, 3, 325, 6985, 8,
|
|
325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1,
|
|
327, 5, 327, 6996, 8, 327, 10, 327, 12, 327, 6999, 9, 327, 1, 327, 1, 327,
|
|
1, 327, 1, 327, 1, 327, 3, 327, 7006, 8, 327, 1, 328, 1, 328, 3, 328, 7010,
|
|
8, 328, 1, 329, 1, 329, 1, 329, 3, 329, 7015, 8, 329, 1, 329, 1, 329, 1,
|
|
329, 3, 329, 7020, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7026,
|
|
8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7031, 8, 329, 1, 329, 1, 329, 3,
|
|
329, 7035, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7040, 8, 329, 1, 329,
|
|
1, 329, 1, 329, 3, 329, 7045, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7050,
|
|
8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 5, 329, 7058, 8,
|
|
329, 10, 329, 12, 329, 7061, 9, 329, 3, 329, 7063, 8, 329, 1, 329, 1, 329,
|
|
3, 329, 7067, 8, 329, 1, 329, 1, 329, 3, 329, 7071, 8, 329, 1, 330, 1,
|
|
330, 1, 330, 1, 330, 1, 330, 3, 330, 7078, 8, 330, 1, 330, 1, 330, 3, 330,
|
|
7082, 8, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1,
|
|
330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1,
|
|
330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1,
|
|
330, 1, 330, 3, 330, 7111, 8, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331,
|
|
1, 331, 3, 331, 7119, 8, 331, 1, 332, 3, 332, 7122, 8, 332, 1, 332, 3,
|
|
332, 7125, 8, 332, 1, 332, 3, 332, 7128, 8, 332, 1, 332, 3, 332, 7131,
|
|
8, 332, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 336,
|
|
1, 336, 3, 336, 7142, 8, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1,
|
|
338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 7156, 8, 338,
|
|
1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 5, 339, 7163, 8, 339, 10, 339,
|
|
12, 339, 7166, 9, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340,
|
|
1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340,
|
|
1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340,
|
|
3, 340, 7192, 8, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1,
|
|
342, 1, 342, 1, 342, 3, 342, 7203, 8, 342, 1, 342, 1, 342, 1, 342, 1, 342,
|
|
1, 342, 3, 342, 7210, 8, 342, 5, 342, 7212, 8, 342, 10, 342, 12, 342, 7215,
|
|
9, 342, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7221, 8, 343, 1, 344, 1,
|
|
344, 1, 344, 1, 344, 1, 344, 1, 344, 3, 344, 7229, 8, 344, 1, 344, 1, 344,
|
|
1, 344, 3, 344, 7234, 8, 344, 1, 344, 1, 344, 1, 344, 1, 344, 5, 344, 7240,
|
|
8, 344, 10, 344, 12, 344, 7243, 9, 344, 1, 345, 1, 345, 1, 345, 1, 345,
|
|
1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7254, 8, 345, 1, 345, 1,
|
|
345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1,
|
|
345, 3, 345, 7267, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7273,
|
|
8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7279, 8, 345, 1, 345, 1,
|
|
345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1,
|
|
345, 1, 345, 1, 345, 1, 345, 3, 345, 7295, 8, 345, 1, 345, 1, 345, 1, 345,
|
|
1, 345, 3, 345, 7301, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1,
|
|
345, 1, 345, 5, 345, 7310, 8, 345, 10, 345, 12, 345, 7313, 9, 345, 1, 346,
|
|
1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346,
|
|
1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 5, 346, 7332, 8,
|
|
346, 10, 346, 12, 346, 7335, 9, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1,
|
|
346, 1, 346, 1, 346, 4, 346, 7344, 8, 346, 11, 346, 12, 346, 7345, 1, 346,
|
|
1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346,
|
|
1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 3, 346, 7363, 8, 346, 1, 346, 1,
|
|
346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1,
|
|
346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 5,
|
|
346, 7384, 8, 346, 10, 346, 12, 346, 7387, 9, 346, 1, 347, 1, 347, 1, 348,
|
|
1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348,
|
|
1, 348, 1, 348, 1, 348, 1, 348, 3, 348, 7405, 8, 348, 1, 349, 1, 349, 1,
|
|
349, 1, 349, 1, 349, 1, 349, 1, 349, 3, 349, 7414, 8, 349, 1, 350, 1, 350,
|
|
1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 3, 350, 7423, 8, 350, 1, 351, 1,
|
|
351, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 3, 353, 7434,
|
|
8, 353, 1, 354, 1, 354, 1, 355, 1, 355, 1, 356, 1, 356, 1, 357, 1, 357,
|
|
1, 358, 1, 358, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 0, 3, 688, 690,
|
|
692, 361, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
|
|
34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68,
|
|
70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104,
|
|
106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134,
|
|
136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164,
|
|
166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194,
|
|
196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224,
|
|
226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254,
|
|
256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284,
|
|
286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314,
|
|
316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344,
|
|
346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,
|
|
376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404,
|
|
406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434,
|
|
436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464,
|
|
466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494,
|
|
496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524,
|
|
526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554,
|
|
556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584,
|
|
586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614,
|
|
616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644,
|
|
646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674,
|
|
676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704,
|
|
706, 708, 710, 712, 714, 716, 718, 720, 0, 144, 2, 0, 39, 39, 150, 150,
|
|
2, 0, 531, 531, 537, 537, 3, 0, 69, 69, 159, 159, 181, 181, 3, 0, 42, 42,
|
|
384, 384, 454, 454, 4, 0, 42, 42, 419, 419, 529, 529, 611, 611, 2, 0, 514,
|
|
514, 1148, 1148, 2, 0, 78, 78, 141, 141, 2, 0, 15, 15, 334, 334, 3, 0,
|
|
44, 44, 85, 85, 184, 184, 2, 0, 434, 434, 558, 558, 3, 0, 506, 506, 650,
|
|
650, 658, 658, 2, 0, 392, 392, 460, 460, 2, 0, 352, 352, 474, 474, 2, 0,
|
|
42, 42, 1138, 1139, 2, 0, 350, 350, 443, 443, 2, 0, 459, 459, 673, 673,
|
|
3, 0, 80, 80, 84, 84, 125, 125, 3, 0, 42, 42, 402, 402, 431, 431, 3, 0,
|
|
42, 42, 398, 398, 792, 792, 2, 0, 637, 637, 672, 672, 2, 0, 81, 81, 91,
|
|
91, 3, 0, 436, 436, 548, 548, 613, 613, 2, 0, 69, 69, 159, 159, 1, 0, 356,
|
|
357, 1, 0, 1138, 1139, 2, 0, 1148, 1148, 1156, 1156, 2, 0, 81, 81, 388,
|
|
388, 2, 0, 545, 545, 1148, 1148, 2, 0, 546, 546, 1148, 1148, 3, 0, 430,
|
|
430, 469, 469, 521, 521, 7, 0, 42, 42, 370, 370, 372, 372, 402, 402, 431,
|
|
431, 573, 573, 1156, 1156, 2, 0, 514, 514, 530, 530, 1, 0, 1139, 1140,
|
|
2, 0, 5, 5, 51, 51, 4, 0, 42, 42, 384, 384, 454, 454, 458, 458, 2, 0, 26,
|
|
26, 30, 30, 2, 0, 12, 12, 175, 175, 2, 0, 192, 192, 677, 677, 2, 0, 21,
|
|
21, 144, 144, 3, 0, 43, 43, 75, 75, 106, 106, 2, 0, 106, 106, 374, 374,
|
|
2, 0, 365, 365, 427, 427, 2, 0, 101, 101, 601, 601, 2, 0, 43, 43, 106,
|
|
106, 2, 0, 6, 6, 49, 49, 2, 0, 188, 188, 669, 669, 4, 0, 430, 430, 469,
|
|
469, 520, 520, 562, 562, 2, 0, 430, 430, 520, 520, 2, 0, 13, 13, 45, 45,
|
|
3, 0, 66, 66, 78, 78, 186, 186, 2, 0, 34, 34, 83, 83, 2, 0, 97, 97, 148,
|
|
148, 2, 0, 6, 6, 49, 50, 1, 0, 626, 627, 2, 0, 172, 172, 742, 742, 2, 0,
|
|
439, 439, 609, 609, 2, 0, 226, 226, 477, 477, 5, 0, 107, 107, 482, 483,
|
|
485, 485, 489, 497, 575, 575, 4, 0, 479, 480, 484, 484, 486, 487, 576,
|
|
576, 3, 0, 108, 108, 478, 478, 488, 488, 2, 0, 462, 462, 628, 628, 2, 0,
|
|
622, 622, 624, 624, 2, 0, 344, 344, 629, 629, 2, 0, 90, 90, 591, 591, 2,
|
|
0, 51, 51, 390, 390, 3, 0, 31, 31, 61, 61, 179, 179, 3, 0, 131, 131, 172,
|
|
172, 437, 437, 3, 0, 12, 12, 19, 19, 187, 187, 2, 0, 42, 42, 121, 121,
|
|
2, 0, 103, 103, 182, 182, 2, 0, 360, 360, 614, 614, 2, 0, 40, 40, 671,
|
|
671, 2, 0, 115, 115, 474, 474, 2, 0, 422, 422, 568, 568, 4, 0, 206, 206,
|
|
208, 208, 214, 214, 638, 638, 2, 0, 1108, 1108, 1124, 1124, 2, 0, 345,
|
|
345, 577, 577, 2, 0, 68, 68, 80, 80, 6, 0, 131, 131, 172, 172, 177, 177,
|
|
415, 415, 437, 437, 671, 671, 2, 0, 513, 513, 634, 634, 2, 0, 412, 412,
|
|
675, 675, 2, 0, 131, 131, 437, 437, 3, 0, 81, 81, 92, 92, 452, 452, 3,
|
|
0, 439, 439, 474, 474, 609, 609, 2, 0, 634, 634, 670, 670, 2, 0, 376, 376,
|
|
567, 567, 6, 0, 226, 226, 409, 409, 411, 411, 438, 438, 574, 574, 615,
|
|
615, 2, 0, 45, 46, 62, 62, 3, 0, 422, 422, 550, 550, 885, 885, 2, 0, 466,
|
|
466, 652, 652, 10, 0, 359, 359, 367, 367, 378, 380, 387, 387, 507, 507,
|
|
515, 515, 639, 639, 646, 646, 836, 836, 1005, 1005, 2, 0, 35, 35, 168,
|
|
168, 2, 0, 117, 117, 996, 996, 11, 0, 359, 359, 367, 367, 378, 380, 387,
|
|
387, 507, 507, 515, 515, 592, 592, 639, 639, 646, 646, 836, 836, 1005,
|
|
1005, 2, 0, 1137, 1137, 1158, 1159, 1, 0, 1159, 1160, 2, 0, 375, 375, 787,
|
|
798, 3, 0, 1138, 1140, 1149, 1149, 1151, 1151, 2, 0, 63, 63, 178, 178,
|
|
2, 0, 116, 116, 1152, 1152, 5, 0, 25, 25, 222, 224, 231, 231, 233, 236,
|
|
518, 518, 2, 0, 25, 25, 222, 222, 2, 0, 25, 25, 222, 223, 1, 0, 196, 207,
|
|
3, 0, 183, 183, 195, 195, 612, 612, 2, 0, 211, 216, 431, 431, 6, 0, 217,
|
|
217, 228, 228, 230, 230, 232, 232, 239, 239, 348, 349, 4, 0, 218, 221,
|
|
226, 227, 229, 229, 346, 346, 2, 0, 153, 153, 237, 237, 2, 0, 466, 466,
|
|
803, 811, 3, 0, 211, 211, 226, 226, 518, 518, 6, 0, 200, 200, 206, 206,
|
|
209, 209, 217, 218, 220, 221, 466, 466, 1, 0, 214, 215, 2, 0, 183, 183,
|
|
612, 612, 2, 0, 200, 200, 206, 206, 2, 0, 315, 316, 322, 322, 3, 0, 150,
|
|
150, 313, 316, 331, 331, 1, 0, 325, 326, 3, 0, 17, 17, 95, 95, 176, 176,
|
|
2, 0, 222, 222, 226, 226, 2, 0, 217, 218, 220, 220, 3, 0, 13, 13, 45, 45,
|
|
994, 994, 3, 0, 286, 286, 298, 299, 309, 309, 3, 0, 287, 289, 305, 308,
|
|
310, 312, 2, 0, 295, 295, 297, 297, 2, 0, 293, 293, 296, 296, 2, 0, 291,
|
|
292, 302, 304, 2, 0, 133, 133, 601, 601, 2, 0, 433, 433, 559, 559, 2, 0,
|
|
535, 535, 551, 551, 2, 0, 114, 114, 1127, 1127, 3, 0, 63, 63, 178, 178,
|
|
662, 662, 2, 0, 137, 137, 149, 149, 3, 0, 6, 6, 337, 337, 618, 618, 3,
|
|
0, 114, 114, 1120, 1121, 1127, 1128, 2, 0, 1117, 1119, 1122, 1123, 1, 0,
|
|
1120, 1121, 2, 0, 226, 226, 746, 786, 1, 0, 799, 802, 5, 0, 708, 709, 725,
|
|
727, 733, 733, 739, 740, 742, 742, 1, 0, 689, 696, 3, 0, 217, 221, 234,
|
|
234, 237, 237, 57, 0, 11, 11, 14, 14, 18, 18, 29, 29, 35, 35, 37, 37, 42,
|
|
42, 48, 48, 55, 55, 57, 57, 59, 59, 73, 73, 79, 79, 94, 94, 117, 117, 121,
|
|
121, 124, 124, 130, 130, 158, 158, 168, 168, 239, 239, 283, 290, 294, 294,
|
|
298, 299, 305, 312, 332, 385, 387, 403, 405, 405, 407, 432, 434, 450, 452,
|
|
458, 460, 521, 523, 523, 527, 544, 547, 558, 560, 589, 591, 606, 608, 636,
|
|
638, 672, 674, 675, 677, 688, 697, 697, 699, 707, 710, 712, 717, 718, 720,
|
|
724, 728, 732, 734, 734, 736, 738, 741, 741, 743, 745, 792, 792, 836, 836,
|
|
875, 875, 1000, 1000, 1005, 1005, 1088, 1088, 24, 0, 39, 39, 97, 97, 148,
|
|
148, 150, 150, 170, 170, 217, 219, 221, 221, 251, 282, 290, 293, 295, 297,
|
|
300, 304, 324, 324, 459, 459, 673, 673, 689, 696, 736, 736, 803, 803, 806,
|
|
835, 837, 874, 876, 999, 1001, 1004, 1006, 1087, 1089, 1107, 1123, 1123,
|
|
8771, 0, 723, 1, 0, 0, 0, 2, 742, 1, 0, 0, 0, 4, 763, 1, 0, 0, 0, 6, 765,
|
|
1, 0, 0, 0, 8, 805, 1, 0, 0, 0, 10, 820, 1, 0, 0, 0, 12, 831, 1, 0, 0,
|
|
0, 14, 848, 1, 0, 0, 0, 16, 853, 1, 0, 0, 0, 18, 868, 1, 0, 0, 0, 20, 895,
|
|
1, 0, 0, 0, 22, 904, 1, 0, 0, 0, 24, 906, 1, 0, 0, 0, 26, 918, 1, 0, 0,
|
|
0, 28, 948, 1, 0, 0, 0, 30, 984, 1, 0, 0, 0, 32, 1035, 1, 0, 0, 0, 34,
|
|
1061, 1, 0, 0, 0, 36, 1097, 1, 0, 0, 0, 38, 1110, 1, 0, 0, 0, 40, 1207,
|
|
1, 0, 0, 0, 42, 1209, 1, 0, 0, 0, 44, 1227, 1, 0, 0, 0, 46, 1288, 1, 0,
|
|
0, 0, 48, 1310, 1, 0, 0, 0, 50, 1316, 1, 0, 0, 0, 52, 1338, 1, 0, 0, 0,
|
|
54, 1340, 1, 0, 0, 0, 56, 1342, 1, 0, 0, 0, 58, 1422, 1, 0, 0, 0, 60, 1429,
|
|
1, 0, 0, 0, 62, 1431, 1, 0, 0, 0, 64, 1436, 1, 0, 0, 0, 66, 1476, 1, 0,
|
|
0, 0, 68, 1482, 1, 0, 0, 0, 70, 1484, 1, 0, 0, 0, 72, 1505, 1, 0, 0, 0,
|
|
74, 1512, 1, 0, 0, 0, 76, 1514, 1, 0, 0, 0, 78, 1539, 1, 0, 0, 0, 80, 1542,
|
|
1, 0, 0, 0, 82, 1547, 1, 0, 0, 0, 84, 1573, 1, 0, 0, 0, 86, 1589, 1, 0,
|
|
0, 0, 88, 1591, 1, 0, 0, 0, 90, 1613, 1, 0, 0, 0, 92, 1615, 1, 0, 0, 0,
|
|
94, 1681, 1, 0, 0, 0, 96, 1752, 1, 0, 0, 0, 98, 1754, 1, 0, 0, 0, 100,
|
|
1782, 1, 0, 0, 0, 102, 1792, 1, 0, 0, 0, 104, 1822, 1, 0, 0, 0, 106, 2009,
|
|
1, 0, 0, 0, 108, 2011, 1, 0, 0, 0, 110, 2013, 1, 0, 0, 0, 112, 2016, 1,
|
|
0, 0, 0, 114, 2091, 1, 0, 0, 0, 116, 2114, 1, 0, 0, 0, 118, 2262, 1, 0,
|
|
0, 0, 120, 2267, 1, 0, 0, 0, 122, 2269, 1, 0, 0, 0, 124, 2279, 1, 0, 0,
|
|
0, 126, 2335, 1, 0, 0, 0, 128, 2355, 1, 0, 0, 0, 130, 2357, 1, 0, 0, 0,
|
|
132, 2392, 1, 0, 0, 0, 134, 2401, 1, 0, 0, 0, 136, 2408, 1, 0, 0, 0, 138,
|
|
2431, 1, 0, 0, 0, 140, 2440, 1, 0, 0, 0, 142, 2455, 1, 0, 0, 0, 144, 2480,
|
|
1, 0, 0, 0, 146, 2500, 1, 0, 0, 0, 148, 2883, 1, 0, 0, 0, 150, 2983, 1,
|
|
0, 0, 0, 152, 2985, 1, 0, 0, 0, 154, 2992, 1, 0, 0, 0, 156, 2999, 1, 0,
|
|
0, 0, 158, 3022, 1, 0, 0, 0, 160, 3030, 1, 0, 0, 0, 162, 3037, 1, 0, 0,
|
|
0, 164, 3044, 1, 0, 0, 0, 166, 3051, 1, 0, 0, 0, 168, 3063, 1, 0, 0, 0,
|
|
170, 3073, 1, 0, 0, 0, 172, 3080, 1, 0, 0, 0, 174, 3096, 1, 0, 0, 0, 176,
|
|
3142, 1, 0, 0, 0, 178, 3144, 1, 0, 0, 0, 180, 3154, 1, 0, 0, 0, 182, 3158,
|
|
1, 0, 0, 0, 184, 3164, 1, 0, 0, 0, 186, 3176, 1, 0, 0, 0, 188, 3178, 1,
|
|
0, 0, 0, 190, 3185, 1, 0, 0, 0, 192, 3187, 1, 0, 0, 0, 194, 3245, 1, 0,
|
|
0, 0, 196, 3319, 1, 0, 0, 0, 198, 3378, 1, 0, 0, 0, 200, 3476, 1, 0, 0,
|
|
0, 202, 3480, 1, 0, 0, 0, 204, 3482, 1, 0, 0, 0, 206, 3517, 1, 0, 0, 0,
|
|
208, 3519, 1, 0, 0, 0, 210, 3527, 1, 0, 0, 0, 212, 3535, 1, 0, 0, 0, 214,
|
|
3537, 1, 0, 0, 0, 216, 3573, 1, 0, 0, 0, 218, 3628, 1, 0, 0, 0, 220, 3637,
|
|
1, 0, 0, 0, 222, 3657, 1, 0, 0, 0, 224, 3669, 1, 0, 0, 0, 226, 3673, 1,
|
|
0, 0, 0, 228, 3706, 1, 0, 0, 0, 230, 3727, 1, 0, 0, 0, 232, 3737, 1, 0,
|
|
0, 0, 234, 3741, 1, 0, 0, 0, 236, 3767, 1, 0, 0, 0, 238, 3809, 1, 0, 0,
|
|
0, 240, 3811, 1, 0, 0, 0, 242, 3826, 1, 0, 0, 0, 244, 3875, 1, 0, 0, 0,
|
|
246, 3884, 1, 0, 0, 0, 248, 3894, 1, 0, 0, 0, 250, 3904, 1, 0, 0, 0, 252,
|
|
3960, 1, 0, 0, 0, 254, 3962, 1, 0, 0, 0, 256, 3989, 1, 0, 0, 0, 258, 3995,
|
|
1, 0, 0, 0, 260, 4003, 1, 0, 0, 0, 262, 4020, 1, 0, 0, 0, 264, 4036, 1,
|
|
0, 0, 0, 266, 4073, 1, 0, 0, 0, 268, 4079, 1, 0, 0, 0, 270, 4088, 1, 0,
|
|
0, 0, 272, 4101, 1, 0, 0, 0, 274, 4105, 1, 0, 0, 0, 276, 4143, 1, 0, 0,
|
|
0, 278, 4181, 1, 0, 0, 0, 280, 4195, 1, 0, 0, 0, 282, 4203, 1, 0, 0, 0,
|
|
284, 4207, 1, 0, 0, 0, 286, 4213, 1, 0, 0, 0, 288, 4227, 1, 0, 0, 0, 290,
|
|
4230, 1, 0, 0, 0, 292, 4248, 1, 0, 0, 0, 294, 4252, 1, 0, 0, 0, 296, 4268,
|
|
1, 0, 0, 0, 298, 4270, 1, 0, 0, 0, 300, 4282, 1, 0, 0, 0, 302, 4286, 1,
|
|
0, 0, 0, 304, 4303, 1, 0, 0, 0, 306, 4320, 1, 0, 0, 0, 308, 4323, 1, 0,
|
|
0, 0, 310, 4333, 1, 0, 0, 0, 312, 4337, 1, 0, 0, 0, 314, 4350, 1, 0, 0,
|
|
0, 316, 4353, 1, 0, 0, 0, 318, 4358, 1, 0, 0, 0, 320, 4378, 1, 0, 0, 0,
|
|
322, 4380, 1, 0, 0, 0, 324, 4397, 1, 0, 0, 0, 326, 4406, 1, 0, 0, 0, 328,
|
|
4415, 1, 0, 0, 0, 330, 4417, 1, 0, 0, 0, 332, 4431, 1, 0, 0, 0, 334, 4442,
|
|
1, 0, 0, 0, 336, 4451, 1, 0, 0, 0, 338, 4454, 1, 0, 0, 0, 340, 4462, 1,
|
|
0, 0, 0, 342, 4487, 1, 0, 0, 0, 344, 4499, 1, 0, 0, 0, 346, 4502, 1, 0,
|
|
0, 0, 348, 4534, 1, 0, 0, 0, 350, 4536, 1, 0, 0, 0, 352, 4538, 1, 0, 0,
|
|
0, 354, 4540, 1, 0, 0, 0, 356, 4542, 1, 0, 0, 0, 358, 4595, 1, 0, 0, 0,
|
|
360, 4597, 1, 0, 0, 0, 362, 4603, 1, 0, 0, 0, 364, 4623, 1, 0, 0, 0, 366,
|
|
4637, 1, 0, 0, 0, 368, 4648, 1, 0, 0, 0, 370, 4650, 1, 0, 0, 0, 372, 4656,
|
|
1, 0, 0, 0, 374, 4666, 1, 0, 0, 0, 376, 4670, 1, 0, 0, 0, 378, 4677, 1,
|
|
0, 0, 0, 380, 4681, 1, 0, 0, 0, 382, 4687, 1, 0, 0, 0, 384, 4694, 1, 0,
|
|
0, 0, 386, 4700, 1, 0, 0, 0, 388, 4706, 1, 0, 0, 0, 390, 4711, 1, 0, 0,
|
|
0, 392, 4756, 1, 0, 0, 0, 394, 4777, 1, 0, 0, 0, 396, 4802, 1, 0, 0, 0,
|
|
398, 4805, 1, 0, 0, 0, 400, 4811, 1, 0, 0, 0, 402, 4827, 1, 0, 0, 0, 404,
|
|
4842, 1, 0, 0, 0, 406, 4848, 1, 0, 0, 0, 408, 4878, 1, 0, 0, 0, 410, 4880,
|
|
1, 0, 0, 0, 412, 4887, 1, 0, 0, 0, 414, 4899, 1, 0, 0, 0, 416, 4905, 1,
|
|
0, 0, 0, 418, 4930, 1, 0, 0, 0, 420, 4934, 1, 0, 0, 0, 422, 4938, 1, 0,
|
|
0, 0, 424, 4949, 1, 0, 0, 0, 426, 5030, 1, 0, 0, 0, 428, 5097, 1, 0, 0,
|
|
0, 430, 5099, 1, 0, 0, 0, 432, 5205, 1, 0, 0, 0, 434, 5229, 1, 0, 0, 0,
|
|
436, 5231, 1, 0, 0, 0, 438, 5249, 1, 0, 0, 0, 440, 5329, 1, 0, 0, 0, 442,
|
|
5331, 1, 0, 0, 0, 444, 5344, 1, 0, 0, 0, 446, 5355, 1, 0, 0, 0, 448, 5383,
|
|
1, 0, 0, 0, 450, 5387, 1, 0, 0, 0, 452, 5408, 1, 0, 0, 0, 454, 5418, 1,
|
|
0, 0, 0, 456, 5428, 1, 0, 0, 0, 458, 5468, 1, 0, 0, 0, 460, 5470, 1, 0,
|
|
0, 0, 462, 5473, 1, 0, 0, 0, 464, 5573, 1, 0, 0, 0, 466, 5591, 1, 0, 0,
|
|
0, 468, 5593, 1, 0, 0, 0, 470, 5597, 1, 0, 0, 0, 472, 5635, 1, 0, 0, 0,
|
|
474, 5644, 1, 0, 0, 0, 476, 5650, 1, 0, 0, 0, 478, 5657, 1, 0, 0, 0, 480,
|
|
5679, 1, 0, 0, 0, 482, 5681, 1, 0, 0, 0, 484, 5695, 1, 0, 0, 0, 486, 5701,
|
|
1, 0, 0, 0, 488, 5757, 1, 0, 0, 0, 490, 5912, 1, 0, 0, 0, 492, 5924, 1,
|
|
0, 0, 0, 494, 5939, 1, 0, 0, 0, 496, 5945, 1, 0, 0, 0, 498, 5964, 1, 0,
|
|
0, 0, 500, 5974, 1, 0, 0, 0, 502, 5988, 1, 0, 0, 0, 504, 5990, 1, 0, 0,
|
|
0, 506, 5993, 1, 0, 0, 0, 508, 6015, 1, 0, 0, 0, 510, 6027, 1, 0, 0, 0,
|
|
512, 6033, 1, 0, 0, 0, 514, 6045, 1, 0, 0, 0, 516, 6049, 1, 0, 0, 0, 518,
|
|
6051, 1, 0, 0, 0, 520, 6093, 1, 0, 0, 0, 522, 6100, 1, 0, 0, 0, 524, 6102,
|
|
1, 0, 0, 0, 526, 6125, 1, 0, 0, 0, 528, 6131, 1, 0, 0, 0, 530, 6139, 1,
|
|
0, 0, 0, 532, 6142, 1, 0, 0, 0, 534, 6145, 1, 0, 0, 0, 536, 6166, 1, 0,
|
|
0, 0, 538, 6187, 1, 0, 0, 0, 540, 6195, 1, 0, 0, 0, 542, 6207, 1, 0, 0,
|
|
0, 544, 6215, 1, 0, 0, 0, 546, 6253, 1, 0, 0, 0, 548, 6265, 1, 0, 0, 0,
|
|
550, 6267, 1, 0, 0, 0, 552, 6273, 1, 0, 0, 0, 554, 6277, 1, 0, 0, 0, 556,
|
|
6293, 1, 0, 0, 0, 558, 6306, 1, 0, 0, 0, 560, 6315, 1, 0, 0, 0, 562, 6317,
|
|
1, 0, 0, 0, 564, 6324, 1, 0, 0, 0, 566, 6326, 1, 0, 0, 0, 568, 6332, 1,
|
|
0, 0, 0, 570, 6336, 1, 0, 0, 0, 572, 6341, 1, 0, 0, 0, 574, 6343, 1, 0,
|
|
0, 0, 576, 6345, 1, 0, 0, 0, 578, 6363, 1, 0, 0, 0, 580, 6379, 1, 0, 0,
|
|
0, 582, 6383, 1, 0, 0, 0, 584, 6388, 1, 0, 0, 0, 586, 6399, 1, 0, 0, 0,
|
|
588, 6404, 1, 0, 0, 0, 590, 6406, 1, 0, 0, 0, 592, 6410, 1, 0, 0, 0, 594,
|
|
6435, 1, 0, 0, 0, 596, 6437, 1, 0, 0, 0, 598, 6440, 1, 0, 0, 0, 600, 6445,
|
|
1, 0, 0, 0, 602, 6461, 1, 0, 0, 0, 604, 6589, 1, 0, 0, 0, 606, 6591, 1,
|
|
0, 0, 0, 608, 6624, 1, 0, 0, 0, 610, 6629, 1, 0, 0, 0, 612, 6633, 1, 0,
|
|
0, 0, 614, 6639, 1, 0, 0, 0, 616, 6647, 1, 0, 0, 0, 618, 6655, 1, 0, 0,
|
|
0, 620, 6663, 1, 0, 0, 0, 622, 6671, 1, 0, 0, 0, 624, 6682, 1, 0, 0, 0,
|
|
626, 6690, 1, 0, 0, 0, 628, 6698, 1, 0, 0, 0, 630, 6706, 1, 0, 0, 0, 632,
|
|
6714, 1, 0, 0, 0, 634, 6748, 1, 0, 0, 0, 636, 6764, 1, 0, 0, 0, 638, 6768,
|
|
1, 0, 0, 0, 640, 6770, 1, 0, 0, 0, 642, 6773, 1, 0, 0, 0, 644, 6777, 1,
|
|
0, 0, 0, 646, 6783, 1, 0, 0, 0, 648, 6803, 1, 0, 0, 0, 650, 6984, 1, 0,
|
|
0, 0, 652, 6986, 1, 0, 0, 0, 654, 7005, 1, 0, 0, 0, 656, 7007, 1, 0, 0,
|
|
0, 658, 7070, 1, 0, 0, 0, 660, 7110, 1, 0, 0, 0, 662, 7112, 1, 0, 0, 0,
|
|
664, 7121, 1, 0, 0, 0, 666, 7132, 1, 0, 0, 0, 668, 7134, 1, 0, 0, 0, 670,
|
|
7137, 1, 0, 0, 0, 672, 7141, 1, 0, 0, 0, 674, 7143, 1, 0, 0, 0, 676, 7155,
|
|
1, 0, 0, 0, 678, 7157, 1, 0, 0, 0, 680, 7191, 1, 0, 0, 0, 682, 7193, 1,
|
|
0, 0, 0, 684, 7202, 1, 0, 0, 0, 686, 7220, 1, 0, 0, 0, 688, 7233, 1, 0,
|
|
0, 0, 690, 7244, 1, 0, 0, 0, 692, 7362, 1, 0, 0, 0, 694, 7388, 1, 0, 0,
|
|
0, 696, 7404, 1, 0, 0, 0, 698, 7413, 1, 0, 0, 0, 700, 7422, 1, 0, 0, 0,
|
|
702, 7424, 1, 0, 0, 0, 704, 7426, 1, 0, 0, 0, 706, 7433, 1, 0, 0, 0, 708,
|
|
7435, 1, 0, 0, 0, 710, 7437, 1, 0, 0, 0, 712, 7439, 1, 0, 0, 0, 714, 7441,
|
|
1, 0, 0, 0, 716, 7443, 1, 0, 0, 0, 718, 7445, 1, 0, 0, 0, 720, 7447, 1,
|
|
0, 0, 0, 722, 724, 3, 2, 1, 0, 723, 722, 1, 0, 0, 0, 723, 724, 1, 0, 0,
|
|
0, 724, 727, 1, 0, 0, 0, 725, 726, 5, 1121, 0, 0, 726, 728, 5, 1121, 0,
|
|
0, 727, 725, 1, 0, 0, 0, 727, 728, 1, 0, 0, 0, 728, 729, 1, 0, 0, 0, 729,
|
|
730, 5, 0, 0, 1, 730, 1, 1, 0, 0, 0, 731, 734, 3, 4, 2, 0, 732, 733, 5,
|
|
1121, 0, 0, 733, 735, 5, 1121, 0, 0, 734, 732, 1, 0, 0, 0, 734, 735, 1,
|
|
0, 0, 0, 735, 737, 1, 0, 0, 0, 736, 738, 5, 1136, 0, 0, 737, 736, 1, 0,
|
|
0, 0, 737, 738, 1, 0, 0, 0, 738, 741, 1, 0, 0, 0, 739, 741, 3, 6, 3, 0,
|
|
740, 731, 1, 0, 0, 0, 740, 739, 1, 0, 0, 0, 741, 744, 1, 0, 0, 0, 742,
|
|
740, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 754, 1, 0, 0, 0, 744, 742,
|
|
1, 0, 0, 0, 745, 751, 3, 4, 2, 0, 746, 747, 5, 1121, 0, 0, 747, 749, 5,
|
|
1121, 0, 0, 748, 746, 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, 749, 750, 1, 0,
|
|
0, 0, 750, 752, 5, 1136, 0, 0, 751, 748, 1, 0, 0, 0, 751, 752, 1, 0, 0,
|
|
0, 752, 755, 1, 0, 0, 0, 753, 755, 3, 6, 3, 0, 754, 745, 1, 0, 0, 0, 754,
|
|
753, 1, 0, 0, 0, 755, 3, 1, 0, 0, 0, 756, 764, 3, 8, 4, 0, 757, 764, 3,
|
|
10, 5, 0, 758, 764, 3, 12, 6, 0, 759, 764, 3, 14, 7, 0, 760, 764, 3, 16,
|
|
8, 0, 761, 764, 3, 20, 10, 0, 762, 764, 3, 22, 11, 0, 763, 756, 1, 0, 0,
|
|
0, 763, 757, 1, 0, 0, 0, 763, 758, 1, 0, 0, 0, 763, 759, 1, 0, 0, 0, 763,
|
|
760, 1, 0, 0, 0, 763, 761, 1, 0, 0, 0, 763, 762, 1, 0, 0, 0, 764, 5, 1,
|
|
0, 0, 0, 765, 766, 5, 1136, 0, 0, 766, 7, 1, 0, 0, 0, 767, 806, 3, 24,
|
|
12, 0, 768, 806, 3, 26, 13, 0, 769, 806, 3, 28, 14, 0, 770, 806, 3, 30,
|
|
15, 0, 771, 806, 3, 32, 16, 0, 772, 806, 3, 34, 17, 0, 773, 806, 3, 38,
|
|
19, 0, 774, 806, 3, 40, 20, 0, 775, 806, 3, 42, 21, 0, 776, 806, 3, 44,
|
|
22, 0, 777, 806, 3, 46, 23, 0, 778, 806, 3, 56, 28, 0, 779, 806, 3, 36,
|
|
18, 0, 780, 806, 3, 128, 64, 0, 781, 806, 3, 130, 65, 0, 782, 806, 3, 132,
|
|
66, 0, 783, 806, 3, 134, 67, 0, 784, 806, 3, 136, 68, 0, 785, 806, 3, 138,
|
|
69, 0, 786, 806, 3, 140, 70, 0, 787, 806, 3, 142, 71, 0, 788, 806, 3, 144,
|
|
72, 0, 789, 806, 3, 146, 73, 0, 790, 806, 3, 152, 76, 0, 791, 806, 3, 154,
|
|
77, 0, 792, 806, 3, 156, 78, 0, 793, 806, 3, 158, 79, 0, 794, 806, 3, 160,
|
|
80, 0, 795, 806, 3, 162, 81, 0, 796, 806, 3, 164, 82, 0, 797, 806, 3, 166,
|
|
83, 0, 798, 806, 3, 168, 84, 0, 799, 806, 3, 170, 85, 0, 800, 806, 3, 172,
|
|
86, 0, 801, 806, 3, 174, 87, 0, 802, 806, 3, 176, 88, 0, 803, 806, 3, 178,
|
|
89, 0, 804, 806, 3, 182, 91, 0, 805, 767, 1, 0, 0, 0, 805, 768, 1, 0, 0,
|
|
0, 805, 769, 1, 0, 0, 0, 805, 770, 1, 0, 0, 0, 805, 771, 1, 0, 0, 0, 805,
|
|
772, 1, 0, 0, 0, 805, 773, 1, 0, 0, 0, 805, 774, 1, 0, 0, 0, 805, 775,
|
|
1, 0, 0, 0, 805, 776, 1, 0, 0, 0, 805, 777, 1, 0, 0, 0, 805, 778, 1, 0,
|
|
0, 0, 805, 779, 1, 0, 0, 0, 805, 780, 1, 0, 0, 0, 805, 781, 1, 0, 0, 0,
|
|
805, 782, 1, 0, 0, 0, 805, 783, 1, 0, 0, 0, 805, 784, 1, 0, 0, 0, 805,
|
|
785, 1, 0, 0, 0, 805, 786, 1, 0, 0, 0, 805, 787, 1, 0, 0, 0, 805, 788,
|
|
1, 0, 0, 0, 805, 789, 1, 0, 0, 0, 805, 790, 1, 0, 0, 0, 805, 791, 1, 0,
|
|
0, 0, 805, 792, 1, 0, 0, 0, 805, 793, 1, 0, 0, 0, 805, 794, 1, 0, 0, 0,
|
|
805, 795, 1, 0, 0, 0, 805, 796, 1, 0, 0, 0, 805, 797, 1, 0, 0, 0, 805,
|
|
798, 1, 0, 0, 0, 805, 799, 1, 0, 0, 0, 805, 800, 1, 0, 0, 0, 805, 801,
|
|
1, 0, 0, 0, 805, 802, 1, 0, 0, 0, 805, 803, 1, 0, 0, 0, 805, 804, 1, 0,
|
|
0, 0, 806, 9, 1, 0, 0, 0, 807, 821, 3, 200, 100, 0, 808, 821, 3, 192, 96,
|
|
0, 809, 821, 3, 202, 101, 0, 810, 821, 3, 186, 93, 0, 811, 821, 3, 198,
|
|
99, 0, 812, 821, 3, 184, 92, 0, 813, 821, 3, 194, 97, 0, 814, 821, 3, 196,
|
|
98, 0, 815, 821, 3, 188, 94, 0, 816, 821, 3, 190, 95, 0, 817, 821, 3, 204,
|
|
102, 0, 818, 821, 3, 540, 270, 0, 819, 821, 3, 542, 271, 0, 820, 807, 1,
|
|
0, 0, 0, 820, 808, 1, 0, 0, 0, 820, 809, 1, 0, 0, 0, 820, 810, 1, 0, 0,
|
|
0, 820, 811, 1, 0, 0, 0, 820, 812, 1, 0, 0, 0, 820, 813, 1, 0, 0, 0, 820,
|
|
814, 1, 0, 0, 0, 820, 815, 1, 0, 0, 0, 820, 816, 1, 0, 0, 0, 820, 817,
|
|
1, 0, 0, 0, 820, 818, 1, 0, 0, 0, 820, 819, 1, 0, 0, 0, 821, 11, 1, 0,
|
|
0, 0, 822, 832, 3, 298, 149, 0, 823, 832, 3, 300, 150, 0, 824, 832, 3,
|
|
302, 151, 0, 825, 832, 3, 304, 152, 0, 826, 832, 3, 306, 153, 0, 827, 832,
|
|
3, 308, 154, 0, 828, 832, 3, 310, 155, 0, 829, 832, 3, 312, 156, 0, 830,
|
|
832, 3, 314, 157, 0, 831, 822, 1, 0, 0, 0, 831, 823, 1, 0, 0, 0, 831, 824,
|
|
1, 0, 0, 0, 831, 825, 1, 0, 0, 0, 831, 826, 1, 0, 0, 0, 831, 827, 1, 0,
|
|
0, 0, 831, 828, 1, 0, 0, 0, 831, 829, 1, 0, 0, 0, 831, 830, 1, 0, 0, 0,
|
|
832, 13, 1, 0, 0, 0, 833, 849, 3, 330, 165, 0, 834, 849, 3, 332, 166, 0,
|
|
835, 849, 3, 334, 167, 0, 836, 849, 3, 336, 168, 0, 837, 849, 3, 338, 169,
|
|
0, 838, 849, 3, 340, 170, 0, 839, 849, 3, 342, 171, 0, 840, 849, 3, 344,
|
|
172, 0, 841, 849, 3, 346, 173, 0, 842, 849, 3, 370, 185, 0, 843, 849, 3,
|
|
372, 186, 0, 844, 849, 3, 374, 187, 0, 845, 849, 3, 376, 188, 0, 846, 849,
|
|
3, 378, 189, 0, 847, 849, 3, 380, 190, 0, 848, 833, 1, 0, 0, 0, 848, 834,
|
|
1, 0, 0, 0, 848, 835, 1, 0, 0, 0, 848, 836, 1, 0, 0, 0, 848, 837, 1, 0,
|
|
0, 0, 848, 838, 1, 0, 0, 0, 848, 839, 1, 0, 0, 0, 848, 840, 1, 0, 0, 0,
|
|
848, 841, 1, 0, 0, 0, 848, 842, 1, 0, 0, 0, 848, 843, 1, 0, 0, 0, 848,
|
|
844, 1, 0, 0, 0, 848, 845, 1, 0, 0, 0, 848, 846, 1, 0, 0, 0, 848, 847,
|
|
1, 0, 0, 0, 849, 15, 1, 0, 0, 0, 850, 854, 3, 382, 191, 0, 851, 854, 3,
|
|
384, 192, 0, 852, 854, 3, 386, 193, 0, 853, 850, 1, 0, 0, 0, 853, 851,
|
|
1, 0, 0, 0, 853, 852, 1, 0, 0, 0, 854, 17, 1, 0, 0, 0, 855, 869, 3, 390,
|
|
195, 0, 856, 869, 3, 392, 196, 0, 857, 869, 3, 394, 197, 0, 858, 869, 3,
|
|
398, 199, 0, 859, 869, 3, 400, 200, 0, 860, 869, 3, 402, 201, 0, 861, 869,
|
|
3, 406, 203, 0, 862, 869, 3, 396, 198, 0, 863, 869, 3, 404, 202, 0, 864,
|
|
869, 3, 408, 204, 0, 865, 866, 3, 540, 270, 0, 866, 867, 3, 10, 5, 0, 867,
|
|
869, 1, 0, 0, 0, 868, 855, 1, 0, 0, 0, 868, 856, 1, 0, 0, 0, 868, 857,
|
|
1, 0, 0, 0, 868, 858, 1, 0, 0, 0, 868, 859, 1, 0, 0, 0, 868, 860, 1, 0,
|
|
0, 0, 868, 861, 1, 0, 0, 0, 868, 862, 1, 0, 0, 0, 868, 863, 1, 0, 0, 0,
|
|
868, 864, 1, 0, 0, 0, 868, 865, 1, 0, 0, 0, 869, 19, 1, 0, 0, 0, 870, 896,
|
|
3, 426, 213, 0, 871, 896, 3, 428, 214, 0, 872, 896, 3, 430, 215, 0, 873,
|
|
896, 3, 432, 216, 0, 874, 896, 3, 436, 218, 0, 875, 896, 3, 438, 219, 0,
|
|
876, 896, 3, 440, 220, 0, 877, 896, 3, 442, 221, 0, 878, 896, 3, 470, 235,
|
|
0, 879, 896, 3, 472, 236, 0, 880, 896, 3, 474, 237, 0, 881, 896, 3, 476,
|
|
238, 0, 882, 896, 3, 478, 239, 0, 883, 896, 3, 482, 241, 0, 884, 896, 3,
|
|
484, 242, 0, 885, 896, 3, 486, 243, 0, 886, 896, 3, 488, 244, 0, 887, 896,
|
|
3, 490, 245, 0, 888, 896, 3, 504, 252, 0, 889, 896, 3, 506, 253, 0, 890,
|
|
896, 3, 508, 254, 0, 891, 896, 3, 510, 255, 0, 892, 896, 3, 512, 256, 0,
|
|
893, 896, 3, 514, 257, 0, 894, 896, 3, 516, 258, 0, 895, 870, 1, 0, 0,
|
|
0, 895, 871, 1, 0, 0, 0, 895, 872, 1, 0, 0, 0, 895, 873, 1, 0, 0, 0, 895,
|
|
874, 1, 0, 0, 0, 895, 875, 1, 0, 0, 0, 895, 876, 1, 0, 0, 0, 895, 877,
|
|
1, 0, 0, 0, 895, 878, 1, 0, 0, 0, 895, 879, 1, 0, 0, 0, 895, 880, 1, 0,
|
|
0, 0, 895, 881, 1, 0, 0, 0, 895, 882, 1, 0, 0, 0, 895, 883, 1, 0, 0, 0,
|
|
895, 884, 1, 0, 0, 0, 895, 885, 1, 0, 0, 0, 895, 886, 1, 0, 0, 0, 895,
|
|
887, 1, 0, 0, 0, 895, 888, 1, 0, 0, 0, 895, 889, 1, 0, 0, 0, 895, 890,
|
|
1, 0, 0, 0, 895, 891, 1, 0, 0, 0, 895, 892, 1, 0, 0, 0, 895, 893, 1, 0,
|
|
0, 0, 895, 894, 1, 0, 0, 0, 896, 21, 1, 0, 0, 0, 897, 905, 3, 526, 263,
|
|
0, 898, 905, 3, 528, 264, 0, 899, 905, 3, 530, 265, 0, 900, 905, 3, 532,
|
|
266, 0, 901, 905, 3, 534, 267, 0, 902, 905, 3, 536, 268, 0, 903, 905, 3,
|
|
544, 272, 0, 904, 897, 1, 0, 0, 0, 904, 898, 1, 0, 0, 0, 904, 899, 1, 0,
|
|
0, 0, 904, 900, 1, 0, 0, 0, 904, 901, 1, 0, 0, 0, 904, 902, 1, 0, 0, 0,
|
|
904, 903, 1, 0, 0, 0, 905, 23, 1, 0, 0, 0, 906, 907, 5, 33, 0, 0, 907,
|
|
909, 7, 0, 0, 0, 908, 910, 3, 642, 321, 0, 909, 908, 1, 0, 0, 0, 909, 910,
|
|
1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 915, 3, 584, 292, 0, 912, 914, 3,
|
|
58, 29, 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0,
|
|
0, 0, 915, 916, 1, 0, 0, 0, 916, 25, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0,
|
|
918, 920, 5, 33, 0, 0, 919, 921, 3, 64, 32, 0, 920, 919, 1, 0, 0, 0, 920,
|
|
921, 1, 0, 0, 0, 921, 922, 1, 0, 0, 0, 922, 924, 5, 415, 0, 0, 923, 925,
|
|
3, 642, 321, 0, 924, 923, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 926, 1,
|
|
0, 0, 0, 926, 927, 3, 550, 275, 0, 927, 928, 5, 118, 0, 0, 928, 929, 5,
|
|
605, 0, 0, 929, 936, 3, 66, 33, 0, 930, 931, 5, 118, 0, 0, 931, 933, 5,
|
|
371, 0, 0, 932, 934, 5, 114, 0, 0, 933, 932, 1, 0, 0, 0, 933, 934, 1, 0,
|
|
0, 0, 934, 935, 1, 0, 0, 0, 935, 937, 5, 561, 0, 0, 936, 930, 1, 0, 0,
|
|
0, 936, 937, 1, 0, 0, 0, 937, 939, 1, 0, 0, 0, 938, 940, 3, 74, 37, 0,
|
|
939, 938, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 943, 1, 0, 0, 0, 941,
|
|
942, 5, 368, 0, 0, 942, 944, 5, 1148, 0, 0, 943, 941, 1, 0, 0, 0, 943,
|
|
944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 5, 399, 0, 0, 946, 947,
|
|
3, 388, 194, 0, 947, 27, 1, 0, 0, 0, 948, 950, 5, 33, 0, 0, 949, 951, 7,
|
|
1, 0, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 953, 1, 0, 0,
|
|
0, 952, 954, 7, 2, 0, 0, 953, 952, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 954,
|
|
955, 1, 0, 0, 0, 955, 956, 5, 81, 0, 0, 956, 958, 3, 584, 292, 0, 957,
|
|
959, 3, 76, 38, 0, 958, 957, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 960,
|
|
1, 0, 0, 0, 960, 961, 5, 118, 0, 0, 961, 962, 3, 552, 276, 0, 962, 966,
|
|
3, 622, 311, 0, 963, 965, 3, 78, 39, 0, 964, 963, 1, 0, 0, 0, 965, 968,
|
|
1, 0, 0, 0, 966, 964, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 981, 1, 0,
|
|
0, 0, 968, 966, 1, 0, 0, 0, 969, 971, 5, 336, 0, 0, 970, 972, 5, 1124,
|
|
0, 0, 971, 970, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 973, 1, 0, 0, 0,
|
|
973, 980, 7, 3, 0, 0, 974, 976, 5, 103, 0, 0, 975, 977, 5, 1124, 0, 0,
|
|
976, 975, 1, 0, 0, 0, 976, 977, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978,
|
|
980, 7, 4, 0, 0, 979, 969, 1, 0, 0, 0, 979, 974, 1, 0, 0, 0, 980, 983,
|
|
1, 0, 0, 0, 981, 979, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 29, 1, 0,
|
|
0, 0, 983, 981, 1, 0, 0, 0, 984, 985, 5, 33, 0, 0, 985, 986, 5, 475, 0,
|
|
0, 986, 987, 5, 73, 0, 0, 987, 988, 3, 584, 292, 0, 988, 989, 5, 5, 0,
|
|
0, 989, 990, 5, 659, 0, 0, 990, 996, 5, 1148, 0, 0, 991, 993, 5, 453, 0,
|
|
0, 992, 994, 5, 1124, 0, 0, 993, 992, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0,
|
|
994, 995, 1, 0, 0, 0, 995, 997, 3, 592, 296, 0, 996, 991, 1, 0, 0, 0, 996,
|
|
997, 1, 0, 0, 0, 997, 1003, 1, 0, 0, 0, 998, 1000, 5, 660, 0, 0, 999, 1001,
|
|
5, 1124, 0, 0, 1000, 999, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002,
|
|
1, 0, 0, 0, 1002, 1004, 3, 592, 296, 0, 1003, 998, 1, 0, 0, 0, 1003, 1004,
|
|
1, 0, 0, 0, 1004, 1010, 1, 0, 0, 0, 1005, 1007, 5, 572, 0, 0, 1006, 1008,
|
|
5, 1124, 0, 0, 1007, 1006, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009,
|
|
1, 0, 0, 0, 1009, 1011, 3, 592, 296, 0, 1010, 1005, 1, 0, 0, 0, 1010, 1011,
|
|
1, 0, 0, 0, 1011, 1017, 1, 0, 0, 0, 1012, 1014, 5, 528, 0, 0, 1013, 1015,
|
|
5, 1124, 0, 0, 1014, 1013, 1, 0, 0, 0, 1014, 1015, 1, 0, 0, 0, 1015, 1016,
|
|
1, 0, 0, 0, 1016, 1018, 3, 584, 292, 0, 1017, 1012, 1, 0, 0, 0, 1017, 1018,
|
|
1, 0, 0, 0, 1018, 1020, 1, 0, 0, 0, 1019, 1021, 5, 674, 0, 0, 1020, 1019,
|
|
1, 0, 0, 0, 1020, 1021, 1, 0, 0, 0, 1021, 1027, 1, 0, 0, 0, 1022, 1024,
|
|
5, 368, 0, 0, 1023, 1025, 5, 1124, 0, 0, 1024, 1023, 1, 0, 0, 0, 1024,
|
|
1025, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 1028, 5, 1148, 0, 0, 1027,
|
|
1022, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029,
|
|
1031, 5, 409, 0, 0, 1030, 1032, 5, 1124, 0, 0, 1031, 1030, 1, 0, 0, 0,
|
|
1031, 1032, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1034, 3, 572, 286,
|
|
0, 1034, 31, 1, 0, 0, 0, 1035, 1037, 5, 33, 0, 0, 1036, 1038, 3, 64, 32,
|
|
0, 1037, 1036, 1, 0, 0, 0, 1037, 1038, 1, 0, 0, 0, 1038, 1039, 1, 0, 0,
|
|
0, 1039, 1040, 5, 131, 0, 0, 1040, 1041, 3, 550, 275, 0, 1041, 1043, 5,
|
|
1133, 0, 0, 1042, 1044, 3, 80, 40, 0, 1043, 1042, 1, 0, 0, 0, 1043, 1044,
|
|
1, 0, 0, 0, 1044, 1049, 1, 0, 0, 0, 1045, 1046, 5, 1135, 0, 0, 1046, 1048,
|
|
3, 80, 40, 0, 1047, 1045, 1, 0, 0, 0, 1048, 1051, 1, 0, 0, 0, 1049, 1047,
|
|
1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 1052, 1, 0, 0, 0, 1051, 1049,
|
|
1, 0, 0, 0, 1052, 1056, 5, 1134, 0, 0, 1053, 1055, 3, 84, 42, 0, 1054,
|
|
1053, 1, 0, 0, 0, 1055, 1058, 1, 0, 0, 0, 1056, 1054, 1, 0, 0, 0, 1056,
|
|
1057, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1059,
|
|
1060, 3, 388, 194, 0, 1060, 33, 1, 0, 0, 0, 1061, 1063, 5, 33, 0, 0, 1062,
|
|
1064, 3, 64, 32, 0, 1063, 1062, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, 1064,
|
|
1066, 1, 0, 0, 0, 1065, 1067, 5, 335, 0, 0, 1066, 1065, 1, 0, 0, 0, 1066,
|
|
1067, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 5, 437, 0, 0, 1069,
|
|
1071, 3, 642, 321, 0, 1070, 1069, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071,
|
|
1072, 1, 0, 0, 0, 1072, 1073, 3, 550, 275, 0, 1073, 1075, 5, 1133, 0, 0,
|
|
1074, 1076, 3, 82, 41, 0, 1075, 1074, 1, 0, 0, 0, 1075, 1076, 1, 0, 0,
|
|
0, 1076, 1081, 1, 0, 0, 0, 1077, 1078, 5, 1135, 0, 0, 1078, 1080, 3, 82,
|
|
41, 0, 1079, 1077, 1, 0, 0, 0, 1080, 1083, 1, 0, 0, 0, 1081, 1079, 1, 0,
|
|
0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0,
|
|
0, 0, 1084, 1085, 5, 1134, 0, 0, 1085, 1086, 5, 594, 0, 0, 1086, 1090,
|
|
3, 604, 302, 0, 1087, 1089, 3, 84, 42, 0, 1088, 1087, 1, 0, 0, 0, 1089,
|
|
1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091,
|
|
1095, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1096, 3, 388, 194, 0, 1094,
|
|
1096, 3, 404, 202, 0, 1095, 1093, 1, 0, 0, 0, 1095, 1094, 1, 0, 0, 0, 1096,
|
|
35, 1, 0, 0, 0, 1097, 1098, 5, 33, 0, 0, 1098, 1100, 5, 596, 0, 0, 1099,
|
|
1101, 3, 642, 321, 0, 1100, 1099, 1, 0, 0, 0, 1100, 1101, 1, 0, 0, 0, 1101,
|
|
1102, 1, 0, 0, 0, 1102, 1107, 3, 554, 277, 0, 1103, 1104, 5, 1135, 0, 0,
|
|
1104, 1106, 3, 554, 277, 0, 1105, 1103, 1, 0, 0, 0, 1106, 1109, 1, 0, 0,
|
|
0, 1107, 1105, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 37, 1, 0, 0, 0,
|
|
1109, 1107, 1, 0, 0, 0, 1110, 1111, 5, 33, 0, 0, 1111, 1112, 5, 608, 0,
|
|
0, 1112, 1113, 3, 584, 292, 0, 1113, 1114, 5, 67, 0, 0, 1114, 1115, 5,
|
|
388, 0, 0, 1115, 1116, 5, 679, 0, 0, 1116, 1117, 7, 5, 0, 0, 1117, 1118,
|
|
5, 541, 0, 0, 1118, 1119, 5, 1133, 0, 0, 1119, 1124, 3, 86, 43, 0, 1120,
|
|
1121, 5, 1135, 0, 0, 1121, 1123, 3, 86, 43, 0, 1122, 1120, 1, 0, 0, 0,
|
|
1123, 1126, 1, 0, 0, 0, 1124, 1122, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0,
|
|
1125, 1127, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1127, 1128, 5, 1134, 0,
|
|
0, 1128, 39, 1, 0, 0, 0, 1129, 1131, 5, 33, 0, 0, 1130, 1132, 5, 649, 0,
|
|
0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 1, 0, 0,
|
|
0, 1133, 1135, 5, 172, 0, 0, 1134, 1136, 3, 642, 321, 0, 1135, 1134, 1,
|
|
0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1145, 3,
|
|
552, 276, 0, 1138, 1139, 5, 98, 0, 0, 1139, 1146, 3, 552, 276, 0, 1140,
|
|
1141, 5, 1133, 0, 0, 1141, 1142, 5, 98, 0, 0, 1142, 1143, 3, 552, 276,
|
|
0, 1143, 1144, 5, 1134, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1138, 1, 0,
|
|
0, 0, 1145, 1140, 1, 0, 0, 0, 1146, 1208, 1, 0, 0, 0, 1147, 1149, 5, 33,
|
|
0, 0, 1148, 1150, 5, 649, 0, 0, 1149, 1148, 1, 0, 0, 0, 1149, 1150, 1,
|
|
0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1153, 5, 172, 0, 0, 1152, 1154,
|
|
3, 642, 321, 0, 1153, 1152, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1155,
|
|
1, 0, 0, 0, 1155, 1157, 3, 552, 276, 0, 1156, 1158, 3, 88, 44, 0, 1157,
|
|
1156, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1169, 1, 0, 0, 0, 1159,
|
|
1166, 3, 106, 53, 0, 1160, 1162, 5, 1135, 0, 0, 1161, 1160, 1, 0, 0, 0,
|
|
1161, 1162, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1165, 3, 106, 53,
|
|
0, 1164, 1161, 1, 0, 0, 0, 1165, 1168, 1, 0, 0, 0, 1166, 1164, 1, 0, 0,
|
|
0, 1166, 1167, 1, 0, 0, 0, 1167, 1170, 1, 0, 0, 0, 1168, 1166, 1, 0, 0,
|
|
0, 1169, 1159, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1172, 1, 0, 0,
|
|
0, 1171, 1173, 3, 112, 56, 0, 1172, 1171, 1, 0, 0, 0, 1172, 1173, 1, 0,
|
|
0, 0, 1173, 1175, 1, 0, 0, 0, 1174, 1176, 7, 6, 0, 0, 1175, 1174, 1, 0,
|
|
0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1178, 1, 0, 0, 0, 1177, 1179, 5, 12,
|
|
0, 0, 1178, 1177, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1180, 1, 0,
|
|
0, 0, 1180, 1181, 3, 200, 100, 0, 1181, 1208, 1, 0, 0, 0, 1182, 1184, 5,
|
|
33, 0, 0, 1183, 1185, 5, 649, 0, 0, 1184, 1183, 1, 0, 0, 0, 1184, 1185,
|
|
1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 5, 172, 0, 0, 1187, 1189,
|
|
3, 642, 321, 0, 1188, 1187, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1190,
|
|
1, 0, 0, 0, 1190, 1191, 3, 552, 276, 0, 1191, 1202, 3, 88, 44, 0, 1192,
|
|
1199, 3, 106, 53, 0, 1193, 1195, 5, 1135, 0, 0, 1194, 1193, 1, 0, 0, 0,
|
|
1194, 1195, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 3, 106, 53,
|
|
0, 1197, 1194, 1, 0, 0, 0, 1198, 1201, 1, 0, 0, 0, 1199, 1197, 1, 0, 0,
|
|
0, 1199, 1200, 1, 0, 0, 0, 1200, 1203, 1, 0, 0, 0, 1201, 1199, 1, 0, 0,
|
|
0, 1202, 1192, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1205, 1, 0, 0,
|
|
0, 1204, 1206, 3, 112, 56, 0, 1205, 1204, 1, 0, 0, 0, 1205, 1206, 1, 0,
|
|
0, 0, 1206, 1208, 1, 0, 0, 0, 1207, 1129, 1, 0, 0, 0, 1207, 1147, 1, 0,
|
|
0, 0, 1207, 1182, 1, 0, 0, 0, 1208, 41, 1, 0, 0, 0, 1209, 1210, 5, 33,
|
|
0, 0, 1210, 1211, 5, 647, 0, 0, 1211, 1212, 3, 584, 292, 0, 1212, 1213,
|
|
5, 5, 0, 0, 1213, 1214, 5, 389, 0, 0, 1214, 1218, 5, 1148, 0, 0, 1215,
|
|
1216, 5, 428, 0, 0, 1216, 1217, 5, 1124, 0, 0, 1217, 1219, 3, 592, 296,
|
|
0, 1218, 1215, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1225, 1, 0, 0,
|
|
0, 1220, 1222, 5, 409, 0, 0, 1221, 1223, 5, 1124, 0, 0, 1222, 1221, 1,
|
|
0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1226, 3,
|
|
572, 286, 0, 1225, 1220, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 43,
|
|
1, 0, 0, 0, 1227, 1228, 5, 33, 0, 0, 1228, 1229, 5, 647, 0, 0, 1229, 1230,
|
|
3, 584, 292, 0, 1230, 1231, 5, 5, 0, 0, 1231, 1232, 5, 389, 0, 0, 1232,
|
|
1233, 5, 1148, 0, 0, 1233, 1234, 5, 186, 0, 0, 1234, 1235, 5, 475, 0, 0,
|
|
1235, 1236, 5, 73, 0, 0, 1236, 1242, 3, 584, 292, 0, 1237, 1239, 5, 423,
|
|
0, 0, 1238, 1240, 5, 1124, 0, 0, 1239, 1238, 1, 0, 0, 0, 1239, 1240, 1,
|
|
0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1243, 3, 592, 296, 0, 1242, 1237,
|
|
1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 1249, 1, 0, 0, 0, 1244, 1246,
|
|
5, 453, 0, 0, 1245, 1247, 5, 1124, 0, 0, 1246, 1245, 1, 0, 0, 0, 1246,
|
|
1247, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1250, 3, 592, 296, 0, 1249,
|
|
1244, 1, 0, 0, 0, 1249, 1250, 1, 0, 0, 0, 1250, 1256, 1, 0, 0, 0, 1251,
|
|
1253, 5, 341, 0, 0, 1252, 1254, 5, 1124, 0, 0, 1253, 1252, 1, 0, 0, 0,
|
|
1253, 1254, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 1257, 3, 592, 296,
|
|
0, 1256, 1251, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1263, 1, 0, 0,
|
|
0, 1258, 1260, 5, 501, 0, 0, 1259, 1261, 5, 1124, 0, 0, 1260, 1259, 1,
|
|
0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, 1264, 3,
|
|
592, 296, 0, 1263, 1258, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1270,
|
|
1, 0, 0, 0, 1265, 1267, 5, 528, 0, 0, 1266, 1268, 5, 1124, 0, 0, 1267,
|
|
1266, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269,
|
|
1271, 3, 584, 292, 0, 1270, 1265, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271,
|
|
1273, 1, 0, 0, 0, 1272, 1274, 5, 674, 0, 0, 1273, 1272, 1, 0, 0, 0, 1273,
|
|
1274, 1, 0, 0, 0, 1274, 1280, 1, 0, 0, 0, 1275, 1277, 5, 368, 0, 0, 1276,
|
|
1278, 5, 1124, 0, 0, 1277, 1276, 1, 0, 0, 0, 1277, 1278, 1, 0, 0, 0, 1278,
|
|
1279, 1, 0, 0, 0, 1279, 1281, 5, 1148, 0, 0, 1280, 1275, 1, 0, 0, 0, 1280,
|
|
1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1284, 5, 409, 0, 0, 1283,
|
|
1285, 5, 1124, 0, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285,
|
|
1286, 1, 0, 0, 0, 1286, 1287, 3, 572, 286, 0, 1287, 45, 1, 0, 0, 0, 1288,
|
|
1290, 5, 33, 0, 0, 1289, 1291, 3, 64, 32, 0, 1290, 1289, 1, 0, 0, 0, 1290,
|
|
1291, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1294, 5, 177, 0, 0, 1293,
|
|
1295, 3, 642, 321, 0, 1294, 1293, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295,
|
|
1296, 1, 0, 0, 0, 1296, 1297, 3, 550, 275, 0, 1297, 1298, 7, 7, 0, 0, 1298,
|
|
1299, 7, 8, 0, 0, 1299, 1300, 5, 118, 0, 0, 1300, 1301, 3, 552, 276, 0,
|
|
1301, 1302, 5, 65, 0, 0, 1302, 1303, 5, 52, 0, 0, 1303, 1306, 5, 600, 0,
|
|
0, 1304, 1305, 7, 9, 0, 0, 1305, 1307, 3, 550, 275, 0, 1306, 1304, 1, 0,
|
|
0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1309, 3, 388,
|
|
194, 0, 1309, 47, 1, 0, 0, 0, 1310, 1312, 5, 192, 0, 0, 1311, 1313, 5,
|
|
571, 0, 0, 1312, 1311, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314,
|
|
1, 0, 0, 0, 1314, 1315, 3, 50, 25, 0, 1315, 49, 1, 0, 0, 0, 1316, 1328,
|
|
3, 52, 26, 0, 1317, 1318, 5, 1133, 0, 0, 1318, 1323, 3, 54, 27, 0, 1319,
|
|
1320, 5, 1135, 0, 0, 1320, 1322, 3, 54, 27, 0, 1321, 1319, 1, 0, 0, 0,
|
|
1322, 1325, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0,
|
|
1324, 1326, 1, 0, 0, 0, 1325, 1323, 1, 0, 0, 0, 1326, 1327, 5, 1134, 0,
|
|
0, 1327, 1329, 1, 0, 0, 0, 1328, 1317, 1, 0, 0, 0, 1328, 1329, 1, 0, 0,
|
|
0, 1329, 1330, 1, 0, 0, 0, 1330, 1331, 5, 12, 0, 0, 1331, 1332, 5, 1133,
|
|
0, 0, 1332, 1333, 3, 10, 5, 0, 1333, 1336, 5, 1134, 0, 0, 1334, 1335, 5,
|
|
1135, 0, 0, 1335, 1337, 3, 50, 25, 0, 1336, 1334, 1, 0, 0, 0, 1336, 1337,
|
|
1, 0, 0, 0, 1337, 51, 1, 0, 0, 0, 1338, 1339, 3, 584, 292, 0, 1339, 53,
|
|
1, 0, 0, 0, 1340, 1341, 3, 584, 292, 0, 1341, 55, 1, 0, 0, 0, 1342, 1344,
|
|
5, 33, 0, 0, 1343, 1345, 3, 644, 322, 0, 1344, 1343, 1, 0, 0, 0, 1344,
|
|
1345, 1, 0, 0, 0, 1345, 1349, 1, 0, 0, 0, 1346, 1347, 5, 336, 0, 0, 1347,
|
|
1348, 5, 1124, 0, 0, 1348, 1350, 7, 10, 0, 0, 1349, 1346, 1, 0, 0, 0, 1349,
|
|
1350, 1, 0, 0, 0, 1350, 1352, 1, 0, 0, 0, 1351, 1353, 3, 64, 32, 0, 1352,
|
|
1351, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 1357, 1, 0, 0, 0, 1354,
|
|
1355, 5, 160, 0, 0, 1355, 1356, 5, 606, 0, 0, 1356, 1358, 7, 11, 0, 0,
|
|
1357, 1354, 1, 0, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0,
|
|
1359, 1360, 5, 671, 0, 0, 1360, 1365, 3, 550, 275, 0, 1361, 1362, 5, 1133,
|
|
0, 0, 1362, 1363, 3, 616, 308, 0, 1363, 1364, 5, 1134, 0, 0, 1364, 1366,
|
|
1, 0, 0, 0, 1365, 1361, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1367,
|
|
1, 0, 0, 0, 1367, 1387, 5, 12, 0, 0, 1368, 1370, 5, 1133, 0, 0, 1369, 1371,
|
|
3, 48, 24, 0, 1370, 1369, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1372,
|
|
1, 0, 0, 0, 1372, 1373, 3, 200, 100, 0, 1373, 1374, 5, 1134, 0, 0, 1374,
|
|
1388, 1, 0, 0, 0, 1375, 1377, 3, 48, 24, 0, 1376, 1375, 1, 0, 0, 0, 1376,
|
|
1377, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1385, 3, 200, 100, 0, 1379,
|
|
1381, 5, 192, 0, 0, 1380, 1382, 7, 12, 0, 0, 1381, 1380, 1, 0, 0, 0, 1381,
|
|
1382, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, 1384, 5, 26, 0, 0, 1384,
|
|
1386, 5, 120, 0, 0, 1385, 1379, 1, 0, 0, 0, 1385, 1386, 1, 0, 0, 0, 1386,
|
|
1388, 1, 0, 0, 0, 1387, 1368, 1, 0, 0, 0, 1387, 1376, 1, 0, 0, 0, 1388,
|
|
57, 1, 0, 0, 0, 1389, 1391, 5, 42, 0, 0, 1390, 1389, 1, 0, 0, 0, 1390,
|
|
1391, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 1394, 3, 60, 30, 0, 1393,
|
|
1395, 5, 1124, 0, 0, 1394, 1393, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395,
|
|
1398, 1, 0, 0, 0, 1396, 1399, 3, 568, 284, 0, 1397, 1399, 5, 42, 0, 0,
|
|
1398, 1396, 1, 0, 0, 0, 1398, 1397, 1, 0, 0, 0, 1399, 1423, 1, 0, 0, 0,
|
|
1400, 1402, 5, 42, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0,
|
|
1402, 1403, 1, 0, 0, 0, 1403, 1405, 5, 27, 0, 0, 1404, 1406, 5, 1124, 0,
|
|
0, 1405, 1404, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 1, 0, 0,
|
|
0, 1407, 1423, 3, 570, 285, 0, 1408, 1410, 5, 42, 0, 0, 1409, 1408, 1,
|
|
0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1411, 1, 0, 0, 0, 1411, 1413, 5,
|
|
405, 0, 0, 1412, 1414, 5, 1124, 0, 0, 1413, 1412, 1, 0, 0, 0, 1413, 1414,
|
|
1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1423, 5, 1148, 0, 0, 1416, 1417,
|
|
5, 134, 0, 0, 1417, 1419, 5, 538, 0, 0, 1418, 1420, 5, 1124, 0, 0, 1419,
|
|
1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421,
|
|
1423, 7, 13, 0, 0, 1422, 1390, 1, 0, 0, 0, 1422, 1401, 1, 0, 0, 0, 1422,
|
|
1409, 1, 0, 0, 0, 1422, 1416, 1, 0, 0, 0, 1423, 59, 1, 0, 0, 0, 1424, 1425,
|
|
5, 25, 0, 0, 1425, 1430, 5, 153, 0, 0, 1426, 1430, 5, 841, 0, 0, 1427,
|
|
1428, 5, 222, 0, 0, 1428, 1430, 5, 153, 0, 0, 1429, 1424, 1, 0, 0, 0, 1429,
|
|
1426, 1, 0, 0, 0, 1429, 1427, 1, 0, 0, 0, 1430, 61, 1, 0, 0, 0, 1431, 1434,
|
|
5, 37, 0, 0, 1432, 1433, 5, 1133, 0, 0, 1433, 1435, 5, 1134, 0, 0, 1434,
|
|
1432, 1, 0, 0, 0, 1434, 1435, 1, 0, 0, 0, 1435, 63, 1, 0, 0, 0, 1436, 1437,
|
|
5, 392, 0, 0, 1437, 1440, 5, 1124, 0, 0, 1438, 1441, 3, 564, 282, 0, 1439,
|
|
1441, 3, 62, 31, 0, 1440, 1438, 1, 0, 0, 0, 1440, 1439, 1, 0, 0, 0, 1441,
|
|
65, 1, 0, 0, 0, 1442, 1443, 5, 338, 0, 0, 1443, 1447, 3, 68, 34, 0, 1444,
|
|
1446, 3, 70, 35, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447,
|
|
1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1477, 1, 0, 0, 0, 1449,
|
|
1447, 1, 0, 0, 0, 1450, 1453, 5, 417, 0, 0, 1451, 1454, 3, 590, 295, 0,
|
|
1452, 1454, 3, 688, 344, 0, 1453, 1451, 1, 0, 0, 0, 1453, 1452, 1, 0, 0,
|
|
0, 1454, 1455, 1, 0, 0, 0, 1455, 1464, 3, 72, 36, 0, 1456, 1457, 5, 630,
|
|
0, 0, 1457, 1461, 3, 68, 34, 0, 1458, 1460, 3, 70, 35, 0, 1459, 1458, 1,
|
|
0, 0, 0, 1460, 1463, 1, 0, 0, 0, 1461, 1459, 1, 0, 0, 0, 1461, 1462, 1,
|
|
0, 0, 0, 1462, 1465, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1464, 1456, 1,
|
|
0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1474, 1, 0, 0, 0, 1466, 1467, 5,
|
|
408, 0, 0, 1467, 1471, 3, 68, 34, 0, 1468, 1470, 3, 70, 35, 0, 1469, 1468,
|
|
1, 0, 0, 0, 1470, 1473, 1, 0, 0, 0, 1471, 1469, 1, 0, 0, 0, 1471, 1472,
|
|
1, 0, 0, 0, 1472, 1475, 1, 0, 0, 0, 1473, 1471, 1, 0, 0, 0, 1474, 1466,
|
|
1, 0, 0, 0, 1474, 1475, 1, 0, 0, 0, 1475, 1477, 1, 0, 0, 0, 1476, 1442,
|
|
1, 0, 0, 0, 1476, 1450, 1, 0, 0, 0, 1477, 67, 1, 0, 0, 0, 1478, 1483, 5,
|
|
315, 0, 0, 1479, 1483, 3, 594, 297, 0, 1480, 1483, 3, 590, 295, 0, 1481,
|
|
1483, 3, 688, 344, 0, 1482, 1478, 1, 0, 0, 0, 1482, 1479, 1, 0, 0, 0, 1482,
|
|
1480, 1, 0, 0, 0, 1482, 1481, 1, 0, 0, 0, 1483, 69, 1, 0, 0, 0, 1484, 1485,
|
|
5, 1120, 0, 0, 1485, 1488, 5, 86, 0, 0, 1486, 1489, 3, 590, 295, 0, 1487,
|
|
1489, 3, 688, 344, 0, 1488, 1486, 1, 0, 0, 0, 1488, 1487, 1, 0, 0, 0, 1489,
|
|
1490, 1, 0, 0, 0, 1490, 1491, 3, 72, 36, 0, 1491, 71, 1, 0, 0, 0, 1492,
|
|
1506, 3, 714, 357, 0, 1493, 1506, 5, 221, 0, 0, 1494, 1506, 5, 240, 0,
|
|
0, 1495, 1506, 5, 241, 0, 0, 1496, 1506, 5, 242, 0, 0, 1497, 1506, 5, 243,
|
|
0, 0, 1498, 1506, 5, 244, 0, 0, 1499, 1506, 5, 245, 0, 0, 1500, 1506, 5,
|
|
246, 0, 0, 1501, 1506, 5, 247, 0, 0, 1502, 1506, 5, 248, 0, 0, 1503, 1506,
|
|
5, 249, 0, 0, 1504, 1506, 5, 250, 0, 0, 1505, 1492, 1, 0, 0, 0, 1505, 1493,
|
|
1, 0, 0, 0, 1505, 1494, 1, 0, 0, 0, 1505, 1495, 1, 0, 0, 0, 1505, 1496,
|
|
1, 0, 0, 0, 1505, 1497, 1, 0, 0, 0, 1505, 1498, 1, 0, 0, 0, 1505, 1499,
|
|
1, 0, 0, 0, 1505, 1500, 1, 0, 0, 0, 1505, 1501, 1, 0, 0, 0, 1505, 1502,
|
|
1, 0, 0, 0, 1505, 1503, 1, 0, 0, 0, 1505, 1504, 1, 0, 0, 0, 1506, 73, 1,
|
|
0, 0, 0, 1507, 1513, 5, 403, 0, 0, 1508, 1513, 5, 396, 0, 0, 1509, 1510,
|
|
5, 396, 0, 0, 1510, 1511, 5, 118, 0, 0, 1511, 1513, 5, 614, 0, 0, 1512,
|
|
1507, 1, 0, 0, 0, 1512, 1508, 1, 0, 0, 0, 1512, 1509, 1, 0, 0, 0, 1513,
|
|
75, 1, 0, 0, 0, 1514, 1515, 5, 187, 0, 0, 1515, 1516, 7, 14, 0, 0, 1516,
|
|
77, 1, 0, 0, 0, 1517, 1519, 5, 467, 0, 0, 1518, 1520, 5, 1124, 0, 0, 1519,
|
|
1518, 1, 0, 0, 0, 1519, 1520, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, 0, 1521,
|
|
1540, 3, 592, 296, 0, 1522, 1540, 3, 76, 38, 0, 1523, 1524, 5, 192, 0,
|
|
0, 1524, 1525, 5, 547, 0, 0, 1525, 1540, 3, 584, 292, 0, 1526, 1527, 5,
|
|
368, 0, 0, 1527, 1540, 5, 1148, 0, 0, 1528, 1540, 7, 15, 0, 0, 1529, 1531,
|
|
5, 875, 0, 0, 1530, 1532, 5, 1124, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531,
|
|
1532, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1540, 5, 1148, 0, 0, 1534,
|
|
1536, 5, 1000, 0, 0, 1535, 1537, 5, 1124, 0, 0, 1536, 1535, 1, 0, 0, 0,
|
|
1536, 1537, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1540, 5, 1148, 0,
|
|
0, 1539, 1517, 1, 0, 0, 0, 1539, 1522, 1, 0, 0, 0, 1539, 1523, 1, 0, 0,
|
|
0, 1539, 1526, 1, 0, 0, 0, 1539, 1528, 1, 0, 0, 0, 1539, 1529, 1, 0, 0,
|
|
0, 1539, 1534, 1, 0, 0, 0, 1540, 79, 1, 0, 0, 0, 1541, 1543, 7, 16, 0,
|
|
0, 1542, 1541, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1544, 1, 0, 0,
|
|
0, 1544, 1545, 3, 584, 292, 0, 1545, 1546, 3, 604, 302, 0, 1546, 81, 1,
|
|
0, 0, 0, 1547, 1548, 3, 584, 292, 0, 1548, 1549, 3, 604, 302, 0, 1549,
|
|
83, 1, 0, 0, 0, 1550, 1551, 5, 368, 0, 0, 1551, 1574, 5, 1148, 0, 0, 1552,
|
|
1553, 5, 468, 0, 0, 1553, 1574, 5, 160, 0, 0, 1554, 1556, 5, 114, 0, 0,
|
|
1555, 1554, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0,
|
|
1557, 1574, 5, 47, 0, 0, 1558, 1559, 5, 381, 0, 0, 1559, 1569, 5, 160,
|
|
0, 0, 1560, 1561, 5, 521, 0, 0, 1561, 1569, 5, 160, 0, 0, 1562, 1563, 5,
|
|
135, 0, 0, 1563, 1564, 5, 160, 0, 0, 1564, 1569, 5, 388, 0, 0, 1565, 1566,
|
|
5, 112, 0, 0, 1566, 1567, 5, 160, 0, 0, 1567, 1569, 5, 388, 0, 0, 1568,
|
|
1558, 1, 0, 0, 0, 1568, 1560, 1, 0, 0, 0, 1568, 1562, 1, 0, 0, 0, 1568,
|
|
1565, 1, 0, 0, 0, 1569, 1574, 1, 0, 0, 0, 1570, 1571, 5, 160, 0, 0, 1571,
|
|
1572, 5, 606, 0, 0, 1572, 1574, 7, 11, 0, 0, 1573, 1550, 1, 0, 0, 0, 1573,
|
|
1552, 1, 0, 0, 0, 1573, 1555, 1, 0, 0, 0, 1573, 1568, 1, 0, 0, 0, 1573,
|
|
1570, 1, 0, 0, 0, 1574, 85, 1, 0, 0, 0, 1575, 1576, 5, 446, 0, 0, 1576,
|
|
1590, 5, 1148, 0, 0, 1577, 1578, 5, 39, 0, 0, 1578, 1590, 5, 1148, 0, 0,
|
|
1579, 1580, 5, 665, 0, 0, 1580, 1590, 5, 1148, 0, 0, 1581, 1582, 5, 551,
|
|
0, 0, 1582, 1590, 5, 1148, 0, 0, 1583, 1584, 5, 617, 0, 0, 1584, 1590,
|
|
5, 1148, 0, 0, 1585, 1586, 5, 542, 0, 0, 1586, 1590, 5, 1148, 0, 0, 1587,
|
|
1588, 5, 557, 0, 0, 1588, 1590, 3, 590, 295, 0, 1589, 1575, 1, 0, 0, 0,
|
|
1589, 1577, 1, 0, 0, 0, 1589, 1579, 1, 0, 0, 0, 1589, 1581, 1, 0, 0, 0,
|
|
1589, 1583, 1, 0, 0, 0, 1589, 1585, 1, 0, 0, 0, 1589, 1587, 1, 0, 0, 0,
|
|
1590, 87, 1, 0, 0, 0, 1591, 1592, 5, 1133, 0, 0, 1592, 1597, 3, 90, 45,
|
|
0, 1593, 1594, 5, 1135, 0, 0, 1594, 1596, 3, 90, 45, 0, 1595, 1593, 1,
|
|
0, 0, 0, 1596, 1599, 1, 0, 0, 0, 1597, 1595, 1, 0, 0, 0, 1597, 1598, 1,
|
|
0, 0, 0, 1598, 1600, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1600, 1601, 5,
|
|
1134, 0, 0, 1601, 89, 1, 0, 0, 0, 1602, 1603, 3, 556, 278, 0, 1603, 1604,
|
|
3, 92, 46, 0, 1604, 1614, 1, 0, 0, 0, 1605, 1607, 3, 96, 48, 0, 1606, 1608,
|
|
5, 114, 0, 0, 1607, 1606, 1, 0, 0, 0, 1607, 1608, 1, 0, 0, 0, 1608, 1610,
|
|
1, 0, 0, 0, 1609, 1611, 5, 57, 0, 0, 1610, 1609, 1, 0, 0, 0, 1610, 1611,
|
|
1, 0, 0, 0, 1611, 1614, 1, 0, 0, 0, 1612, 1614, 3, 104, 52, 0, 1613, 1602,
|
|
1, 0, 0, 0, 1613, 1605, 1, 0, 0, 0, 1613, 1612, 1, 0, 0, 0, 1614, 91, 1,
|
|
0, 0, 0, 1615, 1619, 3, 604, 302, 0, 1616, 1618, 3, 94, 47, 0, 1617, 1616,
|
|
1, 0, 0, 0, 1618, 1621, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1619, 1620,
|
|
1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1622, 1624,
|
|
5, 114, 0, 0, 1623, 1622, 1, 0, 0, 0, 1623, 1624, 1, 0, 0, 0, 1624, 1626,
|
|
1, 0, 0, 0, 1625, 1627, 5, 57, 0, 0, 1626, 1625, 1, 0, 0, 0, 1626, 1627,
|
|
1, 0, 0, 0, 1627, 93, 1, 0, 0, 0, 1628, 1682, 3, 600, 300, 0, 1629, 1630,
|
|
5, 42, 0, 0, 1630, 1682, 3, 634, 317, 0, 1631, 1682, 5, 673, 0, 0, 1632,
|
|
1682, 5, 459, 0, 0, 1633, 1638, 5, 342, 0, 0, 1634, 1635, 5, 118, 0, 0,
|
|
1635, 1636, 5, 184, 0, 0, 1636, 1638, 3, 636, 318, 0, 1637, 1633, 1, 0,
|
|
0, 0, 1637, 1634, 1, 0, 0, 0, 1638, 1682, 1, 0, 0, 0, 1639, 1641, 5, 130,
|
|
0, 0, 1640, 1639, 1, 0, 0, 0, 1640, 1641, 1, 0, 0, 0, 1641, 1642, 1, 0,
|
|
0, 0, 1642, 1682, 5, 91, 0, 0, 1643, 1645, 5, 181, 0, 0, 1644, 1646, 5,
|
|
91, 0, 0, 1645, 1644, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 1682, 1,
|
|
0, 0, 0, 1647, 1648, 5, 368, 0, 0, 1648, 1682, 5, 1148, 0, 0, 1649, 1650,
|
|
5, 366, 0, 0, 1650, 1682, 7, 17, 0, 0, 1651, 1652, 5, 636, 0, 0, 1652,
|
|
1682, 7, 18, 0, 0, 1653, 1682, 3, 98, 49, 0, 1654, 1655, 5, 27, 0, 0, 1655,
|
|
1682, 3, 570, 285, 0, 1656, 1657, 5, 70, 0, 0, 1657, 1659, 5, 8, 0, 0,
|
|
1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0,
|
|
1660, 1661, 5, 12, 0, 0, 1661, 1662, 5, 1133, 0, 0, 1662, 1663, 3, 688,
|
|
344, 0, 1663, 1665, 5, 1134, 0, 0, 1664, 1666, 7, 19, 0, 0, 1665, 1664,
|
|
1, 0, 0, 0, 1665, 1666, 1, 0, 0, 0, 1666, 1682, 1, 0, 0, 0, 1667, 1668,
|
|
5, 239, 0, 0, 1668, 1669, 5, 42, 0, 0, 1669, 1682, 5, 669, 0, 0, 1670,
|
|
1672, 5, 30, 0, 0, 1671, 1673, 3, 584, 292, 0, 1672, 1671, 1, 0, 0, 0,
|
|
1672, 1673, 1, 0, 0, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0,
|
|
1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 5, 26, 0, 0,
|
|
1677, 1678, 5, 1133, 0, 0, 1678, 1679, 3, 688, 344, 0, 1679, 1680, 5, 1134,
|
|
0, 0, 1680, 1682, 1, 0, 0, 0, 1681, 1628, 1, 0, 0, 0, 1681, 1629, 1, 0,
|
|
0, 0, 1681, 1631, 1, 0, 0, 0, 1681, 1632, 1, 0, 0, 0, 1681, 1637, 1, 0,
|
|
0, 0, 1681, 1640, 1, 0, 0, 0, 1681, 1643, 1, 0, 0, 0, 1681, 1647, 1, 0,
|
|
0, 0, 1681, 1649, 1, 0, 0, 0, 1681, 1651, 1, 0, 0, 0, 1681, 1653, 1, 0,
|
|
0, 0, 1681, 1654, 1, 0, 0, 0, 1681, 1658, 1, 0, 0, 0, 1681, 1667, 1, 0,
|
|
0, 0, 1681, 1674, 1, 0, 0, 0, 1682, 95, 1, 0, 0, 0, 1683, 1685, 5, 30,
|
|
0, 0, 1684, 1686, 3, 584, 292, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1,
|
|
0, 0, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1683, 1, 0, 0, 0, 1687, 1688, 1,
|
|
0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1690, 5, 130, 0, 0, 1690, 1692,
|
|
5, 91, 0, 0, 1691, 1693, 3, 584, 292, 0, 1692, 1691, 1, 0, 0, 0, 1692,
|
|
1693, 1, 0, 0, 0, 1693, 1695, 1, 0, 0, 0, 1694, 1696, 3, 76, 38, 0, 1695,
|
|
1694, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697,
|
|
1701, 3, 622, 311, 0, 1698, 1700, 3, 78, 39, 0, 1699, 1698, 1, 0, 0, 0,
|
|
1700, 1703, 1, 0, 0, 0, 1701, 1699, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0,
|
|
1702, 1753, 1, 0, 0, 0, 1703, 1701, 1, 0, 0, 0, 1704, 1706, 5, 30, 0, 0,
|
|
1705, 1707, 3, 584, 292, 0, 1706, 1705, 1, 0, 0, 0, 1706, 1707, 1, 0, 0,
|
|
0, 1707, 1709, 1, 0, 0, 0, 1708, 1704, 1, 0, 0, 0, 1708, 1709, 1, 0, 0,
|
|
0, 1709, 1710, 1, 0, 0, 0, 1710, 1712, 5, 181, 0, 0, 1711, 1713, 7, 20,
|
|
0, 0, 1712, 1711, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1715, 1, 0,
|
|
0, 0, 1714, 1716, 3, 584, 292, 0, 1715, 1714, 1, 0, 0, 0, 1715, 1716, 1,
|
|
0, 0, 0, 1716, 1718, 1, 0, 0, 0, 1717, 1719, 3, 76, 38, 0, 1718, 1717,
|
|
1, 0, 0, 0, 1718, 1719, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1724,
|
|
3, 622, 311, 0, 1721, 1723, 3, 78, 39, 0, 1722, 1721, 1, 0, 0, 0, 1723,
|
|
1726, 1, 0, 0, 0, 1724, 1722, 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725,
|
|
1753, 1, 0, 0, 0, 1726, 1724, 1, 0, 0, 0, 1727, 1729, 5, 30, 0, 0, 1728,
|
|
1730, 3, 584, 292, 0, 1729, 1728, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730,
|
|
1732, 1, 0, 0, 0, 1731, 1727, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732,
|
|
1733, 1, 0, 0, 0, 1733, 1734, 5, 67, 0, 0, 1734, 1736, 5, 91, 0, 0, 1735,
|
|
1737, 3, 584, 292, 0, 1736, 1735, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737,
|
|
1738, 1, 0, 0, 0, 1738, 1739, 3, 622, 311, 0, 1739, 1740, 3, 98, 49, 0,
|
|
1740, 1753, 1, 0, 0, 0, 1741, 1743, 5, 30, 0, 0, 1742, 1744, 3, 584, 292,
|
|
0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0,
|
|
0, 1745, 1741, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 1, 0, 0,
|
|
0, 1747, 1748, 5, 26, 0, 0, 1748, 1749, 5, 1133, 0, 0, 1749, 1750, 3, 688,
|
|
344, 0, 1750, 1751, 5, 1134, 0, 0, 1751, 1753, 1, 0, 0, 0, 1752, 1687,
|
|
1, 0, 0, 0, 1752, 1708, 1, 0, 0, 0, 1752, 1731, 1, 0, 0, 0, 1752, 1745,
|
|
1, 0, 0, 0, 1753, 97, 1, 0, 0, 0, 1754, 1755, 5, 136, 0, 0, 1755, 1757,
|
|
3, 552, 276, 0, 1756, 1758, 3, 622, 311, 0, 1757, 1756, 1, 0, 0, 0, 1757,
|
|
1758, 1, 0, 0, 0, 1758, 1761, 1, 0, 0, 0, 1759, 1760, 5, 109, 0, 0, 1760,
|
|
1762, 7, 21, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762,
|
|
1764, 1, 0, 0, 0, 1763, 1765, 3, 100, 50, 0, 1764, 1763, 1, 0, 0, 0, 1764,
|
|
1765, 1, 0, 0, 0, 1765, 99, 1, 0, 0, 0, 1766, 1767, 5, 118, 0, 0, 1767,
|
|
1768, 5, 44, 0, 0, 1768, 1772, 3, 102, 51, 0, 1769, 1770, 5, 118, 0, 0,
|
|
1770, 1771, 5, 184, 0, 0, 1771, 1773, 3, 102, 51, 0, 1772, 1769, 1, 0,
|
|
0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1783, 1, 0, 0, 0, 1774, 1775, 5, 118,
|
|
0, 0, 1775, 1776, 5, 184, 0, 0, 1776, 1780, 3, 102, 51, 0, 1777, 1778,
|
|
5, 118, 0, 0, 1778, 1779, 5, 44, 0, 0, 1779, 1781, 3, 102, 51, 0, 1780,
|
|
1777, 1, 0, 0, 0, 1780, 1781, 1, 0, 0, 0, 1781, 1783, 1, 0, 0, 0, 1782,
|
|
1766, 1, 0, 0, 0, 1782, 1774, 1, 0, 0, 0, 1783, 101, 1, 0, 0, 0, 1784,
|
|
1793, 5, 144, 0, 0, 1785, 1793, 5, 21, 0, 0, 1786, 1787, 5, 153, 0, 0,
|
|
1787, 1793, 5, 116, 0, 0, 1788, 1789, 5, 521, 0, 0, 1789, 1793, 5, 333,
|
|
0, 0, 1790, 1791, 5, 153, 0, 0, 1791, 1793, 5, 42, 0, 0, 1792, 1784, 1,
|
|
0, 0, 0, 1792, 1785, 1, 0, 0, 0, 1792, 1786, 1, 0, 0, 0, 1792, 1788, 1,
|
|
0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 103, 1, 0, 0, 0, 1794, 1796, 7,
|
|
20, 0, 0, 1795, 1797, 3, 584, 292, 0, 1796, 1795, 1, 0, 0, 0, 1796, 1797,
|
|
1, 0, 0, 0, 1797, 1799, 1, 0, 0, 0, 1798, 1800, 3, 76, 38, 0, 1799, 1798,
|
|
1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 1805,
|
|
3, 622, 311, 0, 1802, 1804, 3, 78, 39, 0, 1803, 1802, 1, 0, 0, 0, 1804,
|
|
1807, 1, 0, 0, 0, 1805, 1803, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806,
|
|
1823, 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1808, 1810, 7, 22, 0, 0, 1809,
|
|
1811, 7, 20, 0, 0, 1810, 1809, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811,
|
|
1813, 1, 0, 0, 0, 1812, 1814, 3, 584, 292, 0, 1813, 1812, 1, 0, 0, 0, 1813,
|
|
1814, 1, 0, 0, 0, 1814, 1815, 1, 0, 0, 0, 1815, 1819, 3, 622, 311, 0, 1816,
|
|
1818, 3, 78, 39, 0, 1817, 1816, 1, 0, 0, 0, 1818, 1821, 1, 0, 0, 0, 1819,
|
|
1817, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1823, 1, 0, 0, 0, 1821,
|
|
1819, 1, 0, 0, 0, 1822, 1794, 1, 0, 0, 0, 1822, 1808, 1, 0, 0, 0, 1823,
|
|
105, 1, 0, 0, 0, 1824, 1826, 5, 409, 0, 0, 1825, 1827, 5, 1124, 0, 0, 1826,
|
|
1825, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1829, 1, 0, 0, 0, 1828,
|
|
1830, 3, 572, 286, 0, 1829, 1828, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830,
|
|
2010, 1, 0, 0, 0, 1831, 1833, 5, 875, 0, 0, 1832, 1834, 5, 1124, 0, 0,
|
|
1833, 1832, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0,
|
|
1835, 2010, 5, 1148, 0, 0, 1836, 1838, 5, 341, 0, 0, 1837, 1839, 5, 1124,
|
|
0, 0, 1838, 1837, 1, 0, 0, 0, 1838, 1839, 1, 0, 0, 0, 1839, 1840, 1, 0,
|
|
0, 0, 1840, 2010, 3, 590, 295, 0, 1841, 1843, 5, 342, 0, 0, 1842, 1844,
|
|
5, 1124, 0, 0, 1843, 1842, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845,
|
|
1, 0, 0, 0, 1845, 2010, 3, 590, 295, 0, 1846, 1848, 5, 343, 0, 0, 1847,
|
|
1849, 5, 1124, 0, 0, 1848, 1847, 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849,
|
|
1850, 1, 0, 0, 0, 1850, 2010, 3, 590, 295, 0, 1851, 1853, 5, 42, 0, 0,
|
|
1852, 1851, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0,
|
|
1854, 1856, 3, 60, 30, 0, 1855, 1857, 5, 1124, 0, 0, 1856, 1855, 1, 0,
|
|
0, 0, 1856, 1857, 1, 0, 0, 0, 1857, 1860, 1, 0, 0, 0, 1858, 1861, 3, 568,
|
|
284, 0, 1859, 1861, 5, 42, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1859, 1,
|
|
0, 0, 0, 1861, 2010, 1, 0, 0, 0, 1862, 1864, 7, 23, 0, 0, 1863, 1865, 5,
|
|
1124, 0, 0, 1864, 1863, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1866,
|
|
1, 0, 0, 0, 1866, 2010, 7, 24, 0, 0, 1867, 1869, 5, 42, 0, 0, 1868, 1867,
|
|
1, 0, 0, 0, 1868, 1869, 1, 0, 0, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1872,
|
|
5, 27, 0, 0, 1871, 1873, 5, 1124, 0, 0, 1872, 1871, 1, 0, 0, 0, 1872, 1873,
|
|
1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 2010, 3, 570, 285, 0, 1875, 1877,
|
|
5, 368, 0, 0, 1876, 1878, 5, 1124, 0, 0, 1877, 1876, 1, 0, 0, 0, 1877,
|
|
1878, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 2010, 5, 1148, 0, 0, 1880,
|
|
1882, 5, 373, 0, 0, 1881, 1883, 5, 1124, 0, 0, 1882, 1881, 1, 0, 0, 0,
|
|
1882, 1883, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 2010, 7, 25, 0, 0,
|
|
1885, 1887, 5, 376, 0, 0, 1886, 1888, 5, 1124, 0, 0, 1887, 1886, 1, 0,
|
|
0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 2010, 5, 1148,
|
|
0, 0, 1890, 1891, 7, 26, 0, 0, 1891, 1893, 5, 395, 0, 0, 1892, 1894, 5,
|
|
1124, 0, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895,
|
|
1, 0, 0, 0, 1895, 2010, 5, 1148, 0, 0, 1896, 1898, 5, 393, 0, 0, 1897,
|
|
1899, 5, 1124, 0, 0, 1898, 1897, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899,
|
|
1900, 1, 0, 0, 0, 1900, 2010, 7, 24, 0, 0, 1901, 1903, 5, 405, 0, 0, 1902,
|
|
1904, 5, 1124, 0, 0, 1903, 1902, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904,
|
|
1905, 1, 0, 0, 0, 1905, 2010, 5, 1148, 0, 0, 1906, 1908, 7, 27, 0, 0, 1907,
|
|
1909, 5, 1124, 0, 0, 1908, 1907, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909,
|
|
1910, 1, 0, 0, 0, 1910, 2010, 7, 24, 0, 0, 1911, 1913, 7, 28, 0, 0, 1912,
|
|
1914, 5, 1124, 0, 0, 1913, 1912, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914,
|
|
1915, 1, 0, 0, 0, 1915, 2010, 3, 590, 295, 0, 1916, 1918, 5, 406, 0, 0,
|
|
1917, 1919, 5, 1124, 0, 0, 1918, 1917, 1, 0, 0, 0, 1918, 1919, 1, 0, 0,
|
|
0, 1919, 1920, 1, 0, 0, 0, 1920, 2010, 3, 590, 295, 0, 1921, 1922, 5, 81,
|
|
0, 0, 1922, 1924, 5, 395, 0, 0, 1923, 1925, 5, 1124, 0, 0, 1924, 1923,
|
|
1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 2010,
|
|
5, 1148, 0, 0, 1927, 1929, 5, 455, 0, 0, 1928, 1930, 5, 1124, 0, 0, 1929,
|
|
1928, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931,
|
|
2010, 7, 29, 0, 0, 1932, 1934, 5, 467, 0, 0, 1933, 1935, 5, 1124, 0, 0,
|
|
1934, 1933, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0,
|
|
1936, 2010, 3, 592, 296, 0, 1937, 1939, 5, 500, 0, 0, 1938, 1940, 5, 1124,
|
|
0, 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 1, 0,
|
|
0, 0, 1941, 2010, 3, 590, 295, 0, 1942, 1944, 5, 510, 0, 0, 1943, 1945,
|
|
5, 1124, 0, 0, 1944, 1943, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1946,
|
|
1, 0, 0, 0, 1946, 2010, 3, 590, 295, 0, 1947, 1949, 5, 543, 0, 0, 1948,
|
|
1950, 5, 1124, 0, 0, 1949, 1948, 1, 0, 0, 0, 1949, 1950, 1, 0, 0, 0, 1950,
|
|
1951, 1, 0, 0, 0, 1951, 2010, 7, 13, 0, 0, 1952, 1954, 5, 551, 0, 0, 1953,
|
|
1955, 5, 1124, 0, 0, 1954, 1953, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955,
|
|
1956, 1, 0, 0, 0, 1956, 2010, 5, 1148, 0, 0, 1957, 1959, 5, 602, 0, 0,
|
|
1958, 1960, 5, 1124, 0, 0, 1959, 1958, 1, 0, 0, 0, 1959, 1960, 1, 0, 0,
|
|
0, 1960, 1961, 1, 0, 0, 0, 1961, 2010, 7, 30, 0, 0, 1962, 1963, 5, 629,
|
|
0, 0, 1963, 2010, 5, 653, 0, 0, 1964, 1966, 5, 1000, 0, 0, 1965, 1967,
|
|
5, 1124, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968,
|
|
1, 0, 0, 0, 1968, 2010, 5, 1148, 0, 0, 1969, 1971, 5, 631, 0, 0, 1970,
|
|
1972, 5, 1124, 0, 0, 1971, 1970, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972,
|
|
1973, 1, 0, 0, 0, 1973, 2010, 7, 13, 0, 0, 1974, 1976, 5, 632, 0, 0, 1975,
|
|
1977, 5, 1124, 0, 0, 1976, 1975, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977,
|
|
1978, 1, 0, 0, 0, 1978, 2010, 7, 13, 0, 0, 1979, 1981, 5, 633, 0, 0, 1980,
|
|
1982, 5, 1124, 0, 0, 1981, 1980, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982,
|
|
1985, 1, 0, 0, 0, 1983, 1986, 5, 42, 0, 0, 1984, 1986, 3, 590, 295, 0,
|
|
1985, 1983, 1, 0, 0, 0, 1985, 1984, 1, 0, 0, 0, 1986, 2010, 1, 0, 0, 0,
|
|
1987, 1988, 5, 647, 0, 0, 1988, 1990, 3, 584, 292, 0, 1989, 1991, 3, 110,
|
|
55, 0, 1990, 1989, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 2010, 1, 0,
|
|
0, 0, 1992, 1993, 5, 648, 0, 0, 1993, 1994, 5, 1124, 0, 0, 1994, 2010,
|
|
3, 108, 54, 0, 1995, 2010, 3, 110, 55, 0, 1996, 1998, 5, 654, 0, 0, 1997,
|
|
1999, 5, 1124, 0, 0, 1998, 1997, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999,
|
|
2000, 1, 0, 0, 0, 2000, 2010, 7, 24, 0, 0, 2001, 2003, 5, 180, 0, 0, 2002,
|
|
2004, 5, 1124, 0, 0, 2003, 2002, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004,
|
|
2005, 1, 0, 0, 0, 2005, 2006, 5, 1133, 0, 0, 2006, 2007, 3, 620, 310, 0,
|
|
2007, 2008, 5, 1134, 0, 0, 2008, 2010, 1, 0, 0, 0, 2009, 1824, 1, 0, 0,
|
|
0, 2009, 1831, 1, 0, 0, 0, 2009, 1836, 1, 0, 0, 0, 2009, 1841, 1, 0, 0,
|
|
0, 2009, 1846, 1, 0, 0, 0, 2009, 1852, 1, 0, 0, 0, 2009, 1862, 1, 0, 0,
|
|
0, 2009, 1868, 1, 0, 0, 0, 2009, 1875, 1, 0, 0, 0, 2009, 1880, 1, 0, 0,
|
|
0, 2009, 1885, 1, 0, 0, 0, 2009, 1890, 1, 0, 0, 0, 2009, 1896, 1, 0, 0,
|
|
0, 2009, 1901, 1, 0, 0, 0, 2009, 1906, 1, 0, 0, 0, 2009, 1911, 1, 0, 0,
|
|
0, 2009, 1916, 1, 0, 0, 0, 2009, 1921, 1, 0, 0, 0, 2009, 1927, 1, 0, 0,
|
|
0, 2009, 1932, 1, 0, 0, 0, 2009, 1937, 1, 0, 0, 0, 2009, 1942, 1, 0, 0,
|
|
0, 2009, 1947, 1, 0, 0, 0, 2009, 1952, 1, 0, 0, 0, 2009, 1957, 1, 0, 0,
|
|
0, 2009, 1962, 1, 0, 0, 0, 2009, 1964, 1, 0, 0, 0, 2009, 1969, 1, 0, 0,
|
|
0, 2009, 1974, 1, 0, 0, 0, 2009, 1979, 1, 0, 0, 0, 2009, 1987, 1, 0, 0,
|
|
0, 2009, 1992, 1, 0, 0, 0, 2009, 1995, 1, 0, 0, 0, 2009, 1996, 1, 0, 0,
|
|
0, 2009, 2001, 1, 0, 0, 0, 2010, 107, 1, 0, 0, 0, 2011, 2012, 7, 31, 0,
|
|
0, 2012, 109, 1, 0, 0, 0, 2013, 2014, 5, 636, 0, 0, 2014, 2015, 7, 18,
|
|
0, 0, 2015, 111, 1, 0, 0, 0, 2016, 2017, 5, 129, 0, 0, 2017, 2018, 5, 19,
|
|
0, 0, 2018, 2021, 3, 114, 57, 0, 2019, 2020, 5, 550, 0, 0, 2020, 2022,
|
|
3, 590, 295, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 2030,
|
|
1, 0, 0, 0, 2023, 2024, 5, 641, 0, 0, 2024, 2025, 5, 19, 0, 0, 2025, 2028,
|
|
3, 116, 58, 0, 2026, 2027, 5, 642, 0, 0, 2027, 2029, 3, 590, 295, 0, 2028,
|
|
2026, 1, 0, 0, 0, 2028, 2029, 1, 0, 0, 0, 2029, 2031, 1, 0, 0, 0, 2030,
|
|
2023, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2043, 1, 0, 0, 0, 2032,
|
|
2033, 5, 1133, 0, 0, 2033, 2038, 3, 118, 59, 0, 2034, 2035, 5, 1135, 0,
|
|
0, 2035, 2037, 3, 118, 59, 0, 2036, 2034, 1, 0, 0, 0, 2037, 2040, 1, 0,
|
|
0, 0, 2038, 2036, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2041, 1, 0,
|
|
0, 0, 2040, 2038, 1, 0, 0, 0, 2041, 2042, 5, 1134, 0, 0, 2042, 2044, 1,
|
|
0, 0, 0, 2043, 2032, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 113, 1,
|
|
0, 0, 0, 2045, 2047, 5, 100, 0, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047,
|
|
1, 0, 0, 0, 2047, 2048, 1, 0, 0, 0, 2048, 2049, 5, 443, 0, 0, 2049, 2050,
|
|
5, 1133, 0, 0, 2050, 2051, 3, 688, 344, 0, 2051, 2052, 5, 1134, 0, 0, 2052,
|
|
2092, 1, 0, 0, 0, 2053, 2055, 5, 100, 0, 0, 2054, 2053, 1, 0, 0, 0, 2054,
|
|
2055, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2060, 5, 91, 0, 0, 2057,
|
|
2058, 5, 336, 0, 0, 2058, 2059, 5, 1124, 0, 0, 2059, 2061, 7, 32, 0, 0,
|
|
2060, 2057, 1, 0, 0, 0, 2060, 2061, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0,
|
|
2062, 2064, 5, 1133, 0, 0, 2063, 2065, 3, 616, 308, 0, 2064, 2063, 1, 0,
|
|
0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2092, 5, 1134,
|
|
0, 0, 2067, 2077, 5, 133, 0, 0, 2068, 2069, 5, 1133, 0, 0, 2069, 2070,
|
|
3, 688, 344, 0, 2070, 2071, 5, 1134, 0, 0, 2071, 2078, 1, 0, 0, 0, 2072,
|
|
2073, 5, 365, 0, 0, 2073, 2074, 5, 1133, 0, 0, 2074, 2075, 3, 616, 308,
|
|
0, 2075, 2076, 5, 1134, 0, 0, 2076, 2078, 1, 0, 0, 0, 2077, 2068, 1, 0,
|
|
0, 0, 2077, 2072, 1, 0, 0, 0, 2078, 2092, 1, 0, 0, 0, 2079, 2089, 5, 473,
|
|
0, 0, 2080, 2081, 5, 1133, 0, 0, 2081, 2082, 3, 688, 344, 0, 2082, 2083,
|
|
5, 1134, 0, 0, 2083, 2090, 1, 0, 0, 0, 2084, 2085, 5, 365, 0, 0, 2085,
|
|
2086, 5, 1133, 0, 0, 2086, 2087, 3, 616, 308, 0, 2087, 2088, 5, 1134, 0,
|
|
0, 2088, 2090, 1, 0, 0, 0, 2089, 2080, 1, 0, 0, 0, 2089, 2084, 1, 0, 0,
|
|
0, 2090, 2092, 1, 0, 0, 0, 2091, 2046, 1, 0, 0, 0, 2091, 2054, 1, 0, 0,
|
|
0, 2091, 2067, 1, 0, 0, 0, 2091, 2079, 1, 0, 0, 0, 2092, 115, 1, 0, 0,
|
|
0, 2093, 2095, 5, 100, 0, 0, 2094, 2093, 1, 0, 0, 0, 2094, 2095, 1, 0,
|
|
0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2097, 5, 443, 0, 0, 2097, 2098, 5,
|
|
1133, 0, 0, 2098, 2099, 3, 688, 344, 0, 2099, 2100, 5, 1134, 0, 0, 2100,
|
|
2115, 1, 0, 0, 0, 2101, 2103, 5, 100, 0, 0, 2102, 2101, 1, 0, 0, 0, 2102,
|
|
2103, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2108, 5, 91, 0, 0, 2105,
|
|
2106, 5, 336, 0, 0, 2106, 2107, 5, 1124, 0, 0, 2107, 2109, 7, 32, 0, 0,
|
|
2108, 2105, 1, 0, 0, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0,
|
|
2110, 2111, 5, 1133, 0, 0, 2111, 2112, 3, 616, 308, 0, 2112, 2113, 5, 1134,
|
|
0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2094, 1, 0, 0, 0, 2114, 2102, 1, 0,
|
|
0, 0, 2115, 117, 1, 0, 0, 0, 2116, 2117, 5, 129, 0, 0, 2117, 2118, 3, 584,
|
|
292, 0, 2118, 2119, 5, 188, 0, 0, 2119, 2120, 5, 471, 0, 0, 2120, 2121,
|
|
5, 651, 0, 0, 2121, 2122, 5, 1133, 0, 0, 2122, 2127, 3, 120, 60, 0, 2123,
|
|
2124, 5, 1135, 0, 0, 2124, 2126, 3, 120, 60, 0, 2125, 2123, 1, 0, 0, 0,
|
|
2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0,
|
|
2128, 2130, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2134, 5, 1134, 0,
|
|
0, 2131, 2133, 3, 126, 63, 0, 2132, 2131, 1, 0, 0, 0, 2133, 2136, 1, 0,
|
|
0, 0, 2134, 2132, 1, 0, 0, 0, 2134, 2135, 1, 0, 0, 0, 2135, 2148, 1, 0,
|
|
0, 0, 2136, 2134, 1, 0, 0, 0, 2137, 2138, 5, 1133, 0, 0, 2138, 2143, 3,
|
|
124, 62, 0, 2139, 2140, 5, 1135, 0, 0, 2140, 2142, 3, 124, 62, 0, 2141,
|
|
2139, 1, 0, 0, 0, 2142, 2145, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2143,
|
|
2144, 1, 0, 0, 0, 2144, 2146, 1, 0, 0, 0, 2145, 2143, 1, 0, 0, 0, 2146,
|
|
2147, 5, 1134, 0, 0, 2147, 2149, 1, 0, 0, 0, 2148, 2137, 1, 0, 0, 0, 2148,
|
|
2149, 1, 0, 0, 0, 2149, 2263, 1, 0, 0, 0, 2150, 2151, 5, 129, 0, 0, 2151,
|
|
2152, 3, 584, 292, 0, 2152, 2153, 5, 188, 0, 0, 2153, 2154, 5, 471, 0,
|
|
0, 2154, 2155, 5, 651, 0, 0, 2155, 2159, 3, 120, 60, 0, 2156, 2158, 3,
|
|
126, 63, 0, 2157, 2156, 1, 0, 0, 0, 2158, 2161, 1, 0, 0, 0, 2159, 2157,
|
|
1, 0, 0, 0, 2159, 2160, 1, 0, 0, 0, 2160, 2173, 1, 0, 0, 0, 2161, 2159,
|
|
1, 0, 0, 0, 2162, 2163, 5, 1133, 0, 0, 2163, 2168, 3, 124, 62, 0, 2164,
|
|
2165, 5, 1135, 0, 0, 2165, 2167, 3, 124, 62, 0, 2166, 2164, 1, 0, 0, 0,
|
|
2167, 2170, 1, 0, 0, 0, 2168, 2166, 1, 0, 0, 0, 2168, 2169, 1, 0, 0, 0,
|
|
2169, 2171, 1, 0, 0, 0, 2170, 2168, 1, 0, 0, 0, 2171, 2172, 5, 1134, 0,
|
|
0, 2172, 2174, 1, 0, 0, 0, 2173, 2162, 1, 0, 0, 0, 2173, 2174, 1, 0, 0,
|
|
0, 2174, 2263, 1, 0, 0, 0, 2175, 2176, 5, 129, 0, 0, 2176, 2177, 3, 584,
|
|
292, 0, 2177, 2178, 5, 188, 0, 0, 2178, 2179, 5, 80, 0, 0, 2179, 2180,
|
|
5, 1133, 0, 0, 2180, 2185, 3, 120, 60, 0, 2181, 2182, 5, 1135, 0, 0, 2182,
|
|
2184, 3, 120, 60, 0, 2183, 2181, 1, 0, 0, 0, 2184, 2187, 1, 0, 0, 0, 2185,
|
|
2183, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, 1, 0, 0, 0, 2187,
|
|
2185, 1, 0, 0, 0, 2188, 2192, 5, 1134, 0, 0, 2189, 2191, 3, 126, 63, 0,
|
|
2190, 2189, 1, 0, 0, 0, 2191, 2194, 1, 0, 0, 0, 2192, 2190, 1, 0, 0, 0,
|
|
2192, 2193, 1, 0, 0, 0, 2193, 2206, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0,
|
|
2195, 2196, 5, 1133, 0, 0, 2196, 2201, 3, 124, 62, 0, 2197, 2198, 5, 1135,
|
|
0, 0, 2198, 2200, 3, 124, 62, 0, 2199, 2197, 1, 0, 0, 0, 2200, 2203, 1,
|
|
0, 0, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2204, 1,
|
|
0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2204, 2205, 5, 1134, 0, 0, 2205, 2207,
|
|
1, 0, 0, 0, 2206, 2195, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2263,
|
|
1, 0, 0, 0, 2208, 2209, 5, 129, 0, 0, 2209, 2210, 3, 584, 292, 0, 2210,
|
|
2211, 5, 188, 0, 0, 2211, 2212, 5, 80, 0, 0, 2212, 2213, 5, 1133, 0, 0,
|
|
2213, 2218, 3, 122, 61, 0, 2214, 2215, 5, 1135, 0, 0, 2215, 2217, 3, 122,
|
|
61, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0,
|
|
0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2218, 1, 0,
|
|
0, 0, 2221, 2225, 5, 1134, 0, 0, 2222, 2224, 3, 126, 63, 0, 2223, 2222,
|
|
1, 0, 0, 0, 2224, 2227, 1, 0, 0, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2226,
|
|
1, 0, 0, 0, 2226, 2239, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2229,
|
|
5, 1133, 0, 0, 2229, 2234, 3, 124, 62, 0, 2230, 2231, 5, 1135, 0, 0, 2231,
|
|
2233, 3, 124, 62, 0, 2232, 2230, 1, 0, 0, 0, 2233, 2236, 1, 0, 0, 0, 2234,
|
|
2232, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2237, 1, 0, 0, 0, 2236,
|
|
2234, 1, 0, 0, 0, 2237, 2238, 5, 1134, 0, 0, 2238, 2240, 1, 0, 0, 0, 2239,
|
|
2228, 1, 0, 0, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2263, 1, 0, 0, 0, 2241,
|
|
2242, 5, 129, 0, 0, 2242, 2246, 3, 584, 292, 0, 2243, 2245, 3, 126, 63,
|
|
0, 2244, 2243, 1, 0, 0, 0, 2245, 2248, 1, 0, 0, 0, 2246, 2244, 1, 0, 0,
|
|
0, 2246, 2247, 1, 0, 0, 0, 2247, 2260, 1, 0, 0, 0, 2248, 2246, 1, 0, 0,
|
|
0, 2249, 2250, 5, 1133, 0, 0, 2250, 2255, 3, 124, 62, 0, 2251, 2252, 5,
|
|
1135, 0, 0, 2252, 2254, 3, 124, 62, 0, 2253, 2251, 1, 0, 0, 0, 2254, 2257,
|
|
1, 0, 0, 0, 2255, 2253, 1, 0, 0, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2258,
|
|
1, 0, 0, 0, 2257, 2255, 1, 0, 0, 0, 2258, 2259, 5, 1134, 0, 0, 2259, 2261,
|
|
1, 0, 0, 0, 2260, 2249, 1, 0, 0, 0, 2260, 2261, 1, 0, 0, 0, 2261, 2263,
|
|
1, 0, 0, 0, 2262, 2116, 1, 0, 0, 0, 2262, 2150, 1, 0, 0, 0, 2262, 2175,
|
|
1, 0, 0, 0, 2262, 2208, 1, 0, 0, 0, 2262, 2241, 1, 0, 0, 0, 2263, 119,
|
|
1, 0, 0, 0, 2264, 2268, 3, 602, 301, 0, 2265, 2268, 3, 688, 344, 0, 2266,
|
|
2268, 5, 110, 0, 0, 2267, 2264, 1, 0, 0, 0, 2267, 2265, 1, 0, 0, 0, 2267,
|
|
2266, 1, 0, 0, 0, 2268, 121, 1, 0, 0, 0, 2269, 2270, 5, 1133, 0, 0, 2270,
|
|
2273, 3, 120, 60, 0, 2271, 2272, 5, 1135, 0, 0, 2272, 2274, 3, 120, 60,
|
|
0, 2273, 2271, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2273, 1, 0, 0,
|
|
0, 2275, 2276, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2278, 5, 1134,
|
|
0, 0, 2278, 123, 1, 0, 0, 0, 2279, 2280, 5, 641, 0, 0, 2280, 2284, 3, 584,
|
|
292, 0, 2281, 2283, 3, 126, 63, 0, 2282, 2281, 1, 0, 0, 0, 2283, 2286,
|
|
1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 125,
|
|
1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2289, 5, 42, 0, 0, 2288, 2287,
|
|
1, 0, 0, 0, 2288, 2289, 1, 0, 0, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2292,
|
|
5, 636, 0, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2293,
|
|
1, 0, 0, 0, 2293, 2295, 5, 409, 0, 0, 2294, 2296, 5, 1124, 0, 0, 2295,
|
|
2294, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297,
|
|
2336, 3, 572, 286, 0, 2298, 2300, 5, 368, 0, 0, 2299, 2301, 5, 1124, 0,
|
|
0, 2300, 2299, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2302, 1, 0, 0,
|
|
0, 2302, 2336, 5, 1148, 0, 0, 2303, 2304, 5, 388, 0, 0, 2304, 2306, 5,
|
|
395, 0, 0, 2305, 2307, 5, 1124, 0, 0, 2306, 2305, 1, 0, 0, 0, 2306, 2307,
|
|
1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2336, 5, 1148, 0, 0, 2309, 2310,
|
|
5, 81, 0, 0, 2310, 2312, 5, 395, 0, 0, 2311, 2313, 5, 1124, 0, 0, 2312,
|
|
2311, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2314, 1, 0, 0, 0, 2314,
|
|
2336, 5, 1148, 0, 0, 2315, 2317, 5, 500, 0, 0, 2316, 2318, 5, 1124, 0,
|
|
0, 2317, 2316, 1, 0, 0, 0, 2317, 2318, 1, 0, 0, 0, 2318, 2319, 1, 0, 0,
|
|
0, 2319, 2336, 3, 590, 295, 0, 2320, 2322, 5, 510, 0, 0, 2321, 2323, 5,
|
|
1124, 0, 0, 2322, 2321, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2324,
|
|
1, 0, 0, 0, 2324, 2336, 3, 590, 295, 0, 2325, 2327, 5, 647, 0, 0, 2326,
|
|
2328, 5, 1124, 0, 0, 2327, 2326, 1, 0, 0, 0, 2327, 2328, 1, 0, 0, 0, 2328,
|
|
2329, 1, 0, 0, 0, 2329, 2336, 3, 584, 292, 0, 2330, 2332, 5, 528, 0, 0,
|
|
2331, 2333, 5, 1124, 0, 0, 2332, 2331, 1, 0, 0, 0, 2332, 2333, 1, 0, 0,
|
|
0, 2333, 2334, 1, 0, 0, 0, 2334, 2336, 3, 584, 292, 0, 2335, 2288, 1, 0,
|
|
0, 0, 2335, 2298, 1, 0, 0, 0, 2335, 2303, 1, 0, 0, 0, 2335, 2309, 1, 0,
|
|
0, 0, 2335, 2315, 1, 0, 0, 0, 2335, 2320, 1, 0, 0, 0, 2335, 2325, 1, 0,
|
|
0, 0, 2335, 2330, 1, 0, 0, 0, 2336, 127, 1, 0, 0, 0, 2337, 2338, 5, 7,
|
|
0, 0, 2338, 2340, 7, 0, 0, 0, 2339, 2341, 3, 584, 292, 0, 2340, 2339, 1,
|
|
0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2343, 1, 0, 0, 0, 2342, 2344, 3,
|
|
58, 29, 0, 2343, 2342, 1, 0, 0, 0, 2344, 2345, 1, 0, 0, 0, 2345, 2343,
|
|
1, 0, 0, 0, 2345, 2346, 1, 0, 0, 0, 2346, 2356, 1, 0, 0, 0, 2347, 2348,
|
|
5, 7, 0, 0, 2348, 2349, 7, 0, 0, 0, 2349, 2350, 3, 584, 292, 0, 2350, 2351,
|
|
5, 664, 0, 0, 2351, 2352, 5, 388, 0, 0, 2352, 2353, 5, 395, 0, 0, 2353,
|
|
2354, 5, 516, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2337, 1, 0, 0, 0, 2355,
|
|
2347, 1, 0, 0, 0, 2356, 129, 1, 0, 0, 0, 2357, 2359, 5, 7, 0, 0, 2358,
|
|
2360, 3, 64, 32, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360,
|
|
2361, 1, 0, 0, 0, 2361, 2362, 5, 415, 0, 0, 2362, 2366, 3, 550, 275, 0,
|
|
2363, 2364, 5, 118, 0, 0, 2364, 2365, 5, 605, 0, 0, 2365, 2367, 3, 66,
|
|
33, 0, 2366, 2363, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2374, 1, 0,
|
|
0, 0, 2368, 2369, 5, 118, 0, 0, 2369, 2371, 5, 371, 0, 0, 2370, 2372, 5,
|
|
114, 0, 0, 2371, 2370, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2373,
|
|
1, 0, 0, 0, 2373, 2375, 5, 561, 0, 0, 2374, 2368, 1, 0, 0, 0, 2374, 2375,
|
|
1, 0, 0, 0, 2375, 2379, 1, 0, 0, 0, 2376, 2377, 5, 139, 0, 0, 2377, 2378,
|
|
5, 175, 0, 0, 2378, 2380, 3, 550, 275, 0, 2379, 2376, 1, 0, 0, 0, 2379,
|
|
2380, 1, 0, 0, 0, 2380, 2382, 1, 0, 0, 0, 2381, 2383, 3, 74, 37, 0, 2382,
|
|
2381, 1, 0, 0, 0, 2382, 2383, 1, 0, 0, 0, 2383, 2386, 1, 0, 0, 0, 2384,
|
|
2385, 5, 368, 0, 0, 2385, 2387, 5, 1148, 0, 0, 2386, 2384, 1, 0, 0, 0,
|
|
2386, 2387, 1, 0, 0, 0, 2387, 2390, 1, 0, 0, 0, 2388, 2389, 5, 399, 0,
|
|
0, 2389, 2391, 3, 388, 194, 0, 2390, 2388, 1, 0, 0, 0, 2390, 2391, 1, 0,
|
|
0, 0, 2391, 131, 1, 0, 0, 0, 2392, 2393, 5, 7, 0, 0, 2393, 2394, 5, 437,
|
|
0, 0, 2394, 2398, 3, 550, 275, 0, 2395, 2397, 3, 84, 42, 0, 2396, 2395,
|
|
1, 0, 0, 0, 2397, 2400, 1, 0, 0, 0, 2398, 2396, 1, 0, 0, 0, 2398, 2399,
|
|
1, 0, 0, 0, 2399, 133, 1, 0, 0, 0, 2400, 2398, 1, 0, 0, 0, 2401, 2402,
|
|
5, 7, 0, 0, 2402, 2403, 5, 457, 0, 0, 2403, 2404, 5, 599, 0, 0, 2404, 2405,
|
|
5, 791, 0, 0, 2405, 2406, 5, 477, 0, 0, 2406, 2407, 5, 91, 0, 0, 2407,
|
|
135, 1, 0, 0, 0, 2408, 2409, 5, 7, 0, 0, 2409, 2410, 5, 475, 0, 0, 2410,
|
|
2411, 5, 73, 0, 0, 2411, 2412, 3, 584, 292, 0, 2412, 2413, 5, 5, 0, 0,
|
|
2413, 2414, 5, 659, 0, 0, 2414, 2420, 5, 1148, 0, 0, 2415, 2417, 5, 453,
|
|
0, 0, 2416, 2418, 5, 1124, 0, 0, 2417, 2416, 1, 0, 0, 0, 2417, 2418, 1,
|
|
0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2421, 3, 592, 296, 0, 2420, 2415,
|
|
1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2424,
|
|
5, 674, 0, 0, 2423, 2422, 1, 0, 0, 0, 2423, 2424, 1, 0, 0, 0, 2424, 2425,
|
|
1, 0, 0, 0, 2425, 2427, 5, 409, 0, 0, 2426, 2428, 5, 1124, 0, 0, 2427,
|
|
2426, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429,
|
|
2430, 3, 572, 286, 0, 2430, 137, 1, 0, 0, 0, 2431, 2432, 5, 7, 0, 0, 2432,
|
|
2433, 5, 131, 0, 0, 2433, 2437, 3, 550, 275, 0, 2434, 2436, 3, 84, 42,
|
|
0, 2435, 2434, 1, 0, 0, 0, 2436, 2439, 1, 0, 0, 0, 2437, 2435, 1, 0, 0,
|
|
0, 2437, 2438, 1, 0, 0, 0, 2438, 139, 1, 0, 0, 0, 2439, 2437, 1, 0, 0,
|
|
0, 2440, 2441, 5, 7, 0, 0, 2441, 2442, 5, 608, 0, 0, 2442, 2443, 3, 584,
|
|
292, 0, 2443, 2444, 5, 541, 0, 0, 2444, 2445, 5, 1133, 0, 0, 2445, 2450,
|
|
3, 86, 43, 0, 2446, 2447, 5, 1135, 0, 0, 2447, 2449, 3, 86, 43, 0, 2448,
|
|
2446, 1, 0, 0, 0, 2449, 2452, 1, 0, 0, 0, 2450, 2448, 1, 0, 0, 0, 2450,
|
|
2451, 1, 0, 0, 0, 2451, 2453, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2453,
|
|
2454, 5, 1134, 0, 0, 2454, 141, 1, 0, 0, 0, 2455, 2457, 5, 7, 0, 0, 2456,
|
|
2458, 7, 1, 0, 0, 2457, 2456, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458,
|
|
2460, 1, 0, 0, 0, 2459, 2461, 5, 78, 0, 0, 2460, 2459, 1, 0, 0, 0, 2460,
|
|
2461, 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 5, 172, 0, 0, 2463,
|
|
2465, 3, 552, 276, 0, 2464, 2466, 3, 646, 323, 0, 2465, 2464, 1, 0, 0,
|
|
0, 2465, 2466, 1, 0, 0, 0, 2466, 2475, 1, 0, 0, 0, 2467, 2472, 3, 148,
|
|
74, 0, 2468, 2469, 5, 1135, 0, 0, 2469, 2471, 3, 148, 74, 0, 2470, 2468,
|
|
1, 0, 0, 0, 2471, 2474, 1, 0, 0, 0, 2472, 2470, 1, 0, 0, 0, 2472, 2473,
|
|
1, 0, 0, 0, 2473, 2476, 1, 0, 0, 0, 2474, 2472, 1, 0, 0, 0, 2475, 2467,
|
|
1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2479,
|
|
3, 112, 56, 0, 2478, 2477, 1, 0, 0, 0, 2478, 2479, 1, 0, 0, 0, 2479, 143,
|
|
1, 0, 0, 0, 2480, 2481, 5, 7, 0, 0, 2481, 2482, 5, 647, 0, 0, 2482, 2483,
|
|
3, 584, 292, 0, 2483, 2484, 7, 33, 0, 0, 2484, 2485, 5, 389, 0, 0, 2485,
|
|
2489, 5, 1148, 0, 0, 2486, 2487, 5, 453, 0, 0, 2487, 2488, 5, 1124, 0,
|
|
0, 2488, 2490, 3, 592, 296, 0, 2489, 2486, 1, 0, 0, 0, 2489, 2490, 1, 0,
|
|
0, 0, 2490, 2492, 1, 0, 0, 0, 2491, 2493, 5, 674, 0, 0, 2492, 2491, 1,
|
|
0, 0, 0, 2492, 2493, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2496, 5,
|
|
409, 0, 0, 2495, 2497, 5, 1124, 0, 0, 2496, 2495, 1, 0, 0, 0, 2496, 2497,
|
|
1, 0, 0, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2499, 3, 572, 286, 0, 2499, 145,
|
|
1, 0, 0, 0, 2500, 2504, 5, 7, 0, 0, 2501, 2502, 5, 336, 0, 0, 2502, 2503,
|
|
5, 1124, 0, 0, 2503, 2505, 7, 10, 0, 0, 2504, 2501, 1, 0, 0, 0, 2504, 2505,
|
|
1, 0, 0, 0, 2505, 2507, 1, 0, 0, 0, 2506, 2508, 3, 64, 32, 0, 2507, 2506,
|
|
1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2512, 1, 0, 0, 0, 2509, 2510,
|
|
5, 160, 0, 0, 2510, 2511, 5, 606, 0, 0, 2511, 2513, 7, 11, 0, 0, 2512,
|
|
2509, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, 0, 2514,
|
|
2515, 5, 671, 0, 0, 2515, 2520, 3, 550, 275, 0, 2516, 2517, 5, 1133, 0,
|
|
0, 2517, 2518, 3, 616, 308, 0, 2518, 2519, 5, 1134, 0, 0, 2519, 2521, 1,
|
|
0, 0, 0, 2520, 2516, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2522, 1,
|
|
0, 0, 0, 2522, 2523, 5, 12, 0, 0, 2523, 2530, 3, 200, 100, 0, 2524, 2526,
|
|
5, 192, 0, 0, 2525, 2527, 7, 12, 0, 0, 2526, 2525, 1, 0, 0, 0, 2526, 2527,
|
|
1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2529, 5, 26, 0, 0, 2529, 2531,
|
|
5, 120, 0, 0, 2530, 2524, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 147,
|
|
1, 0, 0, 0, 2532, 2539, 3, 106, 53, 0, 2533, 2535, 5, 1135, 0, 0, 2534,
|
|
2533, 1, 0, 0, 0, 2534, 2535, 1, 0, 0, 0, 2535, 2536, 1, 0, 0, 0, 2536,
|
|
2538, 3, 106, 53, 0, 2537, 2534, 1, 0, 0, 0, 2538, 2541, 1, 0, 0, 0, 2539,
|
|
2537, 1, 0, 0, 0, 2539, 2540, 1, 0, 0, 0, 2540, 2884, 1, 0, 0, 0, 2541,
|
|
2539, 1, 0, 0, 0, 2542, 2544, 5, 5, 0, 0, 2543, 2545, 5, 28, 0, 0, 2544,
|
|
2543, 1, 0, 0, 0, 2544, 2545, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546,
|
|
2547, 3, 584, 292, 0, 2547, 2551, 3, 92, 46, 0, 2548, 2552, 5, 430, 0,
|
|
0, 2549, 2550, 5, 334, 0, 0, 2550, 2552, 3, 584, 292, 0, 2551, 2548, 1,
|
|
0, 0, 0, 2551, 2549, 1, 0, 0, 0, 2551, 2552, 1, 0, 0, 0, 2552, 2884, 1,
|
|
0, 0, 0, 2553, 2555, 5, 5, 0, 0, 2554, 2556, 5, 28, 0, 0, 2555, 2554, 1,
|
|
0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 5,
|
|
1133, 0, 0, 2558, 2559, 3, 584, 292, 0, 2559, 2566, 3, 92, 46, 0, 2560,
|
|
2561, 5, 1135, 0, 0, 2561, 2562, 3, 584, 292, 0, 2562, 2563, 3, 92, 46,
|
|
0, 2563, 2565, 1, 0, 0, 0, 2564, 2560, 1, 0, 0, 0, 2565, 2568, 1, 0, 0,
|
|
0, 2566, 2564, 1, 0, 0, 0, 2566, 2567, 1, 0, 0, 0, 2567, 2569, 1, 0, 0,
|
|
0, 2568, 2566, 1, 0, 0, 0, 2569, 2570, 5, 1134, 0, 0, 2570, 2884, 1, 0,
|
|
0, 0, 2571, 2572, 5, 5, 0, 0, 2572, 2574, 7, 20, 0, 0, 2573, 2575, 3, 584,
|
|
292, 0, 2574, 2573, 1, 0, 0, 0, 2574, 2575, 1, 0, 0, 0, 2575, 2577, 1,
|
|
0, 0, 0, 2576, 2578, 3, 76, 38, 0, 2577, 2576, 1, 0, 0, 0, 2577, 2578,
|
|
1, 0, 0, 0, 2578, 2579, 1, 0, 0, 0, 2579, 2583, 3, 622, 311, 0, 2580, 2582,
|
|
3, 78, 39, 0, 2581, 2580, 1, 0, 0, 0, 2582, 2585, 1, 0, 0, 0, 2583, 2581,
|
|
1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2884, 1, 0, 0, 0, 2585, 2583,
|
|
1, 0, 0, 0, 2586, 2591, 5, 5, 0, 0, 2587, 2589, 5, 30, 0, 0, 2588, 2590,
|
|
3, 584, 292, 0, 2589, 2588, 1, 0, 0, 0, 2589, 2590, 1, 0, 0, 0, 2590, 2592,
|
|
1, 0, 0, 0, 2591, 2587, 1, 0, 0, 0, 2591, 2592, 1, 0, 0, 0, 2592, 2593,
|
|
1, 0, 0, 0, 2593, 2594, 5, 130, 0, 0, 2594, 2596, 5, 91, 0, 0, 2595, 2597,
|
|
3, 584, 292, 0, 2596, 2595, 1, 0, 0, 0, 2596, 2597, 1, 0, 0, 0, 2597, 2599,
|
|
1, 0, 0, 0, 2598, 2600, 3, 76, 38, 0, 2599, 2598, 1, 0, 0, 0, 2599, 2600,
|
|
1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2605, 3, 622, 311, 0, 2602, 2604,
|
|
3, 78, 39, 0, 2603, 2602, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, 0, 2605, 2603,
|
|
1, 0, 0, 0, 2605, 2606, 1, 0, 0, 0, 2606, 2884, 1, 0, 0, 0, 2607, 2605,
|
|
1, 0, 0, 0, 2608, 2613, 5, 5, 0, 0, 2609, 2611, 5, 30, 0, 0, 2610, 2612,
|
|
3, 584, 292, 0, 2611, 2610, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 2614,
|
|
1, 0, 0, 0, 2613, 2609, 1, 0, 0, 0, 2613, 2614, 1, 0, 0, 0, 2614, 2615,
|
|
1, 0, 0, 0, 2615, 2617, 5, 181, 0, 0, 2616, 2618, 7, 20, 0, 0, 2617, 2616,
|
|
1, 0, 0, 0, 2617, 2618, 1, 0, 0, 0, 2618, 2620, 1, 0, 0, 0, 2619, 2621,
|
|
3, 584, 292, 0, 2620, 2619, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 2623,
|
|
1, 0, 0, 0, 2622, 2624, 3, 76, 38, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624,
|
|
1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2629, 3, 622, 311, 0, 2626, 2628,
|
|
3, 78, 39, 0, 2627, 2626, 1, 0, 0, 0, 2628, 2631, 1, 0, 0, 0, 2629, 2627,
|
|
1, 0, 0, 0, 2629, 2630, 1, 0, 0, 0, 2630, 2884, 1, 0, 0, 0, 2631, 2629,
|
|
1, 0, 0, 0, 2632, 2633, 5, 5, 0, 0, 2633, 2635, 7, 22, 0, 0, 2634, 2636,
|
|
7, 20, 0, 0, 2635, 2634, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2638,
|
|
1, 0, 0, 0, 2637, 2639, 3, 584, 292, 0, 2638, 2637, 1, 0, 0, 0, 2638, 2639,
|
|
1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2644, 3, 622, 311, 0, 2641, 2643,
|
|
3, 78, 39, 0, 2642, 2641, 1, 0, 0, 0, 2643, 2646, 1, 0, 0, 0, 2644, 2642,
|
|
1, 0, 0, 0, 2644, 2645, 1, 0, 0, 0, 2645, 2884, 1, 0, 0, 0, 2646, 2644,
|
|
1, 0, 0, 0, 2647, 2652, 5, 5, 0, 0, 2648, 2650, 5, 30, 0, 0, 2649, 2651,
|
|
3, 584, 292, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653,
|
|
1, 0, 0, 0, 2652, 2648, 1, 0, 0, 0, 2652, 2653, 1, 0, 0, 0, 2653, 2654,
|
|
1, 0, 0, 0, 2654, 2655, 5, 67, 0, 0, 2655, 2657, 5, 91, 0, 0, 2656, 2658,
|
|
3, 584, 292, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2659,
|
|
1, 0, 0, 0, 2659, 2660, 3, 622, 311, 0, 2660, 2661, 3, 98, 49, 0, 2661,
|
|
2884, 1, 0, 0, 0, 2662, 2667, 5, 5, 0, 0, 2663, 2665, 5, 30, 0, 0, 2664,
|
|
2666, 3, 584, 292, 0, 2665, 2664, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666,
|
|
2668, 1, 0, 0, 0, 2667, 2663, 1, 0, 0, 0, 2667, 2668, 1, 0, 0, 0, 2668,
|
|
2669, 1, 0, 0, 0, 2669, 2676, 5, 26, 0, 0, 2670, 2677, 3, 584, 292, 0,
|
|
2671, 2677, 3, 594, 297, 0, 2672, 2673, 5, 1133, 0, 0, 2673, 2674, 3, 688,
|
|
344, 0, 2674, 2675, 5, 1134, 0, 0, 2675, 2677, 1, 0, 0, 0, 2676, 2670,
|
|
1, 0, 0, 0, 2676, 2671, 1, 0, 0, 0, 2676, 2672, 1, 0, 0, 0, 2677, 2679,
|
|
1, 0, 0, 0, 2678, 2680, 5, 114, 0, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680,
|
|
1, 0, 0, 0, 2680, 2682, 1, 0, 0, 0, 2681, 2683, 5, 57, 0, 0, 2682, 2681,
|
|
1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 2884, 1, 0, 0, 0, 2684, 2689,
|
|
5, 7, 0, 0, 2685, 2687, 5, 30, 0, 0, 2686, 2688, 3, 584, 292, 0, 2687,
|
|
2686, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, 2690, 1, 0, 0, 0, 2689,
|
|
2685, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691,
|
|
2698, 5, 26, 0, 0, 2692, 2699, 3, 584, 292, 0, 2693, 2699, 3, 594, 297,
|
|
0, 2694, 2695, 5, 1133, 0, 0, 2695, 2696, 3, 688, 344, 0, 2696, 2697, 5,
|
|
1134, 0, 0, 2697, 2699, 1, 0, 0, 0, 2698, 2692, 1, 0, 0, 0, 2698, 2693,
|
|
1, 0, 0, 0, 2698, 2694, 1, 0, 0, 0, 2699, 2701, 1, 0, 0, 0, 2700, 2702,
|
|
5, 114, 0, 0, 2701, 2700, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2704,
|
|
1, 0, 0, 0, 2703, 2705, 5, 57, 0, 0, 2704, 2703, 1, 0, 0, 0, 2704, 2705,
|
|
1, 0, 0, 0, 2705, 2884, 1, 0, 0, 0, 2706, 2711, 5, 5, 0, 0, 2707, 2709,
|
|
5, 30, 0, 0, 2708, 2710, 3, 584, 292, 0, 2709, 2708, 1, 0, 0, 0, 2709,
|
|
2710, 1, 0, 0, 0, 2710, 2712, 1, 0, 0, 0, 2711, 2707, 1, 0, 0, 0, 2711,
|
|
2712, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 2714, 5, 26, 0, 0, 2714,
|
|
2715, 5, 1133, 0, 0, 2715, 2716, 3, 688, 344, 0, 2716, 2717, 5, 1134, 0,
|
|
0, 2717, 2884, 1, 0, 0, 0, 2718, 2720, 5, 336, 0, 0, 2719, 2721, 5, 1124,
|
|
0, 0, 2720, 2719, 1, 0, 0, 0, 2720, 2721, 1, 0, 0, 0, 2721, 2722, 1, 0,
|
|
0, 0, 2722, 2884, 7, 34, 0, 0, 2723, 2725, 5, 7, 0, 0, 2724, 2726, 5, 28,
|
|
0, 0, 2725, 2724, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 2727, 1, 0,
|
|
0, 0, 2727, 2733, 3, 584, 292, 0, 2728, 2729, 5, 153, 0, 0, 2729, 2730,
|
|
5, 42, 0, 0, 2730, 2734, 3, 634, 317, 0, 2731, 2732, 5, 51, 0, 0, 2732,
|
|
2734, 5, 42, 0, 0, 2733, 2728, 1, 0, 0, 0, 2733, 2731, 1, 0, 0, 0, 2734,
|
|
2884, 1, 0, 0, 0, 2735, 2737, 5, 24, 0, 0, 2736, 2738, 5, 28, 0, 0, 2737,
|
|
2736, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739,
|
|
2740, 3, 584, 292, 0, 2740, 2741, 3, 584, 292, 0, 2741, 2745, 3, 92, 46,
|
|
0, 2742, 2746, 5, 430, 0, 0, 2743, 2744, 5, 334, 0, 0, 2744, 2746, 3, 584,
|
|
292, 0, 2745, 2742, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2746, 1,
|
|
0, 0, 0, 2746, 2884, 1, 0, 0, 0, 2747, 2748, 5, 139, 0, 0, 2748, 2749,
|
|
5, 28, 0, 0, 2749, 2750, 3, 584, 292, 0, 2750, 2751, 5, 175, 0, 0, 2751,
|
|
2752, 3, 584, 292, 0, 2752, 2884, 1, 0, 0, 0, 2753, 2755, 5, 103, 0, 0,
|
|
2754, 2756, 5, 1124, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0,
|
|
0, 2756, 2757, 1, 0, 0, 0, 2757, 2884, 7, 4, 0, 0, 2758, 2760, 5, 512,
|
|
0, 0, 2759, 2761, 5, 28, 0, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0,
|
|
0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2763, 3, 584, 292, 0, 2763, 2767, 3,
|
|
92, 46, 0, 2764, 2768, 5, 430, 0, 0, 2765, 2766, 5, 334, 0, 0, 2766, 2768,
|
|
3, 584, 292, 0, 2767, 2764, 1, 0, 0, 0, 2767, 2765, 1, 0, 0, 0, 2767, 2768,
|
|
1, 0, 0, 0, 2768, 2884, 1, 0, 0, 0, 2769, 2771, 5, 51, 0, 0, 2770, 2772,
|
|
5, 28, 0, 0, 2771, 2770, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 2773,
|
|
1, 0, 0, 0, 2773, 2775, 3, 584, 292, 0, 2774, 2776, 5, 144, 0, 0, 2775,
|
|
2774, 1, 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 2884, 1, 0, 0, 0, 2777,
|
|
2778, 5, 51, 0, 0, 2778, 2779, 7, 35, 0, 0, 2779, 2884, 3, 584, 292, 0,
|
|
2780, 2781, 5, 51, 0, 0, 2781, 2782, 5, 130, 0, 0, 2782, 2884, 5, 91, 0,
|
|
0, 2783, 2784, 5, 51, 0, 0, 2784, 2785, 7, 20, 0, 0, 2785, 2884, 3, 584,
|
|
292, 0, 2786, 2787, 5, 139, 0, 0, 2787, 2788, 7, 20, 0, 0, 2788, 2789,
|
|
3, 584, 292, 0, 2789, 2790, 5, 175, 0, 0, 2790, 2791, 3, 584, 292, 0, 2791,
|
|
2884, 1, 0, 0, 0, 2792, 2794, 5, 7, 0, 0, 2793, 2795, 5, 28, 0, 0, 2794,
|
|
2793, 1, 0, 0, 0, 2794, 2795, 1, 0, 0, 0, 2795, 2796, 1, 0, 0, 0, 2796,
|
|
2810, 3, 584, 292, 0, 2797, 2798, 5, 153, 0, 0, 2798, 2804, 5, 42, 0, 0,
|
|
2799, 2805, 3, 594, 297, 0, 2800, 2801, 5, 1133, 0, 0, 2801, 2802, 3, 688,
|
|
344, 0, 2802, 2803, 5, 1134, 0, 0, 2803, 2805, 1, 0, 0, 0, 2804, 2799,
|
|
1, 0, 0, 0, 2804, 2800, 1, 0, 0, 0, 2805, 2811, 1, 0, 0, 0, 2806, 2807,
|
|
5, 153, 0, 0, 2807, 2811, 7, 15, 0, 0, 2808, 2809, 5, 51, 0, 0, 2809, 2811,
|
|
5, 42, 0, 0, 2810, 2797, 1, 0, 0, 0, 2810, 2806, 1, 0, 0, 0, 2810, 2808,
|
|
1, 0, 0, 0, 2811, 2884, 1, 0, 0, 0, 2812, 2813, 5, 7, 0, 0, 2813, 2814,
|
|
5, 81, 0, 0, 2814, 2815, 3, 584, 292, 0, 2815, 2816, 7, 15, 0, 0, 2816,
|
|
2884, 1, 0, 0, 0, 2817, 2818, 5, 51, 0, 0, 2818, 2819, 5, 67, 0, 0, 2819,
|
|
2820, 5, 91, 0, 0, 2820, 2884, 3, 584, 292, 0, 2821, 2822, 5, 396, 0, 0,
|
|
2822, 2884, 5, 92, 0, 0, 2823, 2824, 5, 403, 0, 0, 2824, 2884, 5, 92, 0,
|
|
0, 2825, 2827, 5, 139, 0, 0, 2826, 2828, 7, 36, 0, 0, 2827, 2826, 1, 0,
|
|
0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 2831, 1, 0, 0, 0, 2829, 2832, 3, 584,
|
|
292, 0, 2830, 2832, 3, 550, 275, 0, 2831, 2829, 1, 0, 0, 0, 2831, 2830,
|
|
1, 0, 0, 0, 2832, 2884, 1, 0, 0, 0, 2833, 2834, 5, 124, 0, 0, 2834, 2835,
|
|
5, 19, 0, 0, 2835, 2884, 3, 616, 308, 0, 2836, 2837, 5, 32, 0, 0, 2837,
|
|
2841, 5, 175, 0, 0, 2838, 2842, 5, 841, 0, 0, 2839, 2840, 5, 25, 0, 0,
|
|
2840, 2842, 5, 153, 0, 0, 2841, 2838, 1, 0, 0, 0, 2841, 2839, 1, 0, 0,
|
|
0, 2842, 2843, 1, 0, 0, 0, 2843, 2846, 3, 568, 284, 0, 2844, 2845, 5, 27,
|
|
0, 0, 2845, 2847, 3, 570, 285, 0, 2846, 2844, 1, 0, 0, 0, 2846, 2847, 1,
|
|
0, 0, 0, 2847, 2884, 1, 0, 0, 0, 2848, 2850, 5, 42, 0, 0, 2849, 2848, 1,
|
|
0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, 2852, 5,
|
|
25, 0, 0, 2852, 2853, 5, 153, 0, 0, 2853, 2854, 5, 1124, 0, 0, 2854, 2858,
|
|
3, 568, 284, 0, 2855, 2856, 5, 27, 0, 0, 2856, 2857, 5, 1124, 0, 0, 2857,
|
|
2859, 3, 570, 285, 0, 2858, 2855, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859,
|
|
2884, 1, 0, 0, 0, 2860, 2861, 5, 397, 0, 0, 2861, 2884, 5, 647, 0, 0, 2862,
|
|
2863, 5, 450, 0, 0, 2863, 2884, 5, 647, 0, 0, 2864, 2884, 5, 66, 0, 0,
|
|
2865, 2866, 7, 37, 0, 0, 2866, 2884, 5, 668, 0, 0, 2867, 2869, 5, 5, 0,
|
|
0, 2868, 2870, 5, 28, 0, 0, 2869, 2868, 1, 0, 0, 0, 2869, 2870, 1, 0, 0,
|
|
0, 2870, 2871, 1, 0, 0, 0, 2871, 2872, 5, 1133, 0, 0, 2872, 2877, 3, 90,
|
|
45, 0, 2873, 2874, 5, 1135, 0, 0, 2874, 2876, 3, 90, 45, 0, 2875, 2873,
|
|
1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878,
|
|
1, 0, 0, 0, 2878, 2880, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2881,
|
|
5, 1134, 0, 0, 2881, 2884, 1, 0, 0, 0, 2882, 2884, 3, 150, 75, 0, 2883,
|
|
2532, 1, 0, 0, 0, 2883, 2542, 1, 0, 0, 0, 2883, 2553, 1, 0, 0, 0, 2883,
|
|
2571, 1, 0, 0, 0, 2883, 2586, 1, 0, 0, 0, 2883, 2608, 1, 0, 0, 0, 2883,
|
|
2632, 1, 0, 0, 0, 2883, 2647, 1, 0, 0, 0, 2883, 2662, 1, 0, 0, 0, 2883,
|
|
2684, 1, 0, 0, 0, 2883, 2706, 1, 0, 0, 0, 2883, 2718, 1, 0, 0, 0, 2883,
|
|
2723, 1, 0, 0, 0, 2883, 2735, 1, 0, 0, 0, 2883, 2747, 1, 0, 0, 0, 2883,
|
|
2753, 1, 0, 0, 0, 2883, 2758, 1, 0, 0, 0, 2883, 2769, 1, 0, 0, 0, 2883,
|
|
2777, 1, 0, 0, 0, 2883, 2780, 1, 0, 0, 0, 2883, 2783, 1, 0, 0, 0, 2883,
|
|
2786, 1, 0, 0, 0, 2883, 2792, 1, 0, 0, 0, 2883, 2812, 1, 0, 0, 0, 2883,
|
|
2817, 1, 0, 0, 0, 2883, 2821, 1, 0, 0, 0, 2883, 2823, 1, 0, 0, 0, 2883,
|
|
2825, 1, 0, 0, 0, 2883, 2833, 1, 0, 0, 0, 2883, 2836, 1, 0, 0, 0, 2883,
|
|
2849, 1, 0, 0, 0, 2883, 2860, 1, 0, 0, 0, 2883, 2862, 1, 0, 0, 0, 2883,
|
|
2864, 1, 0, 0, 0, 2883, 2865, 1, 0, 0, 0, 2883, 2867, 1, 0, 0, 0, 2883,
|
|
2882, 1, 0, 0, 0, 2884, 149, 1, 0, 0, 0, 2885, 2886, 5, 5, 0, 0, 2886,
|
|
2887, 5, 129, 0, 0, 2887, 2888, 5, 1133, 0, 0, 2888, 2893, 3, 118, 59,
|
|
0, 2889, 2890, 5, 1135, 0, 0, 2890, 2892, 3, 118, 59, 0, 2891, 2889, 1,
|
|
0, 0, 0, 2892, 2895, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2893, 2894, 1,
|
|
0, 0, 0, 2894, 2896, 1, 0, 0, 0, 2895, 2893, 1, 0, 0, 0, 2896, 2897, 5,
|
|
1134, 0, 0, 2897, 2984, 1, 0, 0, 0, 2898, 2899, 5, 51, 0, 0, 2899, 2900,
|
|
5, 129, 0, 0, 2900, 2984, 3, 616, 308, 0, 2901, 2902, 5, 397, 0, 0, 2902,
|
|
2905, 5, 129, 0, 0, 2903, 2906, 3, 616, 308, 0, 2904, 2906, 5, 6, 0, 0,
|
|
2905, 2903, 1, 0, 0, 0, 2905, 2904, 1, 0, 0, 0, 2906, 2907, 1, 0, 0, 0,
|
|
2907, 2984, 5, 647, 0, 0, 2908, 2909, 5, 450, 0, 0, 2909, 2912, 5, 129,
|
|
0, 0, 2910, 2913, 3, 616, 308, 0, 2911, 2913, 5, 6, 0, 0, 2912, 2910, 1,
|
|
0, 0, 0, 2912, 2911, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, 0, 2914, 2984, 5,
|
|
647, 0, 0, 2915, 2916, 5, 656, 0, 0, 2916, 2919, 5, 129, 0, 0, 2917, 2920,
|
|
3, 616, 308, 0, 2918, 2920, 5, 6, 0, 0, 2919, 2917, 1, 0, 0, 0, 2919, 2918,
|
|
1, 0, 0, 0, 2920, 2984, 1, 0, 0, 0, 2921, 2922, 5, 363, 0, 0, 2922, 2923,
|
|
5, 129, 0, 0, 2923, 2984, 3, 590, 295, 0, 2924, 2925, 5, 579, 0, 0, 2925,
|
|
2926, 5, 129, 0, 0, 2926, 2927, 3, 616, 308, 0, 2927, 2928, 5, 87, 0, 0,
|
|
2928, 2929, 5, 1133, 0, 0, 2929, 2934, 3, 118, 59, 0, 2930, 2931, 5, 1135,
|
|
0, 0, 2931, 2933, 3, 118, 59, 0, 2932, 2930, 1, 0, 0, 0, 2933, 2936, 1,
|
|
0, 0, 0, 2934, 2932, 1, 0, 0, 0, 2934, 2935, 1, 0, 0, 0, 2935, 2937, 1,
|
|
0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2937, 2938, 5, 1134, 0, 0, 2938, 2984,
|
|
1, 0, 0, 0, 2939, 2940, 5, 418, 0, 0, 2940, 2941, 5, 129, 0, 0, 2941, 2942,
|
|
3, 584, 292, 0, 2942, 2943, 5, 192, 0, 0, 2943, 2944, 5, 172, 0, 0, 2944,
|
|
2947, 3, 552, 276, 0, 2945, 2946, 7, 37, 0, 0, 2946, 2948, 5, 668, 0, 0,
|
|
2947, 2945, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, 2948, 2984, 1, 0, 0, 0,
|
|
2949, 2950, 5, 9, 0, 0, 2950, 2953, 5, 129, 0, 0, 2951, 2954, 3, 616, 308,
|
|
0, 2952, 2954, 5, 6, 0, 0, 2953, 2951, 1, 0, 0, 0, 2953, 2952, 1, 0, 0,
|
|
0, 2954, 2984, 1, 0, 0, 0, 2955, 2956, 5, 26, 0, 0, 2956, 2959, 5, 129,
|
|
0, 0, 2957, 2960, 3, 616, 308, 0, 2958, 2960, 5, 6, 0, 0, 2959, 2957, 1,
|
|
0, 0, 0, 2959, 2958, 1, 0, 0, 0, 2960, 2984, 1, 0, 0, 0, 2961, 2962, 5,
|
|
119, 0, 0, 2962, 2965, 5, 129, 0, 0, 2963, 2966, 3, 616, 308, 0, 2964,
|
|
2966, 5, 6, 0, 0, 2965, 2963, 1, 0, 0, 0, 2965, 2964, 1, 0, 0, 0, 2966,
|
|
2984, 1, 0, 0, 0, 2967, 2968, 5, 569, 0, 0, 2968, 2971, 5, 129, 0, 0, 2969,
|
|
2972, 3, 616, 308, 0, 2970, 2972, 5, 6, 0, 0, 2971, 2969, 1, 0, 0, 0, 2971,
|
|
2970, 1, 0, 0, 0, 2972, 2984, 1, 0, 0, 0, 2973, 2974, 5, 580, 0, 0, 2974,
|
|
2977, 5, 129, 0, 0, 2975, 2978, 3, 616, 308, 0, 2976, 2978, 5, 6, 0, 0,
|
|
2977, 2975, 1, 0, 0, 0, 2977, 2976, 1, 0, 0, 0, 2978, 2984, 1, 0, 0, 0,
|
|
2979, 2980, 5, 578, 0, 0, 2980, 2984, 5, 549, 0, 0, 2981, 2982, 5, 664,
|
|
0, 0, 2982, 2984, 5, 549, 0, 0, 2983, 2885, 1, 0, 0, 0, 2983, 2898, 1,
|
|
0, 0, 0, 2983, 2901, 1, 0, 0, 0, 2983, 2908, 1, 0, 0, 0, 2983, 2915, 1,
|
|
0, 0, 0, 2983, 2921, 1, 0, 0, 0, 2983, 2924, 1, 0, 0, 0, 2983, 2939, 1,
|
|
0, 0, 0, 2983, 2949, 1, 0, 0, 0, 2983, 2955, 1, 0, 0, 0, 2983, 2961, 1,
|
|
0, 0, 0, 2983, 2967, 1, 0, 0, 0, 2983, 2973, 1, 0, 0, 0, 2983, 2979, 1,
|
|
0, 0, 0, 2983, 2981, 1, 0, 0, 0, 2984, 151, 1, 0, 0, 0, 2985, 2986, 5,
|
|
51, 0, 0, 2986, 2988, 7, 0, 0, 0, 2987, 2989, 3, 640, 320, 0, 2988, 2987,
|
|
1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 2991,
|
|
3, 584, 292, 0, 2991, 153, 1, 0, 0, 0, 2992, 2993, 5, 51, 0, 0, 2993, 2995,
|
|
5, 415, 0, 0, 2994, 2996, 3, 640, 320, 0, 2995, 2994, 1, 0, 0, 0, 2995,
|
|
2996, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, 2998, 3, 550, 275, 0, 2998,
|
|
155, 1, 0, 0, 0, 2999, 3000, 5, 51, 0, 0, 3000, 3002, 5, 81, 0, 0, 3001,
|
|
3003, 7, 1, 0, 0, 3002, 3001, 1, 0, 0, 0, 3002, 3003, 1, 0, 0, 0, 3003,
|
|
3004, 1, 0, 0, 0, 3004, 3005, 3, 584, 292, 0, 3005, 3006, 5, 118, 0, 0,
|
|
3006, 3019, 3, 552, 276, 0, 3007, 3009, 5, 336, 0, 0, 3008, 3010, 5, 1124,
|
|
0, 0, 3009, 3008, 1, 0, 0, 0, 3009, 3010, 1, 0, 0, 0, 3010, 3011, 1, 0,
|
|
0, 0, 3011, 3018, 7, 3, 0, 0, 3012, 3014, 5, 103, 0, 0, 3013, 3015, 5,
|
|
1124, 0, 0, 3014, 3013, 1, 0, 0, 0, 3014, 3015, 1, 0, 0, 0, 3015, 3016,
|
|
1, 0, 0, 0, 3016, 3018, 7, 4, 0, 0, 3017, 3007, 1, 0, 0, 0, 3017, 3012,
|
|
1, 0, 0, 0, 3018, 3021, 1, 0, 0, 0, 3019, 3017, 1, 0, 0, 0, 3019, 3020,
|
|
1, 0, 0, 0, 3020, 157, 1, 0, 0, 0, 3021, 3019, 1, 0, 0, 0, 3022, 3023,
|
|
5, 51, 0, 0, 3023, 3024, 5, 475, 0, 0, 3024, 3025, 5, 73, 0, 0, 3025, 3026,
|
|
3, 584, 292, 0, 3026, 3027, 5, 409, 0, 0, 3027, 3028, 5, 1124, 0, 0, 3028,
|
|
3029, 3, 572, 286, 0, 3029, 159, 1, 0, 0, 0, 3030, 3031, 5, 51, 0, 0, 3031,
|
|
3033, 5, 131, 0, 0, 3032, 3034, 3, 640, 320, 0, 3033, 3032, 1, 0, 0, 0,
|
|
3033, 3034, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 3036, 3, 550, 275,
|
|
0, 3036, 161, 1, 0, 0, 0, 3037, 3038, 5, 51, 0, 0, 3038, 3040, 5, 437,
|
|
0, 0, 3039, 3041, 3, 640, 320, 0, 3040, 3039, 1, 0, 0, 0, 3040, 3041, 1,
|
|
0, 0, 0, 3041, 3042, 1, 0, 0, 0, 3042, 3043, 3, 550, 275, 0, 3043, 163,
|
|
1, 0, 0, 0, 3044, 3045, 5, 51, 0, 0, 3045, 3047, 5, 608, 0, 0, 3046, 3048,
|
|
3, 640, 320, 0, 3047, 3046, 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 3049,
|
|
1, 0, 0, 0, 3049, 3050, 3, 584, 292, 0, 3050, 165, 1, 0, 0, 0, 3051, 3053,
|
|
5, 51, 0, 0, 3052, 3054, 5, 649, 0, 0, 3053, 3052, 1, 0, 0, 0, 3053, 3054,
|
|
1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3057, 5, 172, 0, 0, 3056, 3058,
|
|
3, 640, 320, 0, 3057, 3056, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 3059,
|
|
1, 0, 0, 0, 3059, 3061, 3, 620, 310, 0, 3060, 3062, 7, 38, 0, 0, 3061,
|
|
3060, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 167, 1, 0, 0, 0, 3063,
|
|
3064, 5, 51, 0, 0, 3064, 3065, 5, 647, 0, 0, 3065, 3071, 3, 584, 292, 0,
|
|
3066, 3068, 5, 409, 0, 0, 3067, 3069, 5, 1124, 0, 0, 3068, 3067, 1, 0,
|
|
0, 0, 3068, 3069, 1, 0, 0, 0, 3069, 3070, 1, 0, 0, 0, 3070, 3072, 3, 572,
|
|
286, 0, 3071, 3066, 1, 0, 0, 0, 3071, 3072, 1, 0, 0, 0, 3072, 169, 1, 0,
|
|
0, 0, 3073, 3074, 5, 51, 0, 0, 3074, 3076, 5, 177, 0, 0, 3075, 3077, 3,
|
|
640, 320, 0, 3076, 3075, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3078,
|
|
1, 0, 0, 0, 3078, 3079, 3, 550, 275, 0, 3079, 171, 1, 0, 0, 0, 3080, 3081,
|
|
5, 51, 0, 0, 3081, 3083, 5, 671, 0, 0, 3082, 3084, 3, 640, 320, 0, 3083,
|
|
3082, 1, 0, 0, 0, 3083, 3084, 1, 0, 0, 0, 3084, 3085, 1, 0, 0, 0, 3085,
|
|
3090, 3, 550, 275, 0, 3086, 3087, 5, 1135, 0, 0, 3087, 3089, 3, 550, 275,
|
|
0, 3088, 3086, 1, 0, 0, 0, 3089, 3092, 1, 0, 0, 0, 3090, 3088, 1, 0, 0,
|
|
0, 3090, 3091, 1, 0, 0, 0, 3091, 3094, 1, 0, 0, 0, 3092, 3090, 1, 0, 0,
|
|
0, 3093, 3095, 7, 38, 0, 0, 3094, 3093, 1, 0, 0, 0, 3094, 3095, 1, 0, 0,
|
|
0, 3095, 173, 1, 0, 0, 0, 3096, 3097, 5, 51, 0, 0, 3097, 3099, 5, 596,
|
|
0, 0, 3098, 3100, 3, 640, 320, 0, 3099, 3098, 1, 0, 0, 0, 3099, 3100, 1,
|
|
0, 0, 0, 3100, 3101, 1, 0, 0, 0, 3101, 3106, 3, 554, 277, 0, 3102, 3103,
|
|
5, 1135, 0, 0, 3103, 3105, 3, 554, 277, 0, 3104, 3102, 1, 0, 0, 0, 3105,
|
|
3108, 1, 0, 0, 0, 3106, 3104, 1, 0, 0, 0, 3106, 3107, 1, 0, 0, 0, 3107,
|
|
175, 1, 0, 0, 0, 3108, 3106, 1, 0, 0, 0, 3109, 3110, 5, 153, 0, 0, 3110,
|
|
3111, 5, 42, 0, 0, 3111, 3122, 5, 596, 0, 0, 3112, 3123, 5, 529, 0, 0,
|
|
3113, 3123, 5, 6, 0, 0, 3114, 3119, 3, 554, 277, 0, 3115, 3116, 5, 1135,
|
|
0, 0, 3116, 3118, 3, 554, 277, 0, 3117, 3115, 1, 0, 0, 0, 3118, 3121, 1,
|
|
0, 0, 0, 3119, 3117, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 3123, 1,
|
|
0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3122, 3112, 1, 0, 0, 0, 3122, 3113, 1,
|
|
0, 0, 0, 3122, 3114, 1, 0, 0, 0, 3123, 3124, 1, 0, 0, 0, 3124, 3127, 5,
|
|
175, 0, 0, 3125, 3128, 3, 564, 282, 0, 3126, 3128, 3, 584, 292, 0, 3127,
|
|
3125, 1, 0, 0, 0, 3127, 3126, 1, 0, 0, 0, 3128, 3136, 1, 0, 0, 0, 3129,
|
|
3132, 5, 1135, 0, 0, 3130, 3133, 3, 564, 282, 0, 3131, 3133, 3, 584, 292,
|
|
0, 3132, 3130, 1, 0, 0, 0, 3132, 3131, 1, 0, 0, 0, 3133, 3135, 1, 0, 0,
|
|
0, 3134, 3129, 1, 0, 0, 0, 3135, 3138, 1, 0, 0, 0, 3136, 3134, 1, 0, 0,
|
|
0, 3136, 3137, 1, 0, 0, 0, 3137, 3143, 1, 0, 0, 0, 3138, 3136, 1, 0, 0,
|
|
0, 3139, 3140, 5, 153, 0, 0, 3140, 3141, 5, 596, 0, 0, 3141, 3143, 3, 434,
|
|
217, 0, 3142, 3109, 1, 0, 0, 0, 3142, 3139, 1, 0, 0, 0, 3143, 177, 1, 0,
|
|
0, 0, 3144, 3145, 5, 139, 0, 0, 3145, 3146, 5, 172, 0, 0, 3146, 3151, 3,
|
|
180, 90, 0, 3147, 3148, 5, 1135, 0, 0, 3148, 3150, 3, 180, 90, 0, 3149,
|
|
3147, 1, 0, 0, 0, 3150, 3153, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3151,
|
|
3152, 1, 0, 0, 0, 3152, 179, 1, 0, 0, 0, 3153, 3151, 1, 0, 0, 0, 3154,
|
|
3155, 3, 552, 276, 0, 3155, 3156, 5, 175, 0, 0, 3156, 3157, 3, 552, 276,
|
|
0, 3157, 181, 1, 0, 0, 0, 3158, 3160, 5, 656, 0, 0, 3159, 3161, 5, 172,
|
|
0, 0, 3160, 3159, 1, 0, 0, 0, 3160, 3161, 1, 0, 0, 0, 3161, 3162, 1, 0,
|
|
0, 0, 3162, 3163, 3, 552, 276, 0, 3163, 183, 1, 0, 0, 0, 3164, 3165, 5,
|
|
20, 0, 0, 3165, 3172, 3, 550, 275, 0, 3166, 3169, 5, 1133, 0, 0, 3167,
|
|
3170, 3, 628, 314, 0, 3168, 3170, 3, 624, 312, 0, 3169, 3167, 1, 0, 0,
|
|
0, 3169, 3168, 1, 0, 0, 0, 3169, 3170, 1, 0, 0, 0, 3170, 3171, 1, 0, 0,
|
|
0, 3171, 3173, 5, 1134, 0, 0, 3172, 3166, 1, 0, 0, 0, 3172, 3173, 1, 0,
|
|
0, 0, 3173, 185, 1, 0, 0, 0, 3174, 3177, 3, 214, 107, 0, 3175, 3177, 3,
|
|
216, 108, 0, 3176, 3174, 1, 0, 0, 0, 3176, 3175, 1, 0, 0, 0, 3177, 187,
|
|
1, 0, 0, 0, 3178, 3179, 5, 399, 0, 0, 3179, 3180, 3, 624, 312, 0, 3180,
|
|
189, 1, 0, 0, 0, 3181, 3186, 3, 218, 109, 0, 3182, 3186, 3, 220, 110, 0,
|
|
3183, 3186, 3, 222, 111, 0, 3184, 3186, 3, 224, 112, 0, 3185, 3181, 1,
|
|
0, 0, 0, 3185, 3182, 1, 0, 0, 0, 3185, 3183, 1, 0, 0, 0, 3185, 3184, 1,
|
|
0, 0, 0, 3186, 191, 1, 0, 0, 0, 3187, 3189, 5, 85, 0, 0, 3188, 3190, 7,
|
|
39, 0, 0, 3189, 3188, 1, 0, 0, 0, 3189, 3190, 1, 0, 0, 0, 3190, 3192, 1,
|
|
0, 0, 0, 3191, 3193, 5, 78, 0, 0, 3192, 3191, 1, 0, 0, 0, 3192, 3193, 1,
|
|
0, 0, 0, 3193, 3195, 1, 0, 0, 0, 3194, 3196, 5, 87, 0, 0, 3195, 3194, 1,
|
|
0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3197, 1, 0, 0, 0, 3197, 3204, 3,
|
|
552, 276, 0, 3198, 3199, 5, 129, 0, 0, 3199, 3201, 5, 1133, 0, 0, 3200,
|
|
3202, 3, 616, 308, 0, 3201, 3200, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202,
|
|
3203, 1, 0, 0, 0, 3203, 3205, 5, 1134, 0, 0, 3204, 3198, 1, 0, 0, 0, 3204,
|
|
3205, 1, 0, 0, 0, 3205, 3229, 1, 0, 0, 0, 3206, 3208, 5, 1133, 0, 0, 3207,
|
|
3209, 3, 618, 309, 0, 3208, 3207, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209,
|
|
3210, 1, 0, 0, 0, 3210, 3212, 5, 1134, 0, 0, 3211, 3206, 1, 0, 0, 0, 3211,
|
|
3212, 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, 3218, 3, 206, 103, 0, 3214,
|
|
3216, 5, 12, 0, 0, 3215, 3214, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216,
|
|
3217, 1, 0, 0, 0, 3217, 3219, 3, 584, 292, 0, 3218, 3215, 1, 0, 0, 0, 3218,
|
|
3219, 1, 0, 0, 0, 3219, 3230, 1, 0, 0, 0, 3220, 3221, 5, 153, 0, 0, 3221,
|
|
3226, 3, 208, 104, 0, 3222, 3223, 5, 1135, 0, 0, 3223, 3225, 3, 208, 104,
|
|
0, 3224, 3222, 1, 0, 0, 0, 3225, 3228, 1, 0, 0, 0, 3226, 3224, 1, 0, 0,
|
|
0, 3226, 3227, 1, 0, 0, 0, 3227, 3230, 1, 0, 0, 0, 3228, 3226, 1, 0, 0,
|
|
0, 3229, 3211, 1, 0, 0, 0, 3229, 3220, 1, 0, 0, 0, 3230, 3243, 1, 0, 0,
|
|
0, 3231, 3232, 5, 118, 0, 0, 3232, 3233, 5, 401, 0, 0, 3233, 3234, 5, 91,
|
|
0, 0, 3234, 3235, 5, 184, 0, 0, 3235, 3240, 3, 208, 104, 0, 3236, 3237,
|
|
5, 1135, 0, 0, 3237, 3239, 3, 208, 104, 0, 3238, 3236, 1, 0, 0, 0, 3239,
|
|
3242, 1, 0, 0, 0, 3240, 3238, 1, 0, 0, 0, 3240, 3241, 1, 0, 0, 0, 3241,
|
|
3244, 1, 0, 0, 0, 3242, 3240, 1, 0, 0, 0, 3243, 3231, 1, 0, 0, 0, 3243,
|
|
3244, 1, 0, 0, 0, 3244, 193, 1, 0, 0, 0, 3245, 3246, 5, 102, 0, 0, 3246,
|
|
3248, 5, 388, 0, 0, 3247, 3249, 7, 40, 0, 0, 3248, 3247, 1, 0, 0, 0, 3248,
|
|
3249, 1, 0, 0, 0, 3249, 3251, 1, 0, 0, 0, 3250, 3252, 5, 474, 0, 0, 3251,
|
|
3250, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 3253, 1, 0, 0, 0, 3253,
|
|
3254, 5, 82, 0, 0, 3254, 3256, 5, 1148, 0, 0, 3255, 3257, 7, 6, 0, 0, 3256,
|
|
3255, 1, 0, 0, 0, 3256, 3257, 1, 0, 0, 0, 3257, 3258, 1, 0, 0, 0, 3258,
|
|
3259, 5, 87, 0, 0, 3259, 3260, 5, 172, 0, 0, 3260, 3266, 3, 552, 276, 0,
|
|
3261, 3262, 5, 129, 0, 0, 3262, 3263, 5, 1133, 0, 0, 3263, 3264, 3, 616,
|
|
308, 0, 3264, 3265, 5, 1134, 0, 0, 3265, 3267, 1, 0, 0, 0, 3266, 3261,
|
|
1, 0, 0, 0, 3266, 3267, 1, 0, 0, 0, 3267, 3271, 1, 0, 0, 0, 3268, 3269,
|
|
5, 25, 0, 0, 3269, 3270, 5, 153, 0, 0, 3270, 3272, 3, 568, 284, 0, 3271,
|
|
3268, 1, 0, 0, 0, 3271, 3272, 1, 0, 0, 0, 3272, 3279, 1, 0, 0, 0, 3273,
|
|
3275, 7, 41, 0, 0, 3274, 3276, 3, 280, 140, 0, 3275, 3274, 1, 0, 0, 0,
|
|
3276, 3277, 1, 0, 0, 0, 3277, 3275, 1, 0, 0, 0, 3277, 3278, 1, 0, 0, 0,
|
|
3278, 3280, 1, 0, 0, 0, 3279, 3273, 1, 0, 0, 0, 3279, 3280, 1, 0, 0, 0,
|
|
3280, 3287, 1, 0, 0, 0, 3281, 3283, 5, 101, 0, 0, 3282, 3284, 3, 282, 141,
|
|
0, 3283, 3282, 1, 0, 0, 0, 3284, 3285, 1, 0, 0, 0, 3285, 3283, 1, 0, 0,
|
|
0, 3285, 3286, 1, 0, 0, 0, 3286, 3288, 1, 0, 0, 0, 3287, 3281, 1, 0, 0,
|
|
0, 3287, 3288, 1, 0, 0, 0, 3288, 3293, 1, 0, 0, 0, 3289, 3290, 5, 78, 0,
|
|
0, 3290, 3291, 3, 590, 295, 0, 3291, 3292, 7, 42, 0, 0, 3292, 3294, 1,
|
|
0, 0, 0, 3293, 3289, 1, 0, 0, 0, 3293, 3294, 1, 0, 0, 0, 3294, 3306, 1,
|
|
0, 0, 0, 3295, 3296, 5, 1133, 0, 0, 3296, 3301, 3, 210, 105, 0, 3297, 3298,
|
|
5, 1135, 0, 0, 3298, 3300, 3, 210, 105, 0, 3299, 3297, 1, 0, 0, 0, 3300,
|
|
3303, 1, 0, 0, 0, 3301, 3299, 1, 0, 0, 0, 3301, 3302, 1, 0, 0, 0, 3302,
|
|
3304, 1, 0, 0, 0, 3303, 3301, 1, 0, 0, 0, 3304, 3305, 5, 1134, 0, 0, 3305,
|
|
3307, 1, 0, 0, 0, 3306, 3295, 1, 0, 0, 0, 3306, 3307, 1, 0, 0, 0, 3307,
|
|
3317, 1, 0, 0, 0, 3308, 3309, 5, 153, 0, 0, 3309, 3314, 3, 208, 104, 0,
|
|
3310, 3311, 5, 1135, 0, 0, 3311, 3313, 3, 208, 104, 0, 3312, 3310, 1, 0,
|
|
0, 0, 3313, 3316, 1, 0, 0, 0, 3314, 3312, 1, 0, 0, 0, 3314, 3315, 1, 0,
|
|
0, 0, 3315, 3318, 1, 0, 0, 0, 3316, 3314, 1, 0, 0, 0, 3317, 3308, 1, 0,
|
|
0, 0, 3317, 3318, 1, 0, 0, 0, 3318, 195, 1, 0, 0, 0, 3319, 3320, 5, 102,
|
|
0, 0, 3320, 3322, 5, 682, 0, 0, 3321, 3323, 7, 40, 0, 0, 3322, 3321, 1,
|
|
0, 0, 0, 3322, 3323, 1, 0, 0, 0, 3323, 3325, 1, 0, 0, 0, 3324, 3326, 5,
|
|
474, 0, 0, 3325, 3324, 1, 0, 0, 0, 3325, 3326, 1, 0, 0, 0, 3326, 3327,
|
|
1, 0, 0, 0, 3327, 3328, 5, 82, 0, 0, 3328, 3330, 5, 1148, 0, 0, 3329, 3331,
|
|
7, 6, 0, 0, 3330, 3329, 1, 0, 0, 0, 3330, 3331, 1, 0, 0, 0, 3331, 3332,
|
|
1, 0, 0, 0, 3332, 3333, 5, 87, 0, 0, 3333, 3334, 5, 172, 0, 0, 3334, 3338,
|
|
3, 552, 276, 0, 3335, 3336, 5, 25, 0, 0, 3336, 3337, 5, 153, 0, 0, 3337,
|
|
3339, 3, 568, 284, 0, 3338, 3335, 1, 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339,
|
|
3346, 1, 0, 0, 0, 3340, 3341, 5, 601, 0, 0, 3341, 3342, 5, 448, 0, 0, 3342,
|
|
3343, 5, 19, 0, 0, 3343, 3344, 5, 1126, 0, 0, 3344, 3345, 5, 1148, 0, 0,
|
|
3345, 3347, 5, 1125, 0, 0, 3346, 3340, 1, 0, 0, 0, 3346, 3347, 1, 0, 0,
|
|
0, 3347, 3352, 1, 0, 0, 0, 3348, 3349, 5, 78, 0, 0, 3349, 3350, 3, 590,
|
|
295, 0, 3350, 3351, 7, 42, 0, 0, 3351, 3353, 1, 0, 0, 0, 3352, 3348, 1,
|
|
0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 3365, 1, 0, 0, 0, 3354, 3355, 5,
|
|
1133, 0, 0, 3355, 3360, 3, 210, 105, 0, 3356, 3357, 5, 1135, 0, 0, 3357,
|
|
3359, 3, 210, 105, 0, 3358, 3356, 1, 0, 0, 0, 3359, 3362, 1, 0, 0, 0, 3360,
|
|
3358, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 3363, 1, 0, 0, 0, 3362,
|
|
3360, 1, 0, 0, 0, 3363, 3364, 5, 1134, 0, 0, 3364, 3366, 1, 0, 0, 0, 3365,
|
|
3354, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 3376, 1, 0, 0, 0, 3367,
|
|
3368, 5, 153, 0, 0, 3368, 3373, 3, 208, 104, 0, 3369, 3370, 5, 1135, 0,
|
|
0, 3370, 3372, 3, 208, 104, 0, 3371, 3369, 1, 0, 0, 0, 3372, 3375, 1, 0,
|
|
0, 0, 3373, 3371, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3377, 1, 0,
|
|
0, 0, 3375, 3373, 1, 0, 0, 0, 3376, 3367, 1, 0, 0, 0, 3376, 3377, 1, 0,
|
|
0, 0, 3377, 197, 1, 0, 0, 0, 3378, 3380, 5, 141, 0, 0, 3379, 3381, 7, 43,
|
|
0, 0, 3380, 3379, 1, 0, 0, 0, 3380, 3381, 1, 0, 0, 0, 3381, 3383, 1, 0,
|
|
0, 0, 3382, 3384, 5, 87, 0, 0, 3383, 3382, 1, 0, 0, 0, 3383, 3384, 1, 0,
|
|
0, 0, 3384, 3385, 1, 0, 0, 0, 3385, 3391, 3, 552, 276, 0, 3386, 3387, 5,
|
|
129, 0, 0, 3387, 3388, 5, 1133, 0, 0, 3388, 3389, 3, 616, 308, 0, 3389,
|
|
3390, 5, 1134, 0, 0, 3390, 3392, 1, 0, 0, 0, 3391, 3386, 1, 0, 0, 0, 3391,
|
|
3392, 1, 0, 0, 0, 3392, 3409, 1, 0, 0, 0, 3393, 3394, 5, 1133, 0, 0, 3394,
|
|
3395, 3, 616, 308, 0, 3395, 3396, 5, 1134, 0, 0, 3396, 3398, 1, 0, 0, 0,
|
|
3397, 3393, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0,
|
|
3399, 3410, 3, 206, 103, 0, 3400, 3401, 5, 153, 0, 0, 3401, 3406, 3, 208,
|
|
104, 0, 3402, 3403, 5, 1135, 0, 0, 3403, 3405, 3, 208, 104, 0, 3404, 3402,
|
|
1, 0, 0, 0, 3405, 3408, 1, 0, 0, 0, 3406, 3404, 1, 0, 0, 0, 3406, 3407,
|
|
1, 0, 0, 0, 3407, 3410, 1, 0, 0, 0, 3408, 3406, 1, 0, 0, 0, 3409, 3397,
|
|
1, 0, 0, 0, 3409, 3400, 1, 0, 0, 0, 3410, 199, 1, 0, 0, 0, 3411, 3413,
|
|
3, 252, 126, 0, 3412, 3414, 3, 212, 106, 0, 3413, 3412, 1, 0, 0, 0, 3413,
|
|
3414, 1, 0, 0, 0, 3414, 3477, 1, 0, 0, 0, 3415, 3417, 3, 248, 124, 0, 3416,
|
|
3418, 3, 212, 106, 0, 3417, 3416, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, 0, 3418,
|
|
3477, 1, 0, 0, 0, 3419, 3422, 3, 254, 127, 0, 3420, 3422, 3, 250, 125,
|
|
0, 3421, 3419, 1, 0, 0, 0, 3421, 3420, 1, 0, 0, 0, 3422, 3424, 1, 0, 0,
|
|
0, 3423, 3425, 3, 258, 129, 0, 3424, 3423, 1, 0, 0, 0, 3425, 3426, 1, 0,
|
|
0, 0, 3426, 3424, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3436, 1, 0,
|
|
0, 0, 3428, 3430, 5, 180, 0, 0, 3429, 3431, 7, 44, 0, 0, 3430, 3429, 1,
|
|
0, 0, 0, 3430, 3431, 1, 0, 0, 0, 3431, 3434, 1, 0, 0, 0, 3432, 3435, 3,
|
|
252, 126, 0, 3433, 3435, 3, 248, 124, 0, 3434, 3432, 1, 0, 0, 0, 3434,
|
|
3433, 1, 0, 0, 0, 3435, 3437, 1, 0, 0, 0, 3436, 3428, 1, 0, 0, 0, 3436,
|
|
3437, 1, 0, 0, 0, 3437, 3439, 1, 0, 0, 0, 3438, 3440, 3, 230, 115, 0, 3439,
|
|
3438, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 3442, 1, 0, 0, 0, 3441,
|
|
3443, 3, 294, 147, 0, 3442, 3441, 1, 0, 0, 0, 3442, 3443, 1, 0, 0, 0, 3443,
|
|
3445, 1, 0, 0, 0, 3444, 3446, 3, 212, 106, 0, 3445, 3444, 1, 0, 0, 0, 3445,
|
|
3446, 1, 0, 0, 0, 3446, 3477, 1, 0, 0, 0, 3447, 3449, 3, 250, 125, 0, 3448,
|
|
3450, 3, 256, 128, 0, 3449, 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451,
|
|
3449, 1, 0, 0, 0, 3451, 3452, 1, 0, 0, 0, 3452, 3458, 1, 0, 0, 0, 3453,
|
|
3455, 5, 180, 0, 0, 3454, 3456, 7, 44, 0, 0, 3455, 3454, 1, 0, 0, 0, 3455,
|
|
3456, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 3, 248, 124, 0, 3458,
|
|
3453, 1, 0, 0, 0, 3458, 3459, 1, 0, 0, 0, 3459, 3461, 1, 0, 0, 0, 3460,
|
|
3462, 3, 230, 115, 0, 3461, 3460, 1, 0, 0, 0, 3461, 3462, 1, 0, 0, 0, 3462,
|
|
3464, 1, 0, 0, 0, 3463, 3465, 3, 294, 147, 0, 3464, 3463, 1, 0, 0, 0, 3464,
|
|
3465, 1, 0, 0, 0, 3465, 3467, 1, 0, 0, 0, 3466, 3468, 3, 212, 106, 0, 3467,
|
|
3466, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, 3477, 1, 0, 0, 0, 3469,
|
|
3472, 3, 254, 127, 0, 3470, 3471, 5, 1135, 0, 0, 3471, 3473, 3, 260, 130,
|
|
0, 3472, 3470, 1, 0, 0, 0, 3473, 3474, 1, 0, 0, 0, 3474, 3472, 1, 0, 0,
|
|
0, 3474, 3475, 1, 0, 0, 0, 3475, 3477, 1, 0, 0, 0, 3476, 3411, 1, 0, 0,
|
|
0, 3476, 3415, 1, 0, 0, 0, 3476, 3421, 1, 0, 0, 0, 3476, 3447, 1, 0, 0,
|
|
0, 3476, 3469, 1, 0, 0, 0, 3477, 201, 1, 0, 0, 0, 3478, 3481, 3, 226, 113,
|
|
0, 3479, 3481, 3, 228, 114, 0, 3480, 3478, 1, 0, 0, 0, 3480, 3479, 1, 0,
|
|
0, 0, 3481, 203, 1, 0, 0, 0, 3482, 3483, 5, 188, 0, 0, 3483, 3485, 5, 1133,
|
|
0, 0, 3484, 3486, 3, 626, 313, 0, 3485, 3484, 1, 0, 0, 0, 3485, 3486, 1,
|
|
0, 0, 0, 3486, 3487, 1, 0, 0, 0, 3487, 3496, 5, 1134, 0, 0, 3488, 3489,
|
|
5, 1135, 0, 0, 3489, 3491, 5, 1133, 0, 0, 3490, 3492, 3, 626, 313, 0, 3491,
|
|
3490, 1, 0, 0, 0, 3491, 3492, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493,
|
|
3495, 5, 1134, 0, 0, 3494, 3488, 1, 0, 0, 0, 3495, 3498, 1, 0, 0, 0, 3496,
|
|
3494, 1, 0, 0, 0, 3496, 3497, 1, 0, 0, 0, 3497, 205, 1, 0, 0, 0, 3498,
|
|
3496, 1, 0, 0, 0, 3499, 3518, 3, 200, 100, 0, 3500, 3501, 7, 45, 0, 0,
|
|
3501, 3503, 5, 1133, 0, 0, 3502, 3504, 3, 626, 313, 0, 3503, 3502, 1, 0,
|
|
0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 3514, 5, 1134,
|
|
0, 0, 3506, 3507, 5, 1135, 0, 0, 3507, 3509, 5, 1133, 0, 0, 3508, 3510,
|
|
3, 626, 313, 0, 3509, 3508, 1, 0, 0, 0, 3509, 3510, 1, 0, 0, 0, 3510, 3511,
|
|
1, 0, 0, 0, 3511, 3513, 5, 1134, 0, 0, 3512, 3506, 1, 0, 0, 0, 3513, 3516,
|
|
1, 0, 0, 0, 3514, 3512, 1, 0, 0, 0, 3514, 3515, 1, 0, 0, 0, 3515, 3518,
|
|
1, 0, 0, 0, 3516, 3514, 1, 0, 0, 0, 3517, 3499, 1, 0, 0, 0, 3517, 3500,
|
|
1, 0, 0, 0, 3518, 207, 1, 0, 0, 0, 3519, 3520, 3, 556, 278, 0, 3520, 3523,
|
|
5, 1124, 0, 0, 3521, 3524, 3, 688, 344, 0, 3522, 3524, 5, 42, 0, 0, 3523,
|
|
3521, 1, 0, 0, 0, 3523, 3522, 1, 0, 0, 0, 3524, 209, 1, 0, 0, 0, 3525,
|
|
3528, 3, 584, 292, 0, 3526, 3528, 5, 1159, 0, 0, 3527, 3525, 1, 0, 0, 0,
|
|
3527, 3526, 1, 0, 0, 0, 3528, 211, 1, 0, 0, 0, 3529, 3530, 5, 65, 0, 0,
|
|
3530, 3536, 5, 184, 0, 0, 3531, 3532, 5, 103, 0, 0, 3532, 3533, 5, 80,
|
|
0, 0, 3533, 3534, 5, 610, 0, 0, 3534, 3536, 5, 511, 0, 0, 3535, 3529, 1,
|
|
0, 0, 0, 3535, 3531, 1, 0, 0, 0, 3536, 213, 1, 0, 0, 0, 3537, 3539, 5,
|
|
44, 0, 0, 3538, 3540, 5, 106, 0, 0, 3539, 3538, 1, 0, 0, 0, 3539, 3540,
|
|
1, 0, 0, 0, 3540, 3542, 1, 0, 0, 0, 3541, 3543, 5, 568, 0, 0, 3542, 3541,
|
|
1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3545, 1, 0, 0, 0, 3544, 3546,
|
|
5, 78, 0, 0, 3545, 3544, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3547,
|
|
1, 0, 0, 0, 3547, 3548, 5, 68, 0, 0, 3548, 3553, 3, 552, 276, 0, 3549,
|
|
3551, 5, 12, 0, 0, 3550, 3549, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551,
|
|
3552, 1, 0, 0, 0, 3552, 3554, 3, 584, 292, 0, 3553, 3550, 1, 0, 0, 0, 3553,
|
|
3554, 1, 0, 0, 0, 3554, 3560, 1, 0, 0, 0, 3555, 3556, 5, 129, 0, 0, 3556,
|
|
3557, 5, 1133, 0, 0, 3557, 3558, 3, 616, 308, 0, 3558, 3559, 5, 1134, 0,
|
|
0, 3559, 3561, 1, 0, 0, 0, 3560, 3555, 1, 0, 0, 0, 3560, 3561, 1, 0, 0,
|
|
0, 3561, 3564, 1, 0, 0, 0, 3562, 3563, 5, 190, 0, 0, 3563, 3565, 3, 688,
|
|
344, 0, 3564, 3562, 1, 0, 0, 0, 3564, 3565, 1, 0, 0, 0, 3565, 3567, 1,
|
|
0, 0, 0, 3566, 3568, 3, 230, 115, 0, 3567, 3566, 1, 0, 0, 0, 3567, 3568,
|
|
1, 0, 0, 0, 3568, 3571, 1, 0, 0, 0, 3569, 3570, 5, 99, 0, 0, 3570, 3572,
|
|
3, 296, 148, 0, 3571, 3569, 1, 0, 0, 0, 3571, 3572, 1, 0, 0, 0, 3572, 215,
|
|
1, 0, 0, 0, 3573, 3575, 5, 44, 0, 0, 3574, 3576, 5, 106, 0, 0, 3575, 3574,
|
|
1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 1, 0, 0, 0, 3577, 3579,
|
|
5, 568, 0, 0, 3578, 3577, 1, 0, 0, 0, 3578, 3579, 1, 0, 0, 0, 3579, 3581,
|
|
1, 0, 0, 0, 3580, 3582, 5, 78, 0, 0, 3581, 3580, 1, 0, 0, 0, 3581, 3582,
|
|
1, 0, 0, 0, 3582, 3622, 1, 0, 0, 0, 3583, 3586, 3, 552, 276, 0, 3584, 3585,
|
|
5, 1132, 0, 0, 3585, 3587, 5, 1117, 0, 0, 3586, 3584, 1, 0, 0, 0, 3586,
|
|
3587, 1, 0, 0, 0, 3587, 3596, 1, 0, 0, 0, 3588, 3589, 5, 1135, 0, 0, 3589,
|
|
3592, 3, 552, 276, 0, 3590, 3591, 5, 1132, 0, 0, 3591, 3593, 5, 1117, 0,
|
|
0, 3592, 3590, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 3595, 1, 0, 0,
|
|
0, 3594, 3588, 1, 0, 0, 0, 3595, 3598, 1, 0, 0, 0, 3596, 3594, 1, 0, 0,
|
|
0, 3596, 3597, 1, 0, 0, 0, 3597, 3599, 1, 0, 0, 0, 3598, 3596, 1, 0, 0,
|
|
0, 3599, 3600, 5, 68, 0, 0, 3600, 3601, 3, 234, 117, 0, 3601, 3623, 1,
|
|
0, 0, 0, 3602, 3603, 5, 68, 0, 0, 3603, 3606, 3, 552, 276, 0, 3604, 3605,
|
|
5, 1132, 0, 0, 3605, 3607, 5, 1117, 0, 0, 3606, 3604, 1, 0, 0, 0, 3606,
|
|
3607, 1, 0, 0, 0, 3607, 3616, 1, 0, 0, 0, 3608, 3609, 5, 1135, 0, 0, 3609,
|
|
3612, 3, 552, 276, 0, 3610, 3611, 5, 1132, 0, 0, 3611, 3613, 5, 1117, 0,
|
|
0, 3612, 3610, 1, 0, 0, 0, 3612, 3613, 1, 0, 0, 0, 3613, 3615, 1, 0, 0,
|
|
0, 3614, 3608, 1, 0, 0, 0, 3615, 3618, 1, 0, 0, 0, 3616, 3614, 1, 0, 0,
|
|
0, 3616, 3617, 1, 0, 0, 0, 3617, 3619, 1, 0, 0, 0, 3618, 3616, 1, 0, 0,
|
|
0, 3619, 3620, 5, 187, 0, 0, 3620, 3621, 3, 234, 117, 0, 3621, 3623, 1,
|
|
0, 0, 0, 3622, 3583, 1, 0, 0, 0, 3622, 3602, 1, 0, 0, 0, 3623, 3626, 1,
|
|
0, 0, 0, 3624, 3625, 5, 190, 0, 0, 3625, 3627, 3, 688, 344, 0, 3626, 3624,
|
|
1, 0, 0, 0, 3626, 3627, 1, 0, 0, 0, 3627, 217, 1, 0, 0, 0, 3628, 3629,
|
|
5, 442, 0, 0, 3629, 3630, 3, 552, 276, 0, 3630, 3635, 5, 539, 0, 0, 3631,
|
|
3633, 5, 12, 0, 0, 3632, 3631, 1, 0, 0, 0, 3632, 3633, 1, 0, 0, 0, 3633,
|
|
3634, 1, 0, 0, 0, 3634, 3636, 3, 584, 292, 0, 3635, 3632, 1, 0, 0, 0, 3635,
|
|
3636, 1, 0, 0, 0, 3636, 219, 1, 0, 0, 0, 3637, 3638, 5, 442, 0, 0, 3638,
|
|
3639, 3, 552, 276, 0, 3639, 3640, 5, 134, 0, 0, 3640, 3647, 3, 584, 292,
|
|
0, 3641, 3642, 3, 696, 348, 0, 3642, 3643, 5, 1133, 0, 0, 3643, 3644, 3,
|
|
628, 314, 0, 3644, 3645, 5, 1134, 0, 0, 3645, 3648, 1, 0, 0, 0, 3646, 3648,
|
|
7, 46, 0, 0, 3647, 3641, 1, 0, 0, 0, 3647, 3646, 1, 0, 0, 0, 3648, 3651,
|
|
1, 0, 0, 0, 3649, 3650, 5, 190, 0, 0, 3650, 3652, 3, 688, 344, 0, 3651,
|
|
3649, 1, 0, 0, 0, 3651, 3652, 1, 0, 0, 0, 3652, 3655, 1, 0, 0, 0, 3653,
|
|
3654, 5, 99, 0, 0, 3654, 3656, 3, 296, 148, 0, 3655, 3653, 1, 0, 0, 0,
|
|
3655, 3656, 1, 0, 0, 0, 3656, 221, 1, 0, 0, 0, 3657, 3658, 5, 442, 0, 0,
|
|
3658, 3659, 3, 552, 276, 0, 3659, 3660, 5, 134, 0, 0, 3660, 3663, 7, 47,
|
|
0, 0, 3661, 3662, 5, 190, 0, 0, 3662, 3664, 3, 688, 344, 0, 3663, 3661,
|
|
1, 0, 0, 0, 3663, 3664, 1, 0, 0, 0, 3664, 3667, 1, 0, 0, 0, 3665, 3666,
|
|
5, 99, 0, 0, 3666, 3668, 3, 296, 148, 0, 3667, 3665, 1, 0, 0, 0, 3667,
|
|
3668, 1, 0, 0, 0, 3668, 223, 1, 0, 0, 0, 3669, 3670, 5, 442, 0, 0, 3670,
|
|
3671, 3, 552, 276, 0, 3671, 3672, 5, 361, 0, 0, 3672, 225, 1, 0, 0, 0,
|
|
3673, 3675, 5, 184, 0, 0, 3674, 3676, 5, 106, 0, 0, 3675, 3674, 1, 0, 0,
|
|
0, 3675, 3676, 1, 0, 0, 0, 3676, 3678, 1, 0, 0, 0, 3677, 3679, 5, 78, 0,
|
|
0, 3678, 3677, 1, 0, 0, 0, 3678, 3679, 1, 0, 0, 0, 3679, 3680, 1, 0, 0,
|
|
0, 3680, 3685, 3, 552, 276, 0, 3681, 3683, 5, 12, 0, 0, 3682, 3681, 1,
|
|
0, 0, 0, 3682, 3683, 1, 0, 0, 0, 3683, 3684, 1, 0, 0, 0, 3684, 3686, 3,
|
|
584, 292, 0, 3685, 3682, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3687,
|
|
1, 0, 0, 0, 3687, 3688, 5, 153, 0, 0, 3688, 3693, 3, 208, 104, 0, 3689,
|
|
3690, 5, 1135, 0, 0, 3690, 3692, 3, 208, 104, 0, 3691, 3689, 1, 0, 0, 0,
|
|
3692, 3695, 1, 0, 0, 0, 3693, 3691, 1, 0, 0, 0, 3693, 3694, 1, 0, 0, 0,
|
|
3694, 3698, 1, 0, 0, 0, 3695, 3693, 1, 0, 0, 0, 3696, 3697, 5, 190, 0,
|
|
0, 3697, 3699, 3, 688, 344, 0, 3698, 3696, 1, 0, 0, 0, 3698, 3699, 1, 0,
|
|
0, 0, 3699, 3701, 1, 0, 0, 0, 3700, 3702, 3, 230, 115, 0, 3701, 3700, 1,
|
|
0, 0, 0, 3701, 3702, 1, 0, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3705, 3,
|
|
294, 147, 0, 3704, 3703, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 227,
|
|
1, 0, 0, 0, 3706, 3708, 5, 184, 0, 0, 3707, 3709, 5, 106, 0, 0, 3708, 3707,
|
|
1, 0, 0, 0, 3708, 3709, 1, 0, 0, 0, 3709, 3711, 1, 0, 0, 0, 3710, 3712,
|
|
5, 78, 0, 0, 3711, 3710, 1, 0, 0, 0, 3711, 3712, 1, 0, 0, 0, 3712, 3713,
|
|
1, 0, 0, 0, 3713, 3714, 3, 234, 117, 0, 3714, 3715, 5, 153, 0, 0, 3715,
|
|
3720, 3, 208, 104, 0, 3716, 3717, 5, 1135, 0, 0, 3717, 3719, 3, 208, 104,
|
|
0, 3718, 3716, 1, 0, 0, 0, 3719, 3722, 1, 0, 0, 0, 3720, 3718, 1, 0, 0,
|
|
0, 3720, 3721, 1, 0, 0, 0, 3721, 3725, 1, 0, 0, 0, 3722, 3720, 1, 0, 0,
|
|
0, 3723, 3724, 5, 190, 0, 0, 3724, 3726, 3, 688, 344, 0, 3725, 3723, 1,
|
|
0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 229, 1, 0, 0, 0, 3727, 3728, 5,
|
|
124, 0, 0, 3728, 3729, 5, 19, 0, 0, 3729, 3734, 3, 232, 116, 0, 3730, 3731,
|
|
5, 1135, 0, 0, 3731, 3733, 3, 232, 116, 0, 3732, 3730, 1, 0, 0, 0, 3733,
|
|
3736, 1, 0, 0, 0, 3734, 3732, 1, 0, 0, 0, 3734, 3735, 1, 0, 0, 0, 3735,
|
|
231, 1, 0, 0, 0, 3736, 3734, 1, 0, 0, 0, 3737, 3739, 3, 688, 344, 0, 3738,
|
|
3740, 7, 48, 0, 0, 3739, 3738, 1, 0, 0, 0, 3739, 3740, 1, 0, 0, 0, 3740,
|
|
233, 1, 0, 0, 0, 3741, 3746, 3, 236, 118, 0, 3742, 3743, 5, 1135, 0, 0,
|
|
3743, 3745, 3, 236, 118, 0, 3744, 3742, 1, 0, 0, 0, 3745, 3748, 1, 0, 0,
|
|
0, 3746, 3744, 1, 0, 0, 0, 3746, 3747, 1, 0, 0, 0, 3747, 235, 1, 0, 0,
|
|
0, 3748, 3746, 1, 0, 0, 0, 3749, 3753, 3, 238, 119, 0, 3750, 3752, 3, 244,
|
|
122, 0, 3751, 3750, 1, 0, 0, 0, 3752, 3755, 1, 0, 0, 0, 3753, 3751, 1,
|
|
0, 0, 0, 3753, 3754, 1, 0, 0, 0, 3754, 3768, 1, 0, 0, 0, 3755, 3753, 1,
|
|
0, 0, 0, 3756, 3757, 5, 1133, 0, 0, 3757, 3761, 3, 238, 119, 0, 3758, 3760,
|
|
3, 244, 122, 0, 3759, 3758, 1, 0, 0, 0, 3760, 3763, 1, 0, 0, 0, 3761, 3759,
|
|
1, 0, 0, 0, 3761, 3762, 1, 0, 0, 0, 3762, 3764, 1, 0, 0, 0, 3763, 3761,
|
|
1, 0, 0, 0, 3764, 3765, 5, 1134, 0, 0, 3765, 3768, 1, 0, 0, 0, 3766, 3768,
|
|
3, 262, 131, 0, 3767, 3749, 1, 0, 0, 0, 3767, 3756, 1, 0, 0, 0, 3767, 3766,
|
|
1, 0, 0, 0, 3768, 237, 1, 0, 0, 0, 3769, 3775, 3, 552, 276, 0, 3770, 3771,
|
|
5, 129, 0, 0, 3771, 3772, 5, 1133, 0, 0, 3772, 3773, 3, 616, 308, 0, 3773,
|
|
3774, 5, 1134, 0, 0, 3774, 3776, 1, 0, 0, 0, 3775, 3770, 1, 0, 0, 0, 3775,
|
|
3776, 1, 0, 0, 0, 3776, 3781, 1, 0, 0, 0, 3777, 3779, 5, 12, 0, 0, 3778,
|
|
3777, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3780, 1, 0, 0, 0, 3780,
|
|
3782, 3, 584, 292, 0, 3781, 3778, 1, 0, 0, 0, 3781, 3782, 1, 0, 0, 0, 3782,
|
|
3791, 1, 0, 0, 0, 3783, 3788, 3, 240, 120, 0, 3784, 3785, 5, 1135, 0, 0,
|
|
3785, 3787, 3, 240, 120, 0, 3786, 3784, 1, 0, 0, 0, 3787, 3790, 1, 0, 0,
|
|
0, 3788, 3786, 1, 0, 0, 0, 3788, 3789, 1, 0, 0, 0, 3789, 3792, 1, 0, 0,
|
|
0, 3790, 3788, 1, 0, 0, 0, 3791, 3783, 1, 0, 0, 0, 3791, 3792, 1, 0, 0,
|
|
0, 3792, 3810, 1, 0, 0, 0, 3793, 3799, 3, 200, 100, 0, 3794, 3795, 5, 1133,
|
|
0, 0, 3795, 3796, 3, 200, 100, 0, 3796, 3797, 5, 1134, 0, 0, 3797, 3799,
|
|
1, 0, 0, 0, 3798, 3793, 1, 0, 0, 0, 3798, 3794, 1, 0, 0, 0, 3799, 3801,
|
|
1, 0, 0, 0, 3800, 3802, 5, 12, 0, 0, 3801, 3800, 1, 0, 0, 0, 3801, 3802,
|
|
1, 0, 0, 0, 3802, 3803, 1, 0, 0, 0, 3803, 3804, 3, 584, 292, 0, 3804, 3810,
|
|
1, 0, 0, 0, 3805, 3806, 5, 1133, 0, 0, 3806, 3807, 3, 234, 117, 0, 3807,
|
|
3808, 5, 1134, 0, 0, 3808, 3810, 1, 0, 0, 0, 3809, 3769, 1, 0, 0, 0, 3809,
|
|
3798, 1, 0, 0, 0, 3809, 3805, 1, 0, 0, 0, 3810, 239, 1, 0, 0, 0, 3811,
|
|
3812, 7, 49, 0, 0, 3812, 3815, 7, 20, 0, 0, 3813, 3814, 5, 65, 0, 0, 3814,
|
|
3816, 3, 242, 121, 0, 3815, 3813, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816,
|
|
3817, 1, 0, 0, 0, 3817, 3818, 5, 1133, 0, 0, 3818, 3819, 3, 616, 308, 0,
|
|
3819, 3820, 5, 1134, 0, 0, 3820, 241, 1, 0, 0, 0, 3821, 3827, 5, 90, 0,
|
|
0, 3822, 3823, 5, 124, 0, 0, 3823, 3827, 5, 19, 0, 0, 3824, 3825, 5, 73,
|
|
0, 0, 3825, 3827, 5, 19, 0, 0, 3826, 3821, 1, 0, 0, 0, 3826, 3822, 1, 0,
|
|
0, 0, 3826, 3824, 1, 0, 0, 0, 3827, 243, 1, 0, 0, 0, 3828, 3830, 7, 50,
|
|
0, 0, 3829, 3828, 1, 0, 0, 0, 3829, 3830, 1, 0, 0, 0, 3830, 3831, 1, 0,
|
|
0, 0, 3831, 3833, 5, 90, 0, 0, 3832, 3834, 5, 94, 0, 0, 3833, 3832, 1,
|
|
0, 0, 0, 3833, 3834, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3835, 3839, 3,
|
|
238, 119, 0, 3836, 3838, 3, 246, 123, 0, 3837, 3836, 1, 0, 0, 0, 3838,
|
|
3841, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3839, 3840, 1, 0, 0, 0, 3840,
|
|
3876, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3842, 3843, 5, 171, 0, 0, 3843,
|
|
3848, 3, 238, 119, 0, 3844, 3845, 5, 118, 0, 0, 3845, 3847, 3, 688, 344,
|
|
0, 3846, 3844, 1, 0, 0, 0, 3847, 3850, 1, 0, 0, 0, 3848, 3846, 1, 0, 0,
|
|
0, 3848, 3849, 1, 0, 0, 0, 3849, 3876, 1, 0, 0, 0, 3850, 3848, 1, 0, 0,
|
|
0, 3851, 3853, 7, 51, 0, 0, 3852, 3854, 5, 126, 0, 0, 3853, 3852, 1, 0,
|
|
0, 0, 3853, 3854, 1, 0, 0, 0, 3854, 3855, 1, 0, 0, 0, 3855, 3857, 5, 90,
|
|
0, 0, 3856, 3858, 5, 94, 0, 0, 3857, 3856, 1, 0, 0, 0, 3857, 3858, 1, 0,
|
|
0, 0, 3858, 3859, 1, 0, 0, 0, 3859, 3863, 3, 238, 119, 0, 3860, 3862, 3,
|
|
246, 123, 0, 3861, 3860, 1, 0, 0, 0, 3862, 3865, 1, 0, 0, 0, 3863, 3861,
|
|
1, 0, 0, 0, 3863, 3864, 1, 0, 0, 0, 3864, 3876, 1, 0, 0, 0, 3865, 3863,
|
|
1, 0, 0, 0, 3866, 3871, 5, 113, 0, 0, 3867, 3869, 7, 51, 0, 0, 3868, 3870,
|
|
5, 126, 0, 0, 3869, 3868, 1, 0, 0, 0, 3869, 3870, 1, 0, 0, 0, 3870, 3872,
|
|
1, 0, 0, 0, 3871, 3867, 1, 0, 0, 0, 3871, 3872, 1, 0, 0, 0, 3872, 3873,
|
|
1, 0, 0, 0, 3873, 3874, 5, 90, 0, 0, 3874, 3876, 3, 238, 119, 0, 3875,
|
|
3829, 1, 0, 0, 0, 3875, 3842, 1, 0, 0, 0, 3875, 3851, 1, 0, 0, 0, 3875,
|
|
3866, 1, 0, 0, 0, 3876, 245, 1, 0, 0, 0, 3877, 3878, 5, 118, 0, 0, 3878,
|
|
3885, 3, 688, 344, 0, 3879, 3880, 5, 187, 0, 0, 3880, 3881, 5, 1133, 0,
|
|
0, 3881, 3882, 3, 616, 308, 0, 3882, 3883, 5, 1134, 0, 0, 3883, 3885, 1,
|
|
0, 0, 0, 3884, 3877, 1, 0, 0, 0, 3884, 3879, 1, 0, 0, 0, 3885, 247, 1,
|
|
0, 0, 0, 3886, 3887, 5, 1133, 0, 0, 3887, 3888, 3, 252, 126, 0, 3888, 3889,
|
|
5, 1134, 0, 0, 3889, 3895, 1, 0, 0, 0, 3890, 3891, 5, 1133, 0, 0, 3891,
|
|
3892, 3, 248, 124, 0, 3892, 3893, 5, 1134, 0, 0, 3893, 3895, 1, 0, 0, 0,
|
|
3894, 3886, 1, 0, 0, 0, 3894, 3890, 1, 0, 0, 0, 3895, 249, 1, 0, 0, 0,
|
|
3896, 3897, 5, 1133, 0, 0, 3897, 3898, 3, 254, 127, 0, 3898, 3899, 5, 1134,
|
|
0, 0, 3899, 3905, 1, 0, 0, 0, 3900, 3901, 5, 1133, 0, 0, 3901, 3902, 3,
|
|
250, 125, 0, 3902, 3903, 5, 1134, 0, 0, 3903, 3905, 1, 0, 0, 0, 3904, 3896,
|
|
1, 0, 0, 0, 3904, 3900, 1, 0, 0, 0, 3905, 251, 1, 0, 0, 0, 3906, 3910,
|
|
5, 152, 0, 0, 3907, 3909, 3, 272, 136, 0, 3908, 3907, 1, 0, 0, 0, 3909,
|
|
3912, 1, 0, 0, 0, 3910, 3908, 1, 0, 0, 0, 3910, 3911, 1, 0, 0, 0, 3911,
|
|
3913, 1, 0, 0, 0, 3912, 3910, 1, 0, 0, 0, 3913, 3915, 3, 274, 137, 0, 3914,
|
|
3916, 3, 278, 139, 0, 3915, 3914, 1, 0, 0, 0, 3915, 3916, 1, 0, 0, 0, 3916,
|
|
3917, 1, 0, 0, 0, 3917, 3919, 3, 284, 142, 0, 3918, 3920, 3, 286, 143,
|
|
0, 3919, 3918, 1, 0, 0, 0, 3919, 3920, 1, 0, 0, 0, 3920, 3922, 1, 0, 0,
|
|
0, 3921, 3923, 3, 288, 144, 0, 3922, 3921, 1, 0, 0, 0, 3922, 3923, 1, 0,
|
|
0, 0, 3923, 3925, 1, 0, 0, 0, 3924, 3926, 3, 290, 145, 0, 3925, 3924, 1,
|
|
0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3928, 1, 0, 0, 0, 3927, 3929, 3,
|
|
230, 115, 0, 3928, 3927, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, 0, 3929, 3931,
|
|
1, 0, 0, 0, 3930, 3932, 3, 294, 147, 0, 3931, 3930, 1, 0, 0, 0, 3931, 3932,
|
|
1, 0, 0, 0, 3932, 3961, 1, 0, 0, 0, 3933, 3937, 5, 152, 0, 0, 3934, 3936,
|
|
3, 272, 136, 0, 3935, 3934, 1, 0, 0, 0, 3936, 3939, 1, 0, 0, 0, 3937, 3935,
|
|
1, 0, 0, 0, 3937, 3938, 1, 0, 0, 0, 3938, 3940, 1, 0, 0, 0, 3939, 3937,
|
|
1, 0, 0, 0, 3940, 3941, 3, 274, 137, 0, 3941, 3943, 3, 284, 142, 0, 3942,
|
|
3944, 3, 286, 143, 0, 3943, 3942, 1, 0, 0, 0, 3943, 3944, 1, 0, 0, 0, 3944,
|
|
3946, 1, 0, 0, 0, 3945, 3947, 3, 288, 144, 0, 3946, 3945, 1, 0, 0, 0, 3946,
|
|
3947, 1, 0, 0, 0, 3947, 3949, 1, 0, 0, 0, 3948, 3950, 3, 290, 145, 0, 3949,
|
|
3948, 1, 0, 0, 0, 3949, 3950, 1, 0, 0, 0, 3950, 3952, 1, 0, 0, 0, 3951,
|
|
3953, 3, 230, 115, 0, 3952, 3951, 1, 0, 0, 0, 3952, 3953, 1, 0, 0, 0, 3953,
|
|
3955, 1, 0, 0, 0, 3954, 3956, 3, 294, 147, 0, 3955, 3954, 1, 0, 0, 0, 3955,
|
|
3956, 1, 0, 0, 0, 3956, 3958, 1, 0, 0, 0, 3957, 3959, 3, 278, 139, 0, 3958,
|
|
3957, 1, 0, 0, 0, 3958, 3959, 1, 0, 0, 0, 3959, 3961, 1, 0, 0, 0, 3960,
|
|
3906, 1, 0, 0, 0, 3960, 3933, 1, 0, 0, 0, 3961, 253, 1, 0, 0, 0, 3962,
|
|
3966, 5, 152, 0, 0, 3963, 3965, 3, 272, 136, 0, 3964, 3963, 1, 0, 0, 0,
|
|
3965, 3968, 1, 0, 0, 0, 3966, 3964, 1, 0, 0, 0, 3966, 3967, 1, 0, 0, 0,
|
|
3967, 3969, 1, 0, 0, 0, 3968, 3966, 1, 0, 0, 0, 3969, 3970, 3, 274, 137,
|
|
0, 3970, 3972, 3, 284, 142, 0, 3971, 3973, 3, 286, 143, 0, 3972, 3971,
|
|
1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, 3975, 1, 0, 0, 0, 3974, 3976,
|
|
3, 288, 144, 0, 3975, 3974, 1, 0, 0, 0, 3975, 3976, 1, 0, 0, 0, 3976, 3978,
|
|
1, 0, 0, 0, 3977, 3979, 3, 290, 145, 0, 3978, 3977, 1, 0, 0, 0, 3978, 3979,
|
|
1, 0, 0, 0, 3979, 3981, 1, 0, 0, 0, 3980, 3982, 3, 230, 115, 0, 3981, 3980,
|
|
1, 0, 0, 0, 3981, 3982, 1, 0, 0, 0, 3982, 3984, 1, 0, 0, 0, 3983, 3985,
|
|
3, 294, 147, 0, 3984, 3983, 1, 0, 0, 0, 3984, 3985, 1, 0, 0, 0, 3985, 3987,
|
|
1, 0, 0, 0, 3986, 3988, 3, 258, 129, 0, 3987, 3986, 1, 0, 0, 0, 3987, 3988,
|
|
1, 0, 0, 0, 3988, 255, 1, 0, 0, 0, 3989, 3991, 5, 180, 0, 0, 3990, 3992,
|
|
7, 44, 0, 0, 3991, 3990, 1, 0, 0, 0, 3991, 3992, 1, 0, 0, 0, 3992, 3993,
|
|
1, 0, 0, 0, 3993, 3994, 3, 250, 125, 0, 3994, 257, 1, 0, 0, 0, 3995, 3997,
|
|
5, 180, 0, 0, 3996, 3998, 7, 44, 0, 0, 3997, 3996, 1, 0, 0, 0, 3997, 3998,
|
|
1, 0, 0, 0, 3998, 4001, 1, 0, 0, 0, 3999, 4002, 3, 254, 127, 0, 4000, 4002,
|
|
3, 250, 125, 0, 4001, 3999, 1, 0, 0, 0, 4001, 4000, 1, 0, 0, 0, 4002, 259,
|
|
1, 0, 0, 0, 4003, 4018, 5, 94, 0, 0, 4004, 4019, 3, 254, 127, 0, 4005,
|
|
4019, 3, 250, 125, 0, 4006, 4009, 5, 1133, 0, 0, 4007, 4010, 3, 254, 127,
|
|
0, 4008, 4010, 3, 250, 125, 0, 4009, 4007, 1, 0, 0, 0, 4009, 4008, 1, 0,
|
|
0, 0, 4010, 4011, 1, 0, 0, 0, 4011, 4016, 5, 1134, 0, 0, 4012, 4014, 5,
|
|
12, 0, 0, 4013, 4012, 1, 0, 0, 0, 4013, 4014, 1, 0, 0, 0, 4014, 4015, 1,
|
|
0, 0, 0, 4015, 4017, 3, 584, 292, 0, 4016, 4013, 1, 0, 0, 0, 4016, 4017,
|
|
1, 0, 0, 0, 4017, 4019, 1, 0, 0, 0, 4018, 4004, 1, 0, 0, 0, 4018, 4005,
|
|
1, 0, 0, 0, 4018, 4006, 1, 0, 0, 0, 4019, 261, 1, 0, 0, 0, 4020, 4021,
|
|
5, 278, 0, 0, 4021, 4022, 5, 1133, 0, 0, 4022, 4023, 5, 1148, 0, 0, 4023,
|
|
4024, 5, 1135, 0, 0, 4024, 4025, 5, 1148, 0, 0, 4025, 4026, 5, 365, 0,
|
|
0, 4026, 4027, 5, 1133, 0, 0, 4027, 4028, 3, 264, 132, 0, 4028, 4029, 5,
|
|
1134, 0, 0, 4029, 4034, 5, 1134, 0, 0, 4030, 4032, 5, 12, 0, 0, 4031, 4030,
|
|
1, 0, 0, 0, 4031, 4032, 1, 0, 0, 0, 4032, 4033, 1, 0, 0, 0, 4033, 4035,
|
|
3, 584, 292, 0, 4034, 4031, 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 263,
|
|
1, 0, 0, 0, 4036, 4041, 3, 266, 133, 0, 4037, 4038, 5, 1135, 0, 0, 4038,
|
|
4040, 3, 266, 133, 0, 4039, 4037, 1, 0, 0, 0, 4040, 4043, 1, 0, 0, 0, 4041,
|
|
4039, 1, 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 265, 1, 0, 0, 0, 4043,
|
|
4041, 1, 0, 0, 0, 4044, 4061, 3, 556, 278, 0, 4045, 4046, 5, 65, 0, 0,
|
|
4046, 4062, 5, 284, 0, 0, 4047, 4059, 3, 604, 302, 0, 4048, 4049, 5, 285,
|
|
0, 0, 4049, 4051, 5, 1148, 0, 0, 4050, 4052, 3, 268, 134, 0, 4051, 4050,
|
|
1, 0, 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4054, 1, 0, 0, 0, 4053, 4055,
|
|
3, 270, 135, 0, 4054, 4053, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4060,
|
|
1, 0, 0, 0, 4056, 4057, 5, 60, 0, 0, 4057, 4058, 5, 285, 0, 0, 4058, 4060,
|
|
5, 1148, 0, 0, 4059, 4048, 1, 0, 0, 0, 4059, 4056, 1, 0, 0, 0, 4060, 4062,
|
|
1, 0, 0, 0, 4061, 4045, 1, 0, 0, 0, 4061, 4047, 1, 0, 0, 0, 4062, 4074,
|
|
1, 0, 0, 0, 4063, 4065, 5, 283, 0, 0, 4064, 4066, 5, 285, 0, 0, 4065, 4064,
|
|
1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4068,
|
|
5, 1148, 0, 0, 4068, 4069, 5, 365, 0, 0, 4069, 4070, 5, 1133, 0, 0, 4070,
|
|
4071, 3, 264, 132, 0, 4071, 4072, 5, 1134, 0, 0, 4072, 4074, 1, 0, 0, 0,
|
|
4073, 4044, 1, 0, 0, 0, 4073, 4063, 1, 0, 0, 0, 4074, 267, 1, 0, 0, 0,
|
|
4075, 4080, 5, 116, 0, 0, 4076, 4080, 5, 411, 0, 0, 4077, 4078, 5, 42,
|
|
0, 0, 4078, 4080, 3, 634, 317, 0, 4079, 4075, 1, 0, 0, 0, 4079, 4076, 1,
|
|
0, 0, 0, 4079, 4077, 1, 0, 0, 0, 4080, 4081, 1, 0, 0, 0, 4081, 4082, 5,
|
|
118, 0, 0, 4082, 4083, 5, 55, 0, 0, 4083, 269, 1, 0, 0, 0, 4084, 4089,
|
|
5, 116, 0, 0, 4085, 4089, 5, 411, 0, 0, 4086, 4087, 5, 42, 0, 0, 4087,
|
|
4089, 3, 634, 317, 0, 4088, 4084, 1, 0, 0, 0, 4088, 4085, 1, 0, 0, 0, 4088,
|
|
4086, 1, 0, 0, 0, 4089, 4090, 1, 0, 0, 0, 4090, 4091, 5, 118, 0, 0, 4091,
|
|
4092, 5, 411, 0, 0, 4092, 271, 1, 0, 0, 0, 4093, 4102, 7, 52, 0, 0, 4094,
|
|
4102, 5, 75, 0, 0, 4095, 4102, 5, 171, 0, 0, 4096, 4102, 5, 166, 0, 0,
|
|
4097, 4102, 5, 164, 0, 0, 4098, 4102, 5, 625, 0, 0, 4099, 4102, 7, 53,
|
|
0, 0, 4100, 4102, 5, 165, 0, 0, 4101, 4093, 1, 0, 0, 0, 4101, 4094, 1,
|
|
0, 0, 0, 4101, 4095, 1, 0, 0, 0, 4101, 4096, 1, 0, 0, 0, 4101, 4097, 1,
|
|
0, 0, 0, 4101, 4098, 1, 0, 0, 0, 4101, 4099, 1, 0, 0, 0, 4101, 4100, 1,
|
|
0, 0, 0, 4102, 273, 1, 0, 0, 0, 4103, 4106, 5, 1117, 0, 0, 4104, 4106,
|
|
3, 276, 138, 0, 4105, 4103, 1, 0, 0, 0, 4105, 4104, 1, 0, 0, 0, 4106, 4111,
|
|
1, 0, 0, 0, 4107, 4108, 5, 1135, 0, 0, 4108, 4110, 3, 276, 138, 0, 4109,
|
|
4107, 1, 0, 0, 0, 4110, 4113, 1, 0, 0, 0, 4111, 4109, 1, 0, 0, 0, 4111,
|
|
4112, 1, 0, 0, 0, 4112, 275, 1, 0, 0, 0, 4113, 4111, 1, 0, 0, 0, 4114,
|
|
4115, 3, 550, 275, 0, 4115, 4116, 5, 1132, 0, 0, 4116, 4117, 5, 1117, 0,
|
|
0, 4117, 4144, 1, 0, 0, 0, 4118, 4123, 3, 556, 278, 0, 4119, 4121, 5, 12,
|
|
0, 0, 4120, 4119, 1, 0, 0, 0, 4120, 4121, 1, 0, 0, 0, 4121, 4122, 1, 0,
|
|
0, 0, 4122, 4124, 3, 584, 292, 0, 4123, 4120, 1, 0, 0, 0, 4123, 4124, 1,
|
|
0, 0, 0, 4124, 4144, 1, 0, 0, 0, 4125, 4130, 3, 648, 324, 0, 4126, 4128,
|
|
5, 12, 0, 0, 4127, 4126, 1, 0, 0, 0, 4127, 4128, 1, 0, 0, 0, 4128, 4129,
|
|
1, 0, 0, 0, 4129, 4131, 3, 584, 292, 0, 4130, 4127, 1, 0, 0, 0, 4130, 4131,
|
|
1, 0, 0, 0, 4131, 4144, 1, 0, 0, 0, 4132, 4133, 5, 1159, 0, 0, 4133, 4135,
|
|
5, 1108, 0, 0, 4134, 4132, 1, 0, 0, 0, 4134, 4135, 1, 0, 0, 0, 4135, 4136,
|
|
1, 0, 0, 0, 4136, 4141, 3, 688, 344, 0, 4137, 4139, 5, 12, 0, 0, 4138,
|
|
4137, 1, 0, 0, 0, 4138, 4139, 1, 0, 0, 0, 4139, 4140, 1, 0, 0, 0, 4140,
|
|
4142, 3, 584, 292, 0, 4141, 4138, 1, 0, 0, 0, 4141, 4142, 1, 0, 0, 0, 4142,
|
|
4144, 1, 0, 0, 0, 4143, 4114, 1, 0, 0, 0, 4143, 4118, 1, 0, 0, 0, 4143,
|
|
4125, 1, 0, 0, 0, 4143, 4134, 1, 0, 0, 0, 4144, 277, 1, 0, 0, 0, 4145,
|
|
4146, 5, 87, 0, 0, 4146, 4151, 3, 210, 105, 0, 4147, 4148, 5, 1135, 0,
|
|
0, 4148, 4150, 3, 210, 105, 0, 4149, 4147, 1, 0, 0, 0, 4150, 4153, 1, 0,
|
|
0, 0, 4151, 4149, 1, 0, 0, 0, 4151, 4152, 1, 0, 0, 0, 4152, 4182, 1, 0,
|
|
0, 0, 4153, 4151, 1, 0, 0, 0, 4154, 4155, 5, 87, 0, 0, 4155, 4156, 5, 400,
|
|
0, 0, 4156, 4182, 5, 1148, 0, 0, 4157, 4158, 5, 87, 0, 0, 4158, 4159, 5,
|
|
127, 0, 0, 4159, 4163, 5, 1148, 0, 0, 4160, 4161, 5, 25, 0, 0, 4161, 4162,
|
|
5, 153, 0, 0, 4162, 4164, 3, 568, 284, 0, 4163, 4160, 1, 0, 0, 0, 4163,
|
|
4164, 1, 0, 0, 0, 4164, 4171, 1, 0, 0, 0, 4165, 4167, 7, 41, 0, 0, 4166,
|
|
4168, 3, 280, 140, 0, 4167, 4166, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169,
|
|
4167, 1, 0, 0, 0, 4169, 4170, 1, 0, 0, 0, 4170, 4172, 1, 0, 0, 0, 4171,
|
|
4165, 1, 0, 0, 0, 4171, 4172, 1, 0, 0, 0, 4172, 4179, 1, 0, 0, 0, 4173,
|
|
4175, 5, 101, 0, 0, 4174, 4176, 3, 282, 141, 0, 4175, 4174, 1, 0, 0, 0,
|
|
4176, 4177, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0,
|
|
4178, 4180, 1, 0, 0, 0, 4179, 4173, 1, 0, 0, 0, 4179, 4180, 1, 0, 0, 0,
|
|
4180, 4182, 1, 0, 0, 0, 4181, 4145, 1, 0, 0, 0, 4181, 4154, 1, 0, 0, 0,
|
|
4181, 4157, 1, 0, 0, 0, 4182, 279, 1, 0, 0, 0, 4183, 4184, 5, 173, 0, 0,
|
|
4184, 4185, 5, 19, 0, 0, 4185, 4196, 5, 1148, 0, 0, 4186, 4188, 5, 122,
|
|
0, 0, 4187, 4186, 1, 0, 0, 0, 4187, 4188, 1, 0, 0, 0, 4188, 4189, 1, 0,
|
|
0, 0, 4189, 4190, 5, 56, 0, 0, 4190, 4191, 5, 19, 0, 0, 4191, 4196, 5,
|
|
1148, 0, 0, 4192, 4193, 5, 58, 0, 0, 4193, 4194, 5, 19, 0, 0, 4194, 4196,
|
|
5, 1148, 0, 0, 4195, 4183, 1, 0, 0, 0, 4195, 4187, 1, 0, 0, 0, 4195, 4192,
|
|
1, 0, 0, 0, 4196, 281, 1, 0, 0, 0, 4197, 4198, 5, 169, 0, 0, 4198, 4199,
|
|
5, 19, 0, 0, 4199, 4204, 5, 1148, 0, 0, 4200, 4201, 5, 173, 0, 0, 4201,
|
|
4202, 5, 19, 0, 0, 4202, 4204, 5, 1148, 0, 0, 4203, 4197, 1, 0, 0, 0, 4203,
|
|
4200, 1, 0, 0, 0, 4204, 283, 1, 0, 0, 0, 4205, 4206, 5, 68, 0, 0, 4206,
|
|
4208, 3, 234, 117, 0, 4207, 4205, 1, 0, 0, 0, 4207, 4208, 1, 0, 0, 0, 4208,
|
|
4211, 1, 0, 0, 0, 4209, 4210, 5, 190, 0, 0, 4210, 4212, 3, 688, 344, 0,
|
|
4211, 4209, 1, 0, 0, 0, 4211, 4212, 1, 0, 0, 0, 4212, 285, 1, 0, 0, 0,
|
|
4213, 4214, 5, 73, 0, 0, 4214, 4215, 5, 19, 0, 0, 4215, 4220, 3, 292, 146,
|
|
0, 4216, 4217, 5, 1135, 0, 0, 4217, 4219, 3, 292, 146, 0, 4218, 4216, 1,
|
|
0, 0, 0, 4219, 4222, 1, 0, 0, 0, 4220, 4218, 1, 0, 0, 0, 4220, 4221, 1,
|
|
0, 0, 0, 4221, 4225, 1, 0, 0, 0, 4222, 4220, 1, 0, 0, 0, 4223, 4224, 5,
|
|
192, 0, 0, 4224, 4226, 5, 598, 0, 0, 4225, 4223, 1, 0, 0, 0, 4225, 4226,
|
|
1, 0, 0, 0, 4226, 287, 1, 0, 0, 0, 4227, 4228, 5, 74, 0, 0, 4228, 4229,
|
|
3, 688, 344, 0, 4229, 289, 1, 0, 0, 0, 4230, 4231, 5, 676, 0, 0, 4231,
|
|
4232, 3, 666, 333, 0, 4232, 4233, 5, 12, 0, 0, 4233, 4234, 5, 1133, 0,
|
|
0, 4234, 4235, 3, 664, 332, 0, 4235, 4245, 5, 1134, 0, 0, 4236, 4237, 5,
|
|
1135, 0, 0, 4237, 4238, 3, 666, 333, 0, 4238, 4239, 5, 12, 0, 0, 4239,
|
|
4240, 5, 1133, 0, 0, 4240, 4241, 3, 664, 332, 0, 4241, 4242, 5, 1134, 0,
|
|
0, 4242, 4244, 1, 0, 0, 0, 4243, 4236, 1, 0, 0, 0, 4244, 4247, 1, 0, 0,
|
|
0, 4245, 4243, 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 291, 1, 0, 0,
|
|
0, 4247, 4245, 1, 0, 0, 0, 4248, 4250, 3, 688, 344, 0, 4249, 4251, 7, 48,
|
|
0, 0, 4250, 4249, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 293, 1, 0,
|
|
0, 0, 4252, 4263, 5, 99, 0, 0, 4253, 4254, 3, 296, 148, 0, 4254, 4255,
|
|
5, 1135, 0, 0, 4255, 4257, 1, 0, 0, 0, 4256, 4253, 1, 0, 0, 0, 4256, 4257,
|
|
1, 0, 0, 0, 4257, 4258, 1, 0, 0, 0, 4258, 4264, 3, 296, 148, 0, 4259, 4260,
|
|
3, 296, 148, 0, 4260, 4261, 5, 532, 0, 0, 4261, 4262, 3, 296, 148, 0, 4262,
|
|
4264, 1, 0, 0, 0, 4263, 4256, 1, 0, 0, 0, 4263, 4259, 1, 0, 0, 0, 4264,
|
|
295, 1, 0, 0, 0, 4265, 4269, 3, 590, 295, 0, 4266, 4269, 3, 566, 283, 0,
|
|
4267, 4269, 3, 586, 293, 0, 4268, 4265, 1, 0, 0, 0, 4268, 4266, 1, 0, 0,
|
|
0, 4268, 4267, 1, 0, 0, 0, 4269, 297, 1, 0, 0, 0, 4270, 4271, 5, 629, 0,
|
|
0, 4271, 4280, 5, 653, 0, 0, 4272, 4277, 3, 320, 160, 0, 4273, 4274, 5,
|
|
1135, 0, 0, 4274, 4276, 3, 320, 160, 0, 4275, 4273, 1, 0, 0, 0, 4276, 4279,
|
|
1, 0, 0, 0, 4277, 4275, 1, 0, 0, 0, 4277, 4278, 1, 0, 0, 0, 4278, 4281,
|
|
1, 0, 0, 0, 4279, 4277, 1, 0, 0, 0, 4280, 4272, 1, 0, 0, 0, 4280, 4281,
|
|
1, 0, 0, 0, 4281, 299, 1, 0, 0, 0, 4282, 4284, 5, 344, 0, 0, 4283, 4285,
|
|
5, 678, 0, 0, 4284, 4283, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 301,
|
|
1, 0, 0, 0, 4286, 4288, 5, 369, 0, 0, 4287, 4289, 5, 678, 0, 0, 4288, 4287,
|
|
1, 0, 0, 0, 4288, 4289, 1, 0, 0, 0, 4289, 4295, 1, 0, 0, 0, 4290, 4292,
|
|
5, 10, 0, 0, 4291, 4293, 5, 521, 0, 0, 4292, 4291, 1, 0, 0, 0, 4292, 4293,
|
|
1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 5, 353, 0, 0, 4295, 4290,
|
|
1, 0, 0, 0, 4295, 4296, 1, 0, 0, 0, 4296, 4301, 1, 0, 0, 0, 4297, 4299,
|
|
5, 521, 0, 0, 4298, 4297, 1, 0, 0, 0, 4298, 4299, 1, 0, 0, 0, 4299, 4300,
|
|
1, 0, 0, 0, 4300, 4302, 5, 138, 0, 0, 4301, 4298, 1, 0, 0, 0, 4301, 4302,
|
|
1, 0, 0, 0, 4302, 303, 1, 0, 0, 0, 4303, 4305, 5, 597, 0, 0, 4304, 4306,
|
|
5, 678, 0, 0, 4305, 4304, 1, 0, 0, 0, 4305, 4306, 1, 0, 0, 0, 4306, 4312,
|
|
1, 0, 0, 0, 4307, 4309, 5, 10, 0, 0, 4308, 4310, 5, 521, 0, 0, 4309, 4308,
|
|
1, 0, 0, 0, 4309, 4310, 1, 0, 0, 0, 4310, 4311, 1, 0, 0, 0, 4311, 4313,
|
|
5, 353, 0, 0, 4312, 4307, 1, 0, 0, 0, 4312, 4313, 1, 0, 0, 0, 4313, 4318,
|
|
1, 0, 0, 0, 4314, 4316, 5, 521, 0, 0, 4315, 4314, 1, 0, 0, 0, 4315, 4316,
|
|
1, 0, 0, 0, 4316, 4317, 1, 0, 0, 0, 4317, 4319, 5, 138, 0, 0, 4318, 4315,
|
|
1, 0, 0, 0, 4318, 4319, 1, 0, 0, 0, 4319, 305, 1, 0, 0, 0, 4320, 4321,
|
|
5, 604, 0, 0, 4321, 4322, 3, 584, 292, 0, 4322, 307, 1, 0, 0, 0, 4323,
|
|
4325, 5, 597, 0, 0, 4324, 4326, 5, 678, 0, 0, 4325, 4324, 1, 0, 0, 0, 4325,
|
|
4326, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 4329, 5, 175, 0, 0, 4328,
|
|
4330, 5, 604, 0, 0, 4329, 4328, 1, 0, 0, 0, 4329, 4330, 1, 0, 0, 0, 4330,
|
|
4331, 1, 0, 0, 0, 4331, 4332, 3, 584, 292, 0, 4332, 309, 1, 0, 0, 0, 4333,
|
|
4334, 5, 138, 0, 0, 4334, 4335, 5, 604, 0, 0, 4335, 4336, 3, 584, 292,
|
|
0, 4336, 311, 1, 0, 0, 0, 4337, 4338, 5, 103, 0, 0, 4338, 4339, 7, 54,
|
|
0, 0, 4339, 4344, 3, 322, 161, 0, 4340, 4341, 5, 1135, 0, 0, 4341, 4343,
|
|
3, 322, 161, 0, 4342, 4340, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342,
|
|
1, 0, 0, 0, 4344, 4345, 1, 0, 0, 0, 4345, 4348, 1, 0, 0, 0, 4346, 4344,
|
|
1, 0, 0, 0, 4347, 4349, 3, 646, 323, 0, 4348, 4347, 1, 0, 0, 0, 4348, 4349,
|
|
1, 0, 0, 0, 4349, 313, 1, 0, 0, 0, 4350, 4351, 5, 182, 0, 0, 4351, 4352,
|
|
5, 742, 0, 0, 4352, 315, 1, 0, 0, 0, 4353, 4354, 5, 153, 0, 0, 4354, 4355,
|
|
5, 340, 0, 0, 4355, 4356, 5, 1124, 0, 0, 4356, 4357, 7, 24, 0, 0, 4357,
|
|
317, 1, 0, 0, 0, 4358, 4360, 5, 153, 0, 0, 4359, 4361, 7, 55, 0, 0, 4360,
|
|
4359, 1, 0, 0, 0, 4360, 4361, 1, 0, 0, 0, 4361, 4362, 1, 0, 0, 0, 4362,
|
|
4363, 5, 653, 0, 0, 4363, 4368, 3, 326, 163, 0, 4364, 4365, 5, 1135, 0,
|
|
0, 4365, 4367, 3, 326, 163, 0, 4366, 4364, 1, 0, 0, 0, 4367, 4370, 1, 0,
|
|
0, 0, 4368, 4366, 1, 0, 0, 0, 4368, 4369, 1, 0, 0, 0, 4369, 319, 1, 0,
|
|
0, 0, 4370, 4368, 1, 0, 0, 0, 4371, 4372, 5, 192, 0, 0, 4372, 4373, 5,
|
|
377, 0, 0, 4373, 4379, 5, 616, 0, 0, 4374, 4375, 5, 134, 0, 0, 4375, 4379,
|
|
5, 193, 0, 0, 4376, 4377, 5, 134, 0, 0, 4377, 4379, 5, 538, 0, 0, 4378,
|
|
4371, 1, 0, 0, 0, 4378, 4374, 1, 0, 0, 0, 4378, 4376, 1, 0, 0, 0, 4379,
|
|
321, 1, 0, 0, 0, 4380, 4385, 3, 552, 276, 0, 4381, 4383, 5, 12, 0, 0, 4382,
|
|
4381, 1, 0, 0, 0, 4382, 4383, 1, 0, 0, 0, 4383, 4384, 1, 0, 0, 0, 4384,
|
|
4386, 3, 584, 292, 0, 4385, 4382, 1, 0, 0, 0, 4385, 4386, 1, 0, 0, 0, 4386,
|
|
4387, 1, 0, 0, 0, 4387, 4388, 3, 324, 162, 0, 4388, 323, 1, 0, 0, 0, 4389,
|
|
4391, 5, 134, 0, 0, 4390, 4392, 5, 474, 0, 0, 4391, 4390, 1, 0, 0, 0, 4391,
|
|
4392, 1, 0, 0, 0, 4392, 4398, 1, 0, 0, 0, 4393, 4395, 5, 106, 0, 0, 4394,
|
|
4393, 1, 0, 0, 0, 4394, 4395, 1, 0, 0, 0, 4395, 4396, 1, 0, 0, 0, 4396,
|
|
4398, 5, 193, 0, 0, 4397, 4389, 1, 0, 0, 0, 4397, 4394, 1, 0, 0, 0, 4398,
|
|
325, 1, 0, 0, 0, 4399, 4400, 5, 464, 0, 0, 4400, 4401, 5, 472, 0, 0, 4401,
|
|
4407, 3, 328, 164, 0, 4402, 4403, 5, 134, 0, 0, 4403, 4407, 5, 193, 0,
|
|
0, 4404, 4405, 5, 134, 0, 0, 4405, 4407, 5, 538, 0, 0, 4406, 4399, 1, 0,
|
|
0, 0, 4406, 4402, 1, 0, 0, 0, 4406, 4404, 1, 0, 0, 0, 4407, 327, 1, 0,
|
|
0, 0, 4408, 4409, 5, 799, 0, 0, 4409, 4416, 5, 134, 0, 0, 4410, 4411, 5,
|
|
134, 0, 0, 4411, 4416, 5, 800, 0, 0, 4412, 4413, 5, 134, 0, 0, 4413, 4416,
|
|
5, 801, 0, 0, 4414, 4416, 5, 802, 0, 0, 4415, 4408, 1, 0, 0, 0, 4415, 4410,
|
|
1, 0, 0, 0, 4415, 4412, 1, 0, 0, 0, 4415, 4414, 1, 0, 0, 0, 4416, 329,
|
|
1, 0, 0, 0, 4417, 4418, 5, 24, 0, 0, 4418, 4419, 5, 477, 0, 0, 4419, 4420,
|
|
5, 175, 0, 0, 4420, 4425, 3, 348, 174, 0, 4421, 4422, 5, 1135, 0, 0, 4422,
|
|
4424, 3, 348, 174, 0, 4423, 4421, 1, 0, 0, 0, 4424, 4427, 1, 0, 0, 0, 4425,
|
|
4423, 1, 0, 0, 0, 4425, 4426, 1, 0, 0, 0, 4426, 4429, 1, 0, 0, 0, 4427,
|
|
4425, 1, 0, 0, 0, 4428, 4430, 3, 356, 178, 0, 4429, 4428, 1, 0, 0, 0, 4429,
|
|
4430, 1, 0, 0, 0, 4430, 331, 1, 0, 0, 0, 4431, 4432, 5, 24, 0, 0, 4432,
|
|
4433, 5, 588, 0, 0, 4433, 4434, 5, 429, 0, 0, 4434, 4439, 3, 358, 179,
|
|
0, 4435, 4436, 5, 1135, 0, 0, 4436, 4438, 3, 358, 179, 0, 4437, 4435, 1,
|
|
0, 0, 0, 4438, 4441, 1, 0, 0, 0, 4439, 4437, 1, 0, 0, 0, 4439, 4440, 1,
|
|
0, 0, 0, 4440, 333, 1, 0, 0, 0, 4441, 4439, 1, 0, 0, 0, 4442, 4443, 5,
|
|
132, 0, 0, 4443, 4444, 7, 56, 0, 0, 4444, 4449, 5, 476, 0, 0, 4445, 4446,
|
|
5, 175, 0, 0, 4446, 4450, 5, 1148, 0, 0, 4447, 4448, 5, 15, 0, 0, 4448,
|
|
4450, 5, 1148, 0, 0, 4449, 4445, 1, 0, 0, 0, 4449, 4447, 1, 0, 0, 0, 4450,
|
|
335, 1, 0, 0, 0, 4451, 4452, 5, 589, 0, 0, 4452, 4453, 5, 477, 0, 0, 4453,
|
|
337, 1, 0, 0, 0, 4454, 4455, 5, 589, 0, 0, 4455, 4457, 5, 614, 0, 0, 4456,
|
|
4458, 5, 6, 0, 0, 4457, 4456, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458,
|
|
4460, 1, 0, 0, 0, 4459, 4461, 3, 356, 178, 0, 4460, 4459, 1, 0, 0, 0, 4460,
|
|
4461, 1, 0, 0, 0, 4461, 339, 1, 0, 0, 0, 4462, 4463, 5, 629, 0, 0, 4463,
|
|
4472, 5, 614, 0, 0, 4464, 4469, 3, 362, 181, 0, 4465, 4466, 5, 1135, 0,
|
|
0, 4466, 4468, 3, 362, 181, 0, 4467, 4465, 1, 0, 0, 0, 4468, 4471, 1, 0,
|
|
0, 0, 4469, 4467, 1, 0, 0, 0, 4469, 4470, 1, 0, 0, 0, 4470, 4473, 1, 0,
|
|
0, 0, 4471, 4469, 1, 0, 0, 0, 4472, 4464, 1, 0, 0, 0, 4472, 4473, 1, 0,
|
|
0, 0, 4473, 4476, 1, 0, 0, 0, 4474, 4475, 5, 663, 0, 0, 4475, 4477, 3,
|
|
364, 182, 0, 4476, 4474, 1, 0, 0, 0, 4476, 4477, 1, 0, 0, 0, 4477, 4481,
|
|
1, 0, 0, 0, 4478, 4480, 3, 366, 183, 0, 4479, 4478, 1, 0, 0, 0, 4480, 4483,
|
|
1, 0, 0, 0, 4481, 4479, 1, 0, 0, 0, 4481, 4482, 1, 0, 0, 0, 4482, 4485,
|
|
1, 0, 0, 0, 4483, 4481, 1, 0, 0, 0, 4484, 4486, 3, 356, 178, 0, 4485, 4484,
|
|
1, 0, 0, 0, 4485, 4486, 1, 0, 0, 0, 4486, 341, 1, 0, 0, 0, 4487, 4488,
|
|
5, 635, 0, 0, 4488, 4497, 5, 614, 0, 0, 4489, 4494, 3, 362, 181, 0, 4490,
|
|
4491, 5, 1135, 0, 0, 4491, 4493, 3, 362, 181, 0, 4492, 4490, 1, 0, 0, 0,
|
|
4493, 4496, 1, 0, 0, 0, 4494, 4492, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, 0,
|
|
4495, 4498, 1, 0, 0, 0, 4496, 4494, 1, 0, 0, 0, 4497, 4489, 1, 0, 0, 0,
|
|
4497, 4498, 1, 0, 0, 0, 4498, 343, 1, 0, 0, 0, 4499, 4500, 5, 629, 0, 0,
|
|
4500, 4501, 5, 441, 0, 0, 4501, 345, 1, 0, 0, 0, 4502, 4503, 5, 635, 0,
|
|
0, 4503, 4504, 5, 441, 0, 0, 4504, 347, 1, 0, 0, 0, 4505, 4506, 3, 350,
|
|
175, 0, 4506, 4507, 5, 1124, 0, 0, 4507, 4508, 5, 1148, 0, 0, 4508, 4535,
|
|
1, 0, 0, 0, 4509, 4510, 3, 352, 176, 0, 4510, 4511, 5, 1124, 0, 0, 4511,
|
|
4512, 3, 590, 295, 0, 4512, 4535, 1, 0, 0, 0, 4513, 4514, 3, 354, 177,
|
|
0, 4514, 4515, 5, 1124, 0, 0, 4515, 4516, 7, 24, 0, 0, 4516, 4535, 1, 0,
|
|
0, 0, 4517, 4518, 5, 481, 0, 0, 4518, 4519, 5, 1124, 0, 0, 4519, 4535,
|
|
5, 1151, 0, 0, 4520, 4521, 5, 449, 0, 0, 4521, 4522, 5, 1124, 0, 0, 4522,
|
|
4531, 5, 1133, 0, 0, 4523, 4528, 3, 584, 292, 0, 4524, 4525, 5, 1135, 0,
|
|
0, 4525, 4527, 3, 584, 292, 0, 4526, 4524, 1, 0, 0, 0, 4527, 4530, 1, 0,
|
|
0, 0, 4528, 4526, 1, 0, 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 4532, 1, 0,
|
|
0, 0, 4530, 4528, 1, 0, 0, 0, 4531, 4523, 1, 0, 0, 0, 4531, 4532, 1, 0,
|
|
0, 0, 4532, 4533, 1, 0, 0, 0, 4533, 4535, 5, 1134, 0, 0, 4534, 4505, 1,
|
|
0, 0, 0, 4534, 4509, 1, 0, 0, 0, 4534, 4513, 1, 0, 0, 0, 4534, 4517, 1,
|
|
0, 0, 0, 4534, 4520, 1, 0, 0, 0, 4535, 349, 1, 0, 0, 0, 4536, 4537, 7,
|
|
57, 0, 0, 4537, 351, 1, 0, 0, 0, 4538, 4539, 7, 58, 0, 0, 4539, 353, 1,
|
|
0, 0, 0, 4540, 4541, 7, 59, 0, 0, 4541, 355, 1, 0, 0, 0, 4542, 4543, 5,
|
|
65, 0, 0, 4543, 4544, 5, 355, 0, 0, 4544, 4545, 5, 1148, 0, 0, 4545, 357,
|
|
1, 0, 0, 0, 4546, 4547, 5, 581, 0, 0, 4547, 4548, 5, 1124, 0, 0, 4548,
|
|
4549, 5, 1133, 0, 0, 4549, 4550, 3, 616, 308, 0, 4550, 4551, 5, 1134, 0,
|
|
0, 4551, 4596, 1, 0, 0, 0, 4552, 4553, 5, 583, 0, 0, 4553, 4554, 5, 1124,
|
|
0, 0, 4554, 4555, 5, 1133, 0, 0, 4555, 4556, 3, 616, 308, 0, 4556, 4557,
|
|
5, 1134, 0, 0, 4557, 4596, 1, 0, 0, 0, 4558, 4559, 5, 582, 0, 0, 4559,
|
|
4560, 5, 1124, 0, 0, 4560, 4561, 5, 1133, 0, 0, 4561, 4562, 3, 620, 310,
|
|
0, 4562, 4563, 5, 1134, 0, 0, 4563, 4596, 1, 0, 0, 0, 4564, 4565, 5, 584,
|
|
0, 0, 4565, 4566, 5, 1124, 0, 0, 4566, 4567, 5, 1133, 0, 0, 4567, 4568,
|
|
3, 620, 310, 0, 4568, 4569, 5, 1134, 0, 0, 4569, 4596, 1, 0, 0, 0, 4570,
|
|
4571, 5, 586, 0, 0, 4571, 4572, 5, 1124, 0, 0, 4572, 4573, 5, 1133, 0,
|
|
0, 4573, 4574, 3, 630, 315, 0, 4574, 4575, 5, 1134, 0, 0, 4575, 4596, 1,
|
|
0, 0, 0, 4576, 4577, 5, 587, 0, 0, 4577, 4578, 5, 1124, 0, 0, 4578, 4579,
|
|
5, 1133, 0, 0, 4579, 4580, 3, 630, 315, 0, 4580, 4581, 5, 1134, 0, 0, 4581,
|
|
4596, 1, 0, 0, 0, 4582, 4583, 5, 585, 0, 0, 4583, 4584, 5, 1124, 0, 0,
|
|
4584, 4585, 5, 1133, 0, 0, 4585, 4590, 3, 360, 180, 0, 4586, 4587, 5, 1135,
|
|
0, 0, 4587, 4589, 3, 360, 180, 0, 4588, 4586, 1, 0, 0, 0, 4589, 4592, 1,
|
|
0, 0, 0, 4590, 4588, 1, 0, 0, 0, 4590, 4591, 1, 0, 0, 0, 4591, 4593, 1,
|
|
0, 0, 0, 4592, 4590, 1, 0, 0, 0, 4593, 4594, 5, 1134, 0, 0, 4594, 4596,
|
|
1, 0, 0, 0, 4595, 4546, 1, 0, 0, 0, 4595, 4552, 1, 0, 0, 0, 4595, 4558,
|
|
1, 0, 0, 0, 4595, 4564, 1, 0, 0, 0, 4595, 4570, 1, 0, 0, 0, 4595, 4576,
|
|
1, 0, 0, 0, 4595, 4582, 1, 0, 0, 0, 4596, 359, 1, 0, 0, 0, 4597, 4598,
|
|
5, 1133, 0, 0, 4598, 4599, 3, 552, 276, 0, 4599, 4600, 5, 1135, 0, 0, 4600,
|
|
4601, 3, 552, 276, 0, 4601, 4602, 5, 1134, 0, 0, 4602, 361, 1, 0, 0, 0,
|
|
4603, 4604, 7, 60, 0, 0, 4604, 363, 1, 0, 0, 0, 4605, 4606, 7, 61, 0, 0,
|
|
4606, 4607, 5, 1124, 0, 0, 4607, 4624, 3, 368, 184, 0, 4608, 4609, 5, 483,
|
|
0, 0, 4609, 4610, 5, 1124, 0, 0, 4610, 4611, 5, 1148, 0, 0, 4611, 4612,
|
|
5, 1135, 0, 0, 4612, 4613, 5, 484, 0, 0, 4613, 4614, 5, 1124, 0, 0, 4614,
|
|
4624, 3, 590, 295, 0, 4615, 4616, 5, 575, 0, 0, 4616, 4617, 5, 1124, 0,
|
|
0, 4617, 4618, 5, 1148, 0, 0, 4618, 4619, 5, 1135, 0, 0, 4619, 4620, 5,
|
|
576, 0, 0, 4620, 4621, 5, 1124, 0, 0, 4621, 4624, 3, 590, 295, 0, 4622,
|
|
4624, 5, 623, 0, 0, 4623, 4605, 1, 0, 0, 0, 4623, 4608, 1, 0, 0, 0, 4623,
|
|
4615, 1, 0, 0, 0, 4623, 4622, 1, 0, 0, 0, 4624, 365, 1, 0, 0, 0, 4625,
|
|
4626, 5, 665, 0, 0, 4626, 4627, 5, 1124, 0, 0, 4627, 4638, 5, 1148, 0,
|
|
0, 4628, 4629, 5, 551, 0, 0, 4629, 4630, 5, 1124, 0, 0, 4630, 4638, 5,
|
|
1148, 0, 0, 4631, 4632, 5, 391, 0, 0, 4632, 4633, 5, 1124, 0, 0, 4633,
|
|
4638, 5, 1148, 0, 0, 4634, 4635, 5, 555, 0, 0, 4635, 4636, 5, 1124, 0,
|
|
0, 4636, 4638, 5, 1148, 0, 0, 4637, 4625, 1, 0, 0, 0, 4637, 4628, 1, 0,
|
|
0, 0, 4637, 4631, 1, 0, 0, 0, 4637, 4634, 1, 0, 0, 0, 4638, 367, 1, 0,
|
|
0, 0, 4639, 4644, 3, 576, 288, 0, 4640, 4641, 5, 1135, 0, 0, 4641, 4643,
|
|
3, 576, 288, 0, 4642, 4640, 1, 0, 0, 0, 4643, 4646, 1, 0, 0, 0, 4644, 4642,
|
|
1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 4649, 1, 0, 0, 0, 4646, 4644,
|
|
1, 0, 0, 0, 4647, 4649, 5, 1148, 0, 0, 4648, 4639, 1, 0, 0, 0, 4648, 4647,
|
|
1, 0, 0, 0, 4649, 369, 1, 0, 0, 0, 4650, 4651, 5, 681, 0, 0, 4651, 4652,
|
|
7, 62, 0, 0, 4652, 4654, 3, 578, 289, 0, 4653, 4655, 7, 63, 0, 0, 4654,
|
|
4653, 1, 0, 0, 0, 4654, 4655, 1, 0, 0, 0, 4655, 371, 1, 0, 0, 0, 4656,
|
|
4657, 5, 681, 0, 0, 4657, 4658, 5, 407, 0, 0, 4658, 4664, 3, 578, 289,
|
|
0, 4659, 4662, 5, 643, 0, 0, 4660, 4661, 5, 65, 0, 0, 4661, 4663, 5, 509,
|
|
0, 0, 4662, 4660, 1, 0, 0, 0, 4662, 4663, 1, 0, 0, 0, 4663, 4665, 1, 0,
|
|
0, 0, 4664, 4659, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, 373, 1, 0,
|
|
0, 0, 4666, 4667, 5, 681, 0, 0, 4667, 4668, 5, 560, 0, 0, 4668, 4669, 3,
|
|
578, 289, 0, 4669, 375, 1, 0, 0, 0, 4670, 4671, 5, 681, 0, 0, 4671, 4672,
|
|
5, 369, 0, 0, 4672, 4675, 3, 578, 289, 0, 4673, 4674, 5, 536, 0, 0, 4674,
|
|
4676, 5, 553, 0, 0, 4675, 4673, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676,
|
|
377, 1, 0, 0, 0, 4677, 4678, 5, 681, 0, 0, 4678, 4679, 5, 597, 0, 0, 4679,
|
|
4680, 3, 578, 289, 0, 4680, 379, 1, 0, 0, 0, 4681, 4682, 5, 681, 0, 0,
|
|
4682, 4685, 5, 570, 0, 0, 4683, 4684, 5, 32, 0, 0, 4684, 4686, 3, 578,
|
|
289, 0, 4685, 4683, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, 381, 1, 0,
|
|
0, 0, 4687, 4688, 5, 560, 0, 0, 4688, 4689, 3, 584, 292, 0, 4689, 4692,
|
|
5, 68, 0, 0, 4690, 4693, 5, 1148, 0, 0, 4691, 4693, 5, 1159, 0, 0, 4692,
|
|
4690, 1, 0, 0, 0, 4692, 4691, 1, 0, 0, 0, 4693, 383, 1, 0, 0, 0, 4694,
|
|
4695, 5, 708, 0, 0, 4695, 4698, 3, 584, 292, 0, 4696, 4697, 5, 187, 0,
|
|
0, 4697, 4699, 3, 632, 316, 0, 4698, 4696, 1, 0, 0, 0, 4698, 4699, 1, 0,
|
|
0, 0, 4699, 385, 1, 0, 0, 0, 4700, 4701, 7, 64, 0, 0, 4701, 4702, 5, 560,
|
|
0, 0, 4702, 4703, 3, 584, 292, 0, 4703, 387, 1, 0, 0, 0, 4704, 4707, 3,
|
|
390, 195, 0, 4705, 4707, 3, 4, 2, 0, 4706, 4704, 1, 0, 0, 0, 4706, 4705,
|
|
1, 0, 0, 0, 4707, 389, 1, 0, 0, 0, 4708, 4709, 3, 584, 292, 0, 4709, 4710,
|
|
5, 1144, 0, 0, 4710, 4712, 1, 0, 0, 0, 4711, 4708, 1, 0, 0, 0, 4711, 4712,
|
|
1, 0, 0, 0, 4712, 4713, 1, 0, 0, 0, 4713, 4719, 5, 344, 0, 0, 4714, 4715,
|
|
3, 410, 205, 0, 4715, 4716, 5, 1136, 0, 0, 4716, 4718, 1, 0, 0, 0, 4717,
|
|
4714, 1, 0, 0, 0, 4718, 4721, 1, 0, 0, 0, 4719, 4717, 1, 0, 0, 0, 4719,
|
|
4720, 1, 0, 0, 0, 4720, 4727, 1, 0, 0, 0, 4721, 4719, 1, 0, 0, 0, 4722,
|
|
4723, 3, 412, 206, 0, 4723, 4724, 5, 1136, 0, 0, 4724, 4726, 1, 0, 0, 0,
|
|
4725, 4722, 1, 0, 0, 0, 4726, 4729, 1, 0, 0, 0, 4727, 4725, 1, 0, 0, 0,
|
|
4727, 4728, 1, 0, 0, 0, 4728, 4735, 1, 0, 0, 0, 4729, 4727, 1, 0, 0, 0,
|
|
4730, 4731, 3, 414, 207, 0, 4731, 4732, 5, 1136, 0, 0, 4732, 4734, 1, 0,
|
|
0, 0, 4733, 4730, 1, 0, 0, 0, 4734, 4737, 1, 0, 0, 0, 4735, 4733, 1, 0,
|
|
0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4743, 1, 0, 0, 0, 4737, 4735, 1, 0,
|
|
0, 0, 4738, 4739, 3, 416, 208, 0, 4739, 4740, 5, 1136, 0, 0, 4740, 4742,
|
|
1, 0, 0, 0, 4741, 4738, 1, 0, 0, 0, 4742, 4745, 1, 0, 0, 0, 4743, 4741,
|
|
1, 0, 0, 0, 4743, 4744, 1, 0, 0, 0, 4744, 4749, 1, 0, 0, 0, 4745, 4743,
|
|
1, 0, 0, 0, 4746, 4748, 3, 420, 210, 0, 4747, 4746, 1, 0, 0, 0, 4748, 4751,
|
|
1, 0, 0, 0, 4749, 4747, 1, 0, 0, 0, 4749, 4750, 1, 0, 0, 0, 4750, 4752,
|
|
1, 0, 0, 0, 4751, 4749, 1, 0, 0, 0, 4752, 4754, 5, 407, 0, 0, 4753, 4755,
|
|
3, 584, 292, 0, 4754, 4753, 1, 0, 0, 0, 4754, 4755, 1, 0, 0, 0, 4755, 391,
|
|
1, 0, 0, 0, 4756, 4759, 5, 22, 0, 0, 4757, 4760, 3, 584, 292, 0, 4758,
|
|
4760, 3, 688, 344, 0, 4759, 4757, 1, 0, 0, 0, 4759, 4758, 1, 0, 0, 0, 4759,
|
|
4760, 1, 0, 0, 0, 4760, 4762, 1, 0, 0, 0, 4761, 4763, 3, 422, 211, 0, 4762,
|
|
4761, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764,
|
|
4765, 1, 0, 0, 0, 4765, 4772, 1, 0, 0, 0, 4766, 4768, 5, 53, 0, 0, 4767,
|
|
4769, 3, 420, 210, 0, 4768, 4767, 1, 0, 0, 0, 4769, 4770, 1, 0, 0, 0, 4770,
|
|
4768, 1, 0, 0, 0, 4770, 4771, 1, 0, 0, 0, 4771, 4773, 1, 0, 0, 0, 4772,
|
|
4766, 1, 0, 0, 0, 4772, 4773, 1, 0, 0, 0, 4773, 4774, 1, 0, 0, 0, 4774,
|
|
4775, 5, 407, 0, 0, 4775, 4776, 5, 22, 0, 0, 4776, 393, 1, 0, 0, 0, 4777,
|
|
4778, 5, 77, 0, 0, 4778, 4779, 3, 688, 344, 0, 4779, 4781, 5, 174, 0, 0,
|
|
4780, 4782, 3, 420, 210, 0, 4781, 4780, 1, 0, 0, 0, 4782, 4783, 1, 0, 0,
|
|
0, 4783, 4781, 1, 0, 0, 0, 4783, 4784, 1, 0, 0, 0, 4784, 4788, 1, 0, 0,
|
|
0, 4785, 4787, 3, 424, 212, 0, 4786, 4785, 1, 0, 0, 0, 4787, 4790, 1, 0,
|
|
0, 0, 4788, 4786, 1, 0, 0, 0, 4788, 4789, 1, 0, 0, 0, 4789, 4797, 1, 0,
|
|
0, 0, 4790, 4788, 1, 0, 0, 0, 4791, 4793, 5, 53, 0, 0, 4792, 4794, 3, 420,
|
|
210, 0, 4793, 4792, 1, 0, 0, 0, 4794, 4795, 1, 0, 0, 0, 4795, 4793, 1,
|
|
0, 0, 0, 4795, 4796, 1, 0, 0, 0, 4796, 4798, 1, 0, 0, 0, 4797, 4791, 1,
|
|
0, 0, 0, 4797, 4798, 1, 0, 0, 0, 4798, 4799, 1, 0, 0, 0, 4799, 4800, 5,
|
|
407, 0, 0, 4800, 4801, 5, 77, 0, 0, 4801, 395, 1, 0, 0, 0, 4802, 4803,
|
|
5, 89, 0, 0, 4803, 4804, 3, 584, 292, 0, 4804, 397, 1, 0, 0, 0, 4805, 4806,
|
|
5, 96, 0, 0, 4806, 4807, 3, 584, 292, 0, 4807, 399, 1, 0, 0, 0, 4808, 4809,
|
|
3, 584, 292, 0, 4809, 4810, 5, 1144, 0, 0, 4810, 4812, 1, 0, 0, 0, 4811,
|
|
4808, 1, 0, 0, 0, 4811, 4812, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813,
|
|
4815, 5, 105, 0, 0, 4814, 4816, 3, 420, 210, 0, 4815, 4814, 1, 0, 0, 0,
|
|
4816, 4817, 1, 0, 0, 0, 4817, 4815, 1, 0, 0, 0, 4817, 4818, 1, 0, 0, 0,
|
|
4818, 4819, 1, 0, 0, 0, 4819, 4820, 5, 407, 0, 0, 4820, 4822, 5, 105, 0,
|
|
0, 4821, 4823, 3, 584, 292, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0,
|
|
0, 0, 4823, 401, 1, 0, 0, 0, 4824, 4825, 3, 584, 292, 0, 4825, 4826, 5,
|
|
1144, 0, 0, 4826, 4828, 1, 0, 0, 0, 4827, 4824, 1, 0, 0, 0, 4827, 4828,
|
|
1, 0, 0, 0, 4828, 4829, 1, 0, 0, 0, 4829, 4831, 5, 140, 0, 0, 4830, 4832,
|
|
3, 420, 210, 0, 4831, 4830, 1, 0, 0, 0, 4832, 4833, 1, 0, 0, 0, 4833, 4831,
|
|
1, 0, 0, 0, 4833, 4834, 1, 0, 0, 0, 4834, 4835, 1, 0, 0, 0, 4835, 4836,
|
|
5, 663, 0, 0, 4836, 4837, 3, 688, 344, 0, 4837, 4838, 5, 407, 0, 0, 4838,
|
|
4840, 5, 140, 0, 0, 4839, 4841, 3, 584, 292, 0, 4840, 4839, 1, 0, 0, 0,
|
|
4840, 4841, 1, 0, 0, 0, 4841, 403, 1, 0, 0, 0, 4842, 4843, 5, 146, 0, 0,
|
|
4843, 4844, 3, 688, 344, 0, 4844, 405, 1, 0, 0, 0, 4845, 4846, 3, 584,
|
|
292, 0, 4846, 4847, 5, 1144, 0, 0, 4847, 4849, 1, 0, 0, 0, 4848, 4845,
|
|
1, 0, 0, 0, 4848, 4849, 1, 0, 0, 0, 4849, 4850, 1, 0, 0, 0, 4850, 4851,
|
|
5, 191, 0, 0, 4851, 4852, 3, 688, 344, 0, 4852, 4854, 5, 399, 0, 0, 4853,
|
|
4855, 3, 420, 210, 0, 4854, 4853, 1, 0, 0, 0, 4855, 4856, 1, 0, 0, 0, 4856,
|
|
4854, 1, 0, 0, 0, 4856, 4857, 1, 0, 0, 0, 4857, 4858, 1, 0, 0, 0, 4858,
|
|
4859, 5, 407, 0, 0, 4859, 4861, 5, 191, 0, 0, 4860, 4862, 3, 584, 292,
|
|
0, 4861, 4860, 1, 0, 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 407, 1, 0, 0,
|
|
0, 4863, 4864, 5, 361, 0, 0, 4864, 4879, 3, 584, 292, 0, 4865, 4870, 5,
|
|
64, 0, 0, 4866, 4868, 5, 520, 0, 0, 4867, 4866, 1, 0, 0, 0, 4867, 4868,
|
|
1, 0, 0, 0, 4868, 4869, 1, 0, 0, 0, 4869, 4871, 5, 68, 0, 0, 4870, 4867,
|
|
1, 0, 0, 0, 4870, 4871, 1, 0, 0, 0, 4871, 4872, 1, 0, 0, 0, 4872, 4873,
|
|
3, 584, 292, 0, 4873, 4874, 5, 87, 0, 0, 4874, 4875, 3, 616, 308, 0, 4875,
|
|
4879, 1, 0, 0, 0, 4876, 4877, 5, 539, 0, 0, 4877, 4879, 3, 584, 292, 0,
|
|
4878, 4863, 1, 0, 0, 0, 4878, 4865, 1, 0, 0, 0, 4878, 4876, 1, 0, 0, 0,
|
|
4879, 409, 1, 0, 0, 0, 4880, 4881, 5, 41, 0, 0, 4881, 4882, 3, 616, 308,
|
|
0, 4882, 4885, 3, 604, 302, 0, 4883, 4884, 5, 42, 0, 0, 4884, 4886, 3,
|
|
688, 344, 0, 4885, 4883, 1, 0, 0, 0, 4885, 4886, 1, 0, 0, 0, 4886, 411,
|
|
1, 0, 0, 0, 4887, 4888, 5, 41, 0, 0, 4888, 4889, 3, 584, 292, 0, 4889,
|
|
4890, 5, 29, 0, 0, 4890, 4897, 5, 65, 0, 0, 4891, 4898, 3, 590, 295, 0,
|
|
4892, 4894, 5, 162, 0, 0, 4893, 4895, 5, 669, 0, 0, 4894, 4893, 1, 0, 0,
|
|
0, 4894, 4895, 1, 0, 0, 0, 4895, 4896, 1, 0, 0, 0, 4896, 4898, 5, 1148,
|
|
0, 0, 4897, 4891, 1, 0, 0, 0, 4897, 4892, 1, 0, 0, 0, 4898, 413, 1, 0,
|
|
0, 0, 4899, 4900, 5, 41, 0, 0, 4900, 4901, 3, 584, 292, 0, 4901, 4902,
|
|
5, 38, 0, 0, 4902, 4903, 5, 65, 0, 0, 4903, 4904, 3, 200, 100, 0, 4904,
|
|
415, 1, 0, 0, 0, 4905, 4906, 5, 41, 0, 0, 4906, 4907, 7, 65, 0, 0, 4907,
|
|
4908, 5, 442, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, 4914, 3, 418, 209, 0,
|
|
4910, 4911, 5, 1135, 0, 0, 4911, 4913, 3, 418, 209, 0, 4912, 4910, 1, 0,
|
|
0, 0, 4913, 4916, 1, 0, 0, 0, 4914, 4912, 1, 0, 0, 0, 4914, 4915, 1, 0,
|
|
0, 0, 4915, 4917, 1, 0, 0, 0, 4916, 4914, 1, 0, 0, 0, 4917, 4918, 3, 388,
|
|
194, 0, 4918, 417, 1, 0, 0, 0, 4919, 4931, 3, 590, 295, 0, 4920, 4922,
|
|
5, 162, 0, 0, 4921, 4923, 5, 669, 0, 0, 4922, 4921, 1, 0, 0, 0, 4922, 4923,
|
|
1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4931, 5, 1148, 0, 0, 4925, 4931,
|
|
3, 584, 292, 0, 4926, 4931, 5, 163, 0, 0, 4927, 4928, 5, 114, 0, 0, 4928,
|
|
4931, 5, 435, 0, 0, 4929, 4931, 5, 161, 0, 0, 4930, 4919, 1, 0, 0, 0, 4930,
|
|
4920, 1, 0, 0, 0, 4930, 4925, 1, 0, 0, 0, 4930, 4926, 1, 0, 0, 0, 4930,
|
|
4927, 1, 0, 0, 0, 4930, 4929, 1, 0, 0, 0, 4931, 419, 1, 0, 0, 0, 4932,
|
|
4935, 3, 18, 9, 0, 4933, 4935, 3, 4, 2, 0, 4934, 4932, 1, 0, 0, 0, 4934,
|
|
4933, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, 4937, 5, 1136, 0, 0, 4937,
|
|
421, 1, 0, 0, 0, 4938, 4941, 5, 189, 0, 0, 4939, 4942, 3, 602, 301, 0,
|
|
4940, 4942, 3, 688, 344, 0, 4941, 4939, 1, 0, 0, 0, 4941, 4940, 1, 0, 0,
|
|
0, 4942, 4943, 1, 0, 0, 0, 4943, 4945, 5, 174, 0, 0, 4944, 4946, 3, 420,
|
|
210, 0, 4945, 4944, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 4945, 1,
|
|
0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 423, 1, 0, 0, 0, 4949, 4950, 5,
|
|
54, 0, 0, 4950, 4951, 3, 688, 344, 0, 4951, 4953, 5, 174, 0, 0, 4952, 4954,
|
|
3, 420, 210, 0, 4953, 4952, 1, 0, 0, 0, 4954, 4955, 1, 0, 0, 0, 4955, 4953,
|
|
1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 425, 1, 0, 0, 0, 4957, 4958,
|
|
5, 7, 0, 0, 4958, 4959, 5, 665, 0, 0, 4959, 4964, 3, 446, 223, 0, 4960,
|
|
4961, 5, 1135, 0, 0, 4961, 4963, 3, 446, 223, 0, 4962, 4960, 1, 0, 0, 0,
|
|
4963, 4966, 1, 0, 0, 0, 4964, 4962, 1, 0, 0, 0, 4964, 4965, 1, 0, 0, 0,
|
|
4965, 5031, 1, 0, 0, 0, 4966, 4964, 1, 0, 0, 0, 4967, 4968, 5, 7, 0, 0,
|
|
4968, 4970, 5, 665, 0, 0, 4969, 4971, 3, 640, 320, 0, 4970, 4969, 1, 0,
|
|
0, 0, 4970, 4971, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4977, 3, 448,
|
|
224, 0, 4973, 4974, 5, 1135, 0, 0, 4974, 4976, 3, 448, 224, 0, 4975, 4973,
|
|
1, 0, 0, 0, 4976, 4979, 1, 0, 0, 0, 4977, 4975, 1, 0, 0, 0, 4977, 4978,
|
|
1, 0, 0, 0, 4978, 4994, 1, 0, 0, 0, 4979, 4977, 1, 0, 0, 0, 4980, 4992,
|
|
5, 142, 0, 0, 4981, 4993, 5, 529, 0, 0, 4982, 4989, 3, 454, 227, 0, 4983,
|
|
4985, 5, 10, 0, 0, 4984, 4983, 1, 0, 0, 0, 4984, 4985, 1, 0, 0, 0, 4985,
|
|
4986, 1, 0, 0, 0, 4986, 4988, 3, 454, 227, 0, 4987, 4984, 1, 0, 0, 0, 4988,
|
|
4991, 1, 0, 0, 0, 4989, 4987, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990,
|
|
4993, 1, 0, 0, 0, 4991, 4989, 1, 0, 0, 0, 4992, 4981, 1, 0, 0, 0, 4992,
|
|
4982, 1, 0, 0, 0, 4993, 4995, 1, 0, 0, 0, 4994, 4980, 1, 0, 0, 0, 4994,
|
|
4995, 1, 0, 0, 0, 4995, 5002, 1, 0, 0, 0, 4996, 4998, 5, 192, 0, 0, 4997,
|
|
4999, 3, 456, 228, 0, 4998, 4997, 1, 0, 0, 0, 4999, 5000, 1, 0, 0, 0, 5000,
|
|
4998, 1, 0, 0, 0, 5000, 5001, 1, 0, 0, 0, 5001, 5003, 1, 0, 0, 0, 5002,
|
|
4996, 1, 0, 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5008, 1, 0, 0, 0, 5004,
|
|
5007, 3, 458, 229, 0, 5005, 5007, 3, 460, 230, 0, 5006, 5004, 1, 0, 0,
|
|
0, 5006, 5005, 1, 0, 0, 0, 5007, 5010, 1, 0, 0, 0, 5008, 5006, 1, 0, 0,
|
|
0, 5008, 5009, 1, 0, 0, 0, 5009, 5015, 1, 0, 0, 0, 5010, 5008, 1, 0, 0,
|
|
0, 5011, 5012, 5, 368, 0, 0, 5012, 5016, 5, 1148, 0, 0, 5013, 5014, 5,
|
|
14, 0, 0, 5014, 5016, 5, 1148, 0, 0, 5015, 5011, 1, 0, 0, 0, 5015, 5013,
|
|
1, 0, 0, 0, 5015, 5016, 1, 0, 0, 0, 5016, 5031, 1, 0, 0, 0, 5017, 5018,
|
|
5, 7, 0, 0, 5018, 5020, 5, 665, 0, 0, 5019, 5021, 3, 640, 320, 0, 5020,
|
|
5019, 1, 0, 0, 0, 5020, 5021, 1, 0, 0, 0, 5021, 5024, 1, 0, 0, 0, 5022,
|
|
5025, 3, 564, 282, 0, 5023, 5025, 3, 584, 292, 0, 5024, 5022, 1, 0, 0,
|
|
0, 5024, 5023, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5027, 5, 42, 0,
|
|
0, 5027, 5028, 5, 596, 0, 0, 5028, 5029, 3, 434, 217, 0, 5029, 5031, 1,
|
|
0, 0, 0, 5030, 4957, 1, 0, 0, 0, 5030, 4967, 1, 0, 0, 0, 5030, 5017, 1,
|
|
0, 0, 0, 5031, 427, 1, 0, 0, 0, 5032, 5033, 5, 33, 0, 0, 5033, 5034, 5,
|
|
665, 0, 0, 5034, 5039, 3, 448, 224, 0, 5035, 5036, 5, 1135, 0, 0, 5036,
|
|
5038, 3, 448, 224, 0, 5037, 5035, 1, 0, 0, 0, 5038, 5041, 1, 0, 0, 0, 5039,
|
|
5037, 1, 0, 0, 0, 5039, 5040, 1, 0, 0, 0, 5040, 5098, 1, 0, 0, 0, 5041,
|
|
5039, 1, 0, 0, 0, 5042, 5043, 5, 33, 0, 0, 5043, 5045, 5, 665, 0, 0, 5044,
|
|
5046, 3, 642, 321, 0, 5045, 5044, 1, 0, 0, 0, 5045, 5046, 1, 0, 0, 0, 5046,
|
|
5047, 1, 0, 0, 0, 5047, 5052, 3, 448, 224, 0, 5048, 5049, 5, 1135, 0, 0,
|
|
5049, 5051, 3, 448, 224, 0, 5050, 5048, 1, 0, 0, 0, 5051, 5054, 1, 0, 0,
|
|
0, 5052, 5050, 1, 0, 0, 0, 5052, 5053, 1, 0, 0, 0, 5053, 5058, 1, 0, 0,
|
|
0, 5054, 5052, 1, 0, 0, 0, 5055, 5056, 5, 42, 0, 0, 5056, 5057, 5, 596,
|
|
0, 0, 5057, 5059, 3, 434, 217, 0, 5058, 5055, 1, 0, 0, 0, 5058, 5059, 1,
|
|
0, 0, 0, 5059, 5074, 1, 0, 0, 0, 5060, 5072, 5, 142, 0, 0, 5061, 5073,
|
|
5, 529, 0, 0, 5062, 5069, 3, 454, 227, 0, 5063, 5065, 5, 10, 0, 0, 5064,
|
|
5063, 1, 0, 0, 0, 5064, 5065, 1, 0, 0, 0, 5065, 5066, 1, 0, 0, 0, 5066,
|
|
5068, 3, 454, 227, 0, 5067, 5064, 1, 0, 0, 0, 5068, 5071, 1, 0, 0, 0, 5069,
|
|
5067, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5073, 1, 0, 0, 0, 5071,
|
|
5069, 1, 0, 0, 0, 5072, 5061, 1, 0, 0, 0, 5072, 5062, 1, 0, 0, 0, 5073,
|
|
5075, 1, 0, 0, 0, 5074, 5060, 1, 0, 0, 0, 5074, 5075, 1, 0, 0, 0, 5075,
|
|
5082, 1, 0, 0, 0, 5076, 5078, 5, 192, 0, 0, 5077, 5079, 3, 456, 228, 0,
|
|
5078, 5077, 1, 0, 0, 0, 5079, 5080, 1, 0, 0, 0, 5080, 5078, 1, 0, 0, 0,
|
|
5080, 5081, 1, 0, 0, 0, 5081, 5083, 1, 0, 0, 0, 5082, 5076, 1, 0, 0, 0,
|
|
5082, 5083, 1, 0, 0, 0, 5083, 5088, 1, 0, 0, 0, 5084, 5087, 3, 458, 229,
|
|
0, 5085, 5087, 3, 460, 230, 0, 5086, 5084, 1, 0, 0, 0, 5086, 5085, 1, 0,
|
|
0, 0, 5087, 5090, 1, 0, 0, 0, 5088, 5086, 1, 0, 0, 0, 5088, 5089, 1, 0,
|
|
0, 0, 5089, 5095, 1, 0, 0, 0, 5090, 5088, 1, 0, 0, 0, 5091, 5092, 5, 368,
|
|
0, 0, 5092, 5096, 5, 1148, 0, 0, 5093, 5094, 5, 14, 0, 0, 5094, 5096, 5,
|
|
1148, 0, 0, 5095, 5091, 1, 0, 0, 0, 5095, 5093, 1, 0, 0, 0, 5095, 5096,
|
|
1, 0, 0, 0, 5096, 5098, 1, 0, 0, 0, 5097, 5032, 1, 0, 0, 0, 5097, 5042,
|
|
1, 0, 0, 0, 5098, 429, 1, 0, 0, 0, 5099, 5100, 5, 51, 0, 0, 5100, 5102,
|
|
5, 665, 0, 0, 5101, 5103, 3, 640, 320, 0, 5102, 5101, 1, 0, 0, 0, 5102,
|
|
5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5109, 3, 564, 282, 0, 5105,
|
|
5106, 5, 1135, 0, 0, 5106, 5108, 3, 564, 282, 0, 5107, 5105, 1, 0, 0, 0,
|
|
5108, 5111, 1, 0, 0, 0, 5109, 5107, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0,
|
|
5110, 431, 1, 0, 0, 0, 5111, 5109, 1, 0, 0, 0, 5112, 5113, 5, 72, 0, 0,
|
|
5113, 5118, 3, 462, 231, 0, 5114, 5115, 5, 1135, 0, 0, 5115, 5117, 3, 462,
|
|
231, 0, 5116, 5114, 1, 0, 0, 0, 5117, 5120, 1, 0, 0, 0, 5118, 5116, 1,
|
|
0, 0, 0, 5118, 5119, 1, 0, 0, 0, 5119, 5121, 1, 0, 0, 0, 5120, 5118, 1,
|
|
0, 0, 0, 5121, 5123, 5, 118, 0, 0, 5122, 5124, 7, 66, 0, 0, 5123, 5122,
|
|
1, 0, 0, 0, 5123, 5124, 1, 0, 0, 0, 5124, 5125, 1, 0, 0, 0, 5125, 5126,
|
|
3, 466, 233, 0, 5126, 5127, 5, 175, 0, 0, 5127, 5132, 3, 448, 224, 0, 5128,
|
|
5129, 5, 1135, 0, 0, 5129, 5131, 3, 448, 224, 0, 5130, 5128, 1, 0, 0, 0,
|
|
5131, 5134, 1, 0, 0, 0, 5132, 5130, 1, 0, 0, 0, 5132, 5133, 1, 0, 0, 0,
|
|
5133, 5149, 1, 0, 0, 0, 5134, 5132, 1, 0, 0, 0, 5135, 5147, 5, 142, 0,
|
|
0, 5136, 5148, 5, 529, 0, 0, 5137, 5144, 3, 454, 227, 0, 5138, 5140, 5,
|
|
10, 0, 0, 5139, 5138, 1, 0, 0, 0, 5139, 5140, 1, 0, 0, 0, 5140, 5141, 1,
|
|
0, 0, 0, 5141, 5143, 3, 454, 227, 0, 5142, 5139, 1, 0, 0, 0, 5143, 5146,
|
|
1, 0, 0, 0, 5144, 5142, 1, 0, 0, 0, 5144, 5145, 1, 0, 0, 0, 5145, 5148,
|
|
1, 0, 0, 0, 5146, 5144, 1, 0, 0, 0, 5147, 5136, 1, 0, 0, 0, 5147, 5137,
|
|
1, 0, 0, 0, 5148, 5150, 1, 0, 0, 0, 5149, 5135, 1, 0, 0, 0, 5149, 5150,
|
|
1, 0, 0, 0, 5150, 5160, 1, 0, 0, 0, 5151, 5157, 5, 192, 0, 0, 5152, 5153,
|
|
5, 72, 0, 0, 5153, 5156, 5, 120, 0, 0, 5154, 5156, 3, 456, 228, 0, 5155,
|
|
5152, 1, 0, 0, 0, 5155, 5154, 1, 0, 0, 0, 5156, 5159, 1, 0, 0, 0, 5157,
|
|
5155, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, 0, 5158, 5161, 1, 0, 0, 0, 5159,
|
|
5157, 1, 0, 0, 0, 5160, 5151, 1, 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161,
|
|
5168, 1, 0, 0, 0, 5162, 5163, 5, 12, 0, 0, 5163, 5164, 3, 564, 282, 0,
|
|
5164, 5165, 5, 192, 0, 0, 5165, 5166, 5, 596, 0, 0, 5166, 5167, 3, 434,
|
|
217, 0, 5167, 5169, 1, 0, 0, 0, 5168, 5162, 1, 0, 0, 0, 5168, 5169, 1,
|
|
0, 0, 0, 5169, 5206, 1, 0, 0, 0, 5170, 5173, 5, 72, 0, 0, 5171, 5174, 3,
|
|
564, 282, 0, 5172, 5174, 3, 584, 292, 0, 5173, 5171, 1, 0, 0, 0, 5173,
|
|
5172, 1, 0, 0, 0, 5174, 5182, 1, 0, 0, 0, 5175, 5178, 5, 1135, 0, 0, 5176,
|
|
5179, 3, 564, 282, 0, 5177, 5179, 3, 584, 292, 0, 5178, 5176, 1, 0, 0,
|
|
0, 5178, 5177, 1, 0, 0, 0, 5179, 5181, 1, 0, 0, 0, 5180, 5175, 1, 0, 0,
|
|
0, 5181, 5184, 1, 0, 0, 0, 5182, 5180, 1, 0, 0, 0, 5182, 5183, 1, 0, 0,
|
|
0, 5183, 5185, 1, 0, 0, 0, 5184, 5182, 1, 0, 0, 0, 5185, 5188, 5, 175,
|
|
0, 0, 5186, 5189, 3, 564, 282, 0, 5187, 5189, 3, 584, 292, 0, 5188, 5186,
|
|
1, 0, 0, 0, 5188, 5187, 1, 0, 0, 0, 5189, 5197, 1, 0, 0, 0, 5190, 5193,
|
|
5, 1135, 0, 0, 5191, 5194, 3, 564, 282, 0, 5192, 5194, 3, 584, 292, 0,
|
|
5193, 5191, 1, 0, 0, 0, 5193, 5192, 1, 0, 0, 0, 5194, 5196, 1, 0, 0, 0,
|
|
5195, 5190, 1, 0, 0, 0, 5196, 5199, 1, 0, 0, 0, 5197, 5195, 1, 0, 0, 0,
|
|
5197, 5198, 1, 0, 0, 0, 5198, 5203, 1, 0, 0, 0, 5199, 5197, 1, 0, 0, 0,
|
|
5200, 5201, 5, 192, 0, 0, 5201, 5202, 5, 697, 0, 0, 5202, 5204, 5, 120,
|
|
0, 0, 5203, 5200, 1, 0, 0, 0, 5203, 5204, 1, 0, 0, 0, 5204, 5206, 1, 0,
|
|
0, 0, 5205, 5112, 1, 0, 0, 0, 5205, 5170, 1, 0, 0, 0, 5206, 433, 1, 0,
|
|
0, 0, 5207, 5230, 5, 42, 0, 0, 5208, 5230, 5, 529, 0, 0, 5209, 5219, 5,
|
|
6, 0, 0, 5210, 5211, 5, 59, 0, 0, 5211, 5216, 3, 564, 282, 0, 5212, 5213,
|
|
5, 1135, 0, 0, 5213, 5215, 3, 564, 282, 0, 5214, 5212, 1, 0, 0, 0, 5215,
|
|
5218, 1, 0, 0, 0, 5216, 5214, 1, 0, 0, 0, 5216, 5217, 1, 0, 0, 0, 5217,
|
|
5220, 1, 0, 0, 0, 5218, 5216, 1, 0, 0, 0, 5219, 5210, 1, 0, 0, 0, 5219,
|
|
5220, 1, 0, 0, 0, 5220, 5230, 1, 0, 0, 0, 5221, 5226, 3, 564, 282, 0, 5222,
|
|
5223, 5, 1135, 0, 0, 5223, 5225, 3, 564, 282, 0, 5224, 5222, 1, 0, 0, 0,
|
|
5225, 5228, 1, 0, 0, 0, 5226, 5224, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0,
|
|
5227, 5230, 1, 0, 0, 0, 5228, 5226, 1, 0, 0, 0, 5229, 5207, 1, 0, 0, 0,
|
|
5229, 5208, 1, 0, 0, 0, 5229, 5209, 1, 0, 0, 0, 5229, 5221, 1, 0, 0, 0,
|
|
5230, 435, 1, 0, 0, 0, 5231, 5232, 5, 72, 0, 0, 5232, 5233, 5, 566, 0,
|
|
0, 5233, 5234, 5, 118, 0, 0, 5234, 5235, 3, 564, 282, 0, 5235, 5236, 5,
|
|
175, 0, 0, 5236, 5241, 3, 564, 282, 0, 5237, 5238, 5, 1135, 0, 0, 5238,
|
|
5240, 3, 564, 282, 0, 5239, 5237, 1, 0, 0, 0, 5240, 5243, 1, 0, 0, 0, 5241,
|
|
5239, 1, 0, 0, 0, 5241, 5242, 1, 0, 0, 0, 5242, 5247, 1, 0, 0, 0, 5243,
|
|
5241, 1, 0, 0, 0, 5244, 5245, 5, 192, 0, 0, 5245, 5246, 5, 72, 0, 0, 5246,
|
|
5248, 5, 120, 0, 0, 5247, 5244, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248,
|
|
437, 1, 0, 0, 0, 5249, 5250, 5, 139, 0, 0, 5250, 5251, 5, 665, 0, 0, 5251,
|
|
5256, 3, 468, 234, 0, 5252, 5253, 5, 1135, 0, 0, 5253, 5255, 3, 468, 234,
|
|
0, 5254, 5252, 1, 0, 0, 0, 5255, 5258, 1, 0, 0, 0, 5256, 5254, 1, 0, 0,
|
|
0, 5256, 5257, 1, 0, 0, 0, 5257, 439, 1, 0, 0, 0, 5258, 5256, 1, 0, 0,
|
|
0, 5259, 5260, 5, 147, 0, 0, 5260, 5265, 3, 462, 231, 0, 5261, 5262, 5,
|
|
1135, 0, 0, 5262, 5264, 3, 462, 231, 0, 5263, 5261, 1, 0, 0, 0, 5264, 5267,
|
|
1, 0, 0, 0, 5265, 5263, 1, 0, 0, 0, 5265, 5266, 1, 0, 0, 0, 5266, 5268,
|
|
1, 0, 0, 0, 5267, 5265, 1, 0, 0, 0, 5268, 5270, 5, 118, 0, 0, 5269, 5271,
|
|
7, 66, 0, 0, 5270, 5269, 1, 0, 0, 0, 5270, 5271, 1, 0, 0, 0, 5271, 5272,
|
|
1, 0, 0, 0, 5272, 5273, 3, 466, 233, 0, 5273, 5274, 5, 68, 0, 0, 5274,
|
|
5279, 3, 564, 282, 0, 5275, 5276, 5, 1135, 0, 0, 5276, 5278, 3, 564, 282,
|
|
0, 5277, 5275, 1, 0, 0, 0, 5278, 5281, 1, 0, 0, 0, 5279, 5277, 1, 0, 0,
|
|
0, 5279, 5280, 1, 0, 0, 0, 5280, 5330, 1, 0, 0, 0, 5281, 5279, 1, 0, 0,
|
|
0, 5282, 5283, 5, 147, 0, 0, 5283, 5285, 5, 6, 0, 0, 5284, 5286, 5, 725,
|
|
0, 0, 5285, 5284, 1, 0, 0, 0, 5285, 5286, 1, 0, 0, 0, 5286, 5287, 1, 0,
|
|
0, 0, 5287, 5288, 5, 1135, 0, 0, 5288, 5289, 5, 72, 0, 0, 5289, 5290, 5,
|
|
120, 0, 0, 5290, 5291, 5, 68, 0, 0, 5291, 5296, 3, 564, 282, 0, 5292, 5293,
|
|
5, 1135, 0, 0, 5293, 5295, 3, 564, 282, 0, 5294, 5292, 1, 0, 0, 0, 5295,
|
|
5298, 1, 0, 0, 0, 5296, 5294, 1, 0, 0, 0, 5296, 5297, 1, 0, 0, 0, 5297,
|
|
5330, 1, 0, 0, 0, 5298, 5296, 1, 0, 0, 0, 5299, 5302, 5, 147, 0, 0, 5300,
|
|
5303, 3, 564, 282, 0, 5301, 5303, 3, 584, 292, 0, 5302, 5300, 1, 0, 0,
|
|
0, 5302, 5301, 1, 0, 0, 0, 5303, 5311, 1, 0, 0, 0, 5304, 5307, 5, 1135,
|
|
0, 0, 5305, 5308, 3, 564, 282, 0, 5306, 5308, 3, 584, 292, 0, 5307, 5305,
|
|
1, 0, 0, 0, 5307, 5306, 1, 0, 0, 0, 5308, 5310, 1, 0, 0, 0, 5309, 5304,
|
|
1, 0, 0, 0, 5310, 5313, 1, 0, 0, 0, 5311, 5309, 1, 0, 0, 0, 5311, 5312,
|
|
1, 0, 0, 0, 5312, 5314, 1, 0, 0, 0, 5313, 5311, 1, 0, 0, 0, 5314, 5317,
|
|
5, 68, 0, 0, 5315, 5318, 3, 564, 282, 0, 5316, 5318, 3, 584, 292, 0, 5317,
|
|
5315, 1, 0, 0, 0, 5317, 5316, 1, 0, 0, 0, 5318, 5326, 1, 0, 0, 0, 5319,
|
|
5322, 5, 1135, 0, 0, 5320, 5323, 3, 564, 282, 0, 5321, 5323, 3, 584, 292,
|
|
0, 5322, 5320, 1, 0, 0, 0, 5322, 5321, 1, 0, 0, 0, 5323, 5325, 1, 0, 0,
|
|
0, 5324, 5319, 1, 0, 0, 0, 5325, 5328, 1, 0, 0, 0, 5326, 5324, 1, 0, 0,
|
|
0, 5326, 5327, 1, 0, 0, 0, 5327, 5330, 1, 0, 0, 0, 5328, 5326, 1, 0, 0,
|
|
0, 5329, 5259, 1, 0, 0, 0, 5329, 5282, 1, 0, 0, 0, 5329, 5299, 1, 0, 0,
|
|
0, 5330, 441, 1, 0, 0, 0, 5331, 5332, 5, 147, 0, 0, 5332, 5333, 5, 566,
|
|
0, 0, 5333, 5334, 5, 118, 0, 0, 5334, 5335, 3, 564, 282, 0, 5335, 5336,
|
|
5, 68, 0, 0, 5336, 5341, 3, 564, 282, 0, 5337, 5338, 5, 1135, 0, 0, 5338,
|
|
5340, 3, 564, 282, 0, 5339, 5337, 1, 0, 0, 0, 5340, 5343, 1, 0, 0, 0, 5341,
|
|
5339, 1, 0, 0, 0, 5341, 5342, 1, 0, 0, 0, 5342, 443, 1, 0, 0, 0, 5343,
|
|
5341, 1, 0, 0, 0, 5344, 5345, 5, 153, 0, 0, 5345, 5348, 5, 551, 0, 0, 5346,
|
|
5347, 5, 65, 0, 0, 5347, 5349, 3, 564, 282, 0, 5348, 5346, 1, 0, 0, 0,
|
|
5348, 5349, 1, 0, 0, 0, 5349, 5350, 1, 0, 0, 0, 5350, 5353, 5, 1124, 0,
|
|
0, 5351, 5354, 3, 682, 341, 0, 5352, 5354, 5, 1148, 0, 0, 5353, 5351, 1,
|
|
0, 0, 0, 5353, 5352, 1, 0, 0, 0, 5354, 445, 1, 0, 0, 0, 5355, 5356, 3,
|
|
564, 282, 0, 5356, 5357, 3, 458, 229, 0, 5357, 447, 1, 0, 0, 0, 5358, 5359,
|
|
3, 564, 282, 0, 5359, 5360, 5, 448, 0, 0, 5360, 5361, 5, 19, 0, 0, 5361,
|
|
5362, 5, 551, 0, 0, 5362, 5363, 5, 1148, 0, 0, 5363, 5384, 1, 0, 0, 0,
|
|
5364, 5365, 3, 564, 282, 0, 5365, 5366, 5, 448, 0, 0, 5366, 5367, 5, 19,
|
|
0, 0, 5367, 5368, 5, 991, 0, 0, 5368, 5369, 5, 551, 0, 0, 5369, 5370, 3,
|
|
450, 225, 0, 5370, 5384, 1, 0, 0, 0, 5371, 5372, 3, 564, 282, 0, 5372,
|
|
5373, 5, 448, 0, 0, 5373, 5374, 5, 19, 0, 0, 5374, 5375, 5, 1148, 0, 0,
|
|
5375, 5376, 3, 450, 225, 0, 5376, 5384, 1, 0, 0, 0, 5377, 5378, 3, 564,
|
|
282, 0, 5378, 5379, 5, 448, 0, 0, 5379, 5380, 5, 192, 0, 0, 5380, 5381,
|
|
3, 452, 226, 0, 5381, 5384, 1, 0, 0, 0, 5382, 5384, 3, 564, 282, 0, 5383,
|
|
5358, 1, 0, 0, 0, 5383, 5364, 1, 0, 0, 0, 5383, 5371, 1, 0, 0, 0, 5383,
|
|
5377, 1, 0, 0, 0, 5383, 5382, 1, 0, 0, 0, 5384, 449, 1, 0, 0, 0, 5385,
|
|
5386, 5, 141, 0, 0, 5386, 5388, 5, 1148, 0, 0, 5387, 5385, 1, 0, 0, 0,
|
|
5387, 5388, 1, 0, 0, 0, 5388, 5392, 1, 0, 0, 0, 5389, 5390, 5, 145, 0,
|
|
0, 5390, 5391, 5, 35, 0, 0, 5391, 5393, 5, 551, 0, 0, 5392, 5389, 1, 0,
|
|
0, 0, 5392, 5393, 1, 0, 0, 0, 5393, 451, 1, 0, 0, 0, 5394, 5402, 3, 582,
|
|
291, 0, 5395, 5399, 7, 67, 0, 0, 5396, 5400, 5, 1148, 0, 0, 5397, 5398,
|
|
5, 991, 0, 0, 5398, 5400, 5, 551, 0, 0, 5399, 5396, 1, 0, 0, 0, 5399, 5397,
|
|
1, 0, 0, 0, 5400, 5401, 1, 0, 0, 0, 5401, 5403, 3, 450, 225, 0, 5402, 5395,
|
|
1, 0, 0, 0, 5402, 5403, 1, 0, 0, 0, 5403, 5409, 1, 0, 0, 0, 5404, 5405,
|
|
3, 582, 291, 0, 5405, 5406, 5, 187, 0, 0, 5406, 5407, 3, 682, 341, 0, 5407,
|
|
5409, 1, 0, 0, 0, 5408, 5394, 1, 0, 0, 0, 5408, 5404, 1, 0, 0, 0, 5409,
|
|
453, 1, 0, 0, 0, 5410, 5419, 5, 167, 0, 0, 5411, 5419, 5, 680, 0, 0, 5412,
|
|
5413, 5, 358, 0, 0, 5413, 5419, 5, 1148, 0, 0, 5414, 5415, 5, 465, 0, 0,
|
|
5415, 5419, 5, 1148, 0, 0, 5416, 5417, 5, 640, 0, 0, 5417, 5419, 5, 1148,
|
|
0, 0, 5418, 5410, 1, 0, 0, 0, 5418, 5411, 1, 0, 0, 0, 5418, 5412, 1, 0,
|
|
0, 0, 5418, 5414, 1, 0, 0, 0, 5418, 5416, 1, 0, 0, 0, 5419, 455, 1, 0,
|
|
0, 0, 5420, 5421, 5, 499, 0, 0, 5421, 5429, 3, 590, 295, 0, 5422, 5423,
|
|
5, 502, 0, 0, 5423, 5429, 3, 590, 295, 0, 5424, 5425, 5, 498, 0, 0, 5425,
|
|
5429, 3, 590, 295, 0, 5426, 5427, 5, 503, 0, 0, 5427, 5429, 3, 590, 295,
|
|
0, 5428, 5420, 1, 0, 0, 0, 5428, 5422, 1, 0, 0, 0, 5428, 5424, 1, 0, 0,
|
|
0, 5428, 5426, 1, 0, 0, 0, 5429, 457, 1, 0, 0, 0, 5430, 5431, 5, 551, 0,
|
|
0, 5431, 5438, 5, 420, 0, 0, 5432, 5439, 5, 42, 0, 0, 5433, 5439, 5, 519,
|
|
0, 0, 5434, 5435, 5, 86, 0, 0, 5435, 5436, 3, 590, 295, 0, 5436, 5437,
|
|
5, 691, 0, 0, 5437, 5439, 1, 0, 0, 0, 5438, 5432, 1, 0, 0, 0, 5438, 5433,
|
|
1, 0, 0, 0, 5438, 5434, 1, 0, 0, 0, 5438, 5439, 1, 0, 0, 0, 5439, 5469,
|
|
1, 0, 0, 0, 5440, 5441, 5, 551, 0, 0, 5441, 5444, 5, 445, 0, 0, 5442, 5445,
|
|
5, 42, 0, 0, 5443, 5445, 3, 590, 295, 0, 5444, 5442, 1, 0, 0, 0, 5444,
|
|
5443, 1, 0, 0, 0, 5445, 5469, 1, 0, 0, 0, 5446, 5447, 5, 551, 0, 0, 5447,
|
|
5448, 5, 595, 0, 0, 5448, 5453, 5, 86, 0, 0, 5449, 5454, 5, 42, 0, 0, 5450,
|
|
5451, 3, 590, 295, 0, 5451, 5452, 5, 691, 0, 0, 5452, 5454, 1, 0, 0, 0,
|
|
5453, 5449, 1, 0, 0, 0, 5453, 5450, 1, 0, 0, 0, 5454, 5469, 1, 0, 0, 0,
|
|
5455, 5456, 5, 551, 0, 0, 5456, 5457, 5, 142, 0, 0, 5457, 5459, 5, 35,
|
|
0, 0, 5458, 5460, 7, 68, 0, 0, 5459, 5458, 1, 0, 0, 0, 5459, 5460, 1, 0,
|
|
0, 0, 5460, 5469, 1, 0, 0, 0, 5461, 5462, 5, 424, 0, 0, 5462, 5469, 3,
|
|
590, 295, 0, 5463, 5466, 5, 552, 0, 0, 5464, 5467, 3, 590, 295, 0, 5465,
|
|
5467, 5, 657, 0, 0, 5466, 5464, 1, 0, 0, 0, 5466, 5465, 1, 0, 0, 0, 5467,
|
|
5469, 1, 0, 0, 0, 5468, 5430, 1, 0, 0, 0, 5468, 5440, 1, 0, 0, 0, 5468,
|
|
5446, 1, 0, 0, 0, 5468, 5455, 1, 0, 0, 0, 5468, 5461, 1, 0, 0, 0, 5468,
|
|
5463, 1, 0, 0, 0, 5469, 459, 1, 0, 0, 0, 5470, 5471, 5, 332, 0, 0, 5471,
|
|
5472, 7, 69, 0, 0, 5472, 461, 1, 0, 0, 0, 5473, 5478, 3, 464, 232, 0, 5474,
|
|
5475, 5, 1133, 0, 0, 5475, 5476, 3, 616, 308, 0, 5476, 5477, 5, 1134, 0,
|
|
0, 5477, 5479, 1, 0, 0, 0, 5478, 5474, 1, 0, 0, 0, 5478, 5479, 1, 0, 0,
|
|
0, 5479, 463, 1, 0, 0, 0, 5480, 5482, 5, 6, 0, 0, 5481, 5483, 5, 725, 0,
|
|
0, 5482, 5481, 1, 0, 0, 0, 5482, 5483, 1, 0, 0, 0, 5483, 5574, 1, 0, 0,
|
|
0, 5484, 5486, 5, 7, 0, 0, 5485, 5487, 5, 733, 0, 0, 5486, 5485, 1, 0,
|
|
0, 0, 5486, 5487, 1, 0, 0, 0, 5487, 5574, 1, 0, 0, 0, 5488, 5496, 5, 33,
|
|
0, 0, 5489, 5490, 5, 649, 0, 0, 5490, 5497, 5, 742, 0, 0, 5491, 5497, 5,
|
|
733, 0, 0, 5492, 5497, 5, 671, 0, 0, 5493, 5497, 5, 665, 0, 0, 5494, 5497,
|
|
5, 647, 0, 0, 5495, 5497, 5, 596, 0, 0, 5496, 5489, 1, 0, 0, 0, 5496, 5491,
|
|
1, 0, 0, 0, 5496, 5492, 1, 0, 0, 0, 5496, 5493, 1, 0, 0, 0, 5496, 5494,
|
|
1, 0, 0, 0, 5496, 5495, 1, 0, 0, 0, 5496, 5497, 1, 0, 0, 0, 5497, 5574,
|
|
1, 0, 0, 0, 5498, 5574, 5, 44, 0, 0, 5499, 5501, 5, 51, 0, 0, 5500, 5502,
|
|
5, 596, 0, 0, 5501, 5500, 1, 0, 0, 0, 5501, 5502, 1, 0, 0, 0, 5502, 5574,
|
|
1, 0, 0, 0, 5503, 5574, 5, 415, 0, 0, 5504, 5574, 5, 708, 0, 0, 5505, 5574,
|
|
5, 709, 0, 0, 5506, 5507, 5, 72, 0, 0, 5507, 5574, 5, 120, 0, 0, 5508,
|
|
5574, 5, 81, 0, 0, 5509, 5574, 5, 85, 0, 0, 5510, 5511, 5, 103, 0, 0, 5511,
|
|
5574, 5, 742, 0, 0, 5512, 5574, 5, 726, 0, 0, 5513, 5574, 5, 566, 0, 0,
|
|
5514, 5574, 5, 136, 0, 0, 5515, 5574, 5, 727, 0, 0, 5516, 5517, 5, 588,
|
|
0, 0, 5517, 5574, 7, 70, 0, 0, 5518, 5574, 5, 152, 0, 0, 5519, 5520, 5,
|
|
155, 0, 0, 5520, 5574, 7, 71, 0, 0, 5521, 5574, 5, 739, 0, 0, 5522, 5574,
|
|
5, 740, 0, 0, 5523, 5574, 5, 177, 0, 0, 5524, 5574, 5, 184, 0, 0, 5525,
|
|
5574, 5, 185, 0, 0, 5526, 5574, 5, 698, 0, 0, 5527, 5574, 5, 699, 0, 0,
|
|
5528, 5574, 5, 700, 0, 0, 5529, 5574, 5, 701, 0, 0, 5530, 5574, 5, 702,
|
|
0, 0, 5531, 5574, 5, 703, 0, 0, 5532, 5574, 5, 704, 0, 0, 5533, 5574, 5,
|
|
705, 0, 0, 5534, 5574, 5, 706, 0, 0, 5535, 5574, 5, 707, 0, 0, 5536, 5574,
|
|
5, 710, 0, 0, 5537, 5574, 5, 711, 0, 0, 5538, 5574, 5, 712, 0, 0, 5539,
|
|
5574, 5, 713, 0, 0, 5540, 5574, 5, 714, 0, 0, 5541, 5574, 5, 715, 0, 0,
|
|
5542, 5574, 5, 716, 0, 0, 5543, 5574, 5, 717, 0, 0, 5544, 5574, 5, 718,
|
|
0, 0, 5545, 5574, 5, 719, 0, 0, 5546, 5574, 5, 722, 0, 0, 5547, 5574, 5,
|
|
723, 0, 0, 5548, 5574, 5, 724, 0, 0, 5549, 5574, 5, 728, 0, 0, 5550, 5574,
|
|
5, 729, 0, 0, 5551, 5574, 5, 730, 0, 0, 5552, 5574, 5, 731, 0, 0, 5553,
|
|
5574, 5, 732, 0, 0, 5554, 5574, 5, 735, 0, 0, 5555, 5574, 5, 736, 0, 0,
|
|
5556, 5574, 5, 737, 0, 0, 5557, 5574, 5, 158, 0, 0, 5558, 5574, 5, 738,
|
|
0, 0, 5559, 5574, 5, 1077, 0, 0, 5560, 5574, 5, 741, 0, 0, 5561, 5574,
|
|
5, 743, 0, 0, 5562, 5574, 5, 1088, 0, 0, 5563, 5574, 5, 744, 0, 0, 5564,
|
|
5574, 5, 745, 0, 0, 5565, 5566, 5, 102, 0, 0, 5566, 5567, 5, 68, 0, 0,
|
|
5567, 5574, 5, 734, 0, 0, 5568, 5569, 5, 152, 0, 0, 5569, 5570, 5, 87,
|
|
0, 0, 5570, 5574, 5, 734, 0, 0, 5571, 5572, 5, 720, 0, 0, 5572, 5574, 5,
|
|
721, 0, 0, 5573, 5480, 1, 0, 0, 0, 5573, 5484, 1, 0, 0, 0, 5573, 5488,
|
|
1, 0, 0, 0, 5573, 5498, 1, 0, 0, 0, 5573, 5499, 1, 0, 0, 0, 5573, 5503,
|
|
1, 0, 0, 0, 5573, 5504, 1, 0, 0, 0, 5573, 5505, 1, 0, 0, 0, 5573, 5506,
|
|
1, 0, 0, 0, 5573, 5508, 1, 0, 0, 0, 5573, 5509, 1, 0, 0, 0, 5573, 5510,
|
|
1, 0, 0, 0, 5573, 5512, 1, 0, 0, 0, 5573, 5513, 1, 0, 0, 0, 5573, 5514,
|
|
1, 0, 0, 0, 5573, 5515, 1, 0, 0, 0, 5573, 5516, 1, 0, 0, 0, 5573, 5518,
|
|
1, 0, 0, 0, 5573, 5519, 1, 0, 0, 0, 5573, 5521, 1, 0, 0, 0, 5573, 5522,
|
|
1, 0, 0, 0, 5573, 5523, 1, 0, 0, 0, 5573, 5524, 1, 0, 0, 0, 5573, 5525,
|
|
1, 0, 0, 0, 5573, 5526, 1, 0, 0, 0, 5573, 5527, 1, 0, 0, 0, 5573, 5528,
|
|
1, 0, 0, 0, 5573, 5529, 1, 0, 0, 0, 5573, 5530, 1, 0, 0, 0, 5573, 5531,
|
|
1, 0, 0, 0, 5573, 5532, 1, 0, 0, 0, 5573, 5533, 1, 0, 0, 0, 5573, 5534,
|
|
1, 0, 0, 0, 5573, 5535, 1, 0, 0, 0, 5573, 5536, 1, 0, 0, 0, 5573, 5537,
|
|
1, 0, 0, 0, 5573, 5538, 1, 0, 0, 0, 5573, 5539, 1, 0, 0, 0, 5573, 5540,
|
|
1, 0, 0, 0, 5573, 5541, 1, 0, 0, 0, 5573, 5542, 1, 0, 0, 0, 5573, 5543,
|
|
1, 0, 0, 0, 5573, 5544, 1, 0, 0, 0, 5573, 5545, 1, 0, 0, 0, 5573, 5546,
|
|
1, 0, 0, 0, 5573, 5547, 1, 0, 0, 0, 5573, 5548, 1, 0, 0, 0, 5573, 5549,
|
|
1, 0, 0, 0, 5573, 5550, 1, 0, 0, 0, 5573, 5551, 1, 0, 0, 0, 5573, 5552,
|
|
1, 0, 0, 0, 5573, 5553, 1, 0, 0, 0, 5573, 5554, 1, 0, 0, 0, 5573, 5555,
|
|
1, 0, 0, 0, 5573, 5556, 1, 0, 0, 0, 5573, 5557, 1, 0, 0, 0, 5573, 5558,
|
|
1, 0, 0, 0, 5573, 5559, 1, 0, 0, 0, 5573, 5560, 1, 0, 0, 0, 5573, 5561,
|
|
1, 0, 0, 0, 5573, 5562, 1, 0, 0, 0, 5573, 5563, 1, 0, 0, 0, 5573, 5564,
|
|
1, 0, 0, 0, 5573, 5565, 1, 0, 0, 0, 5573, 5568, 1, 0, 0, 0, 5573, 5571,
|
|
1, 0, 0, 0, 5574, 465, 1, 0, 0, 0, 5575, 5592, 5, 1117, 0, 0, 5576, 5577,
|
|
5, 1117, 0, 0, 5577, 5578, 5, 1132, 0, 0, 5578, 5592, 5, 1117, 0, 0, 5579,
|
|
5580, 3, 584, 292, 0, 5580, 5581, 5, 1132, 0, 0, 5581, 5582, 5, 1117, 0,
|
|
0, 5582, 5592, 1, 0, 0, 0, 5583, 5584, 3, 584, 292, 0, 5584, 5585, 5, 1132,
|
|
0, 0, 5585, 5586, 3, 584, 292, 0, 5586, 5592, 1, 0, 0, 0, 5587, 5588, 3,
|
|
584, 292, 0, 5588, 5589, 3, 588, 294, 0, 5589, 5592, 1, 0, 0, 0, 5590,
|
|
5592, 3, 584, 292, 0, 5591, 5575, 1, 0, 0, 0, 5591, 5576, 1, 0, 0, 0, 5591,
|
|
5579, 1, 0, 0, 0, 5591, 5583, 1, 0, 0, 0, 5591, 5587, 1, 0, 0, 0, 5591,
|
|
5590, 1, 0, 0, 0, 5592, 467, 1, 0, 0, 0, 5593, 5594, 3, 564, 282, 0, 5594,
|
|
5595, 5, 175, 0, 0, 5595, 5596, 3, 564, 282, 0, 5596, 469, 1, 0, 0, 0,
|
|
5597, 5599, 5, 9, 0, 0, 5598, 5600, 7, 72, 0, 0, 5599, 5598, 1, 0, 0, 0,
|
|
5599, 5600, 1, 0, 0, 0, 5600, 5601, 1, 0, 0, 0, 5601, 5602, 7, 54, 0, 0,
|
|
5602, 5620, 3, 620, 310, 0, 5603, 5604, 5, 184, 0, 0, 5604, 5605, 5, 76,
|
|
0, 0, 5605, 5606, 5, 118, 0, 0, 5606, 5611, 3, 556, 278, 0, 5607, 5608,
|
|
5, 1135, 0, 0, 5608, 5610, 3, 556, 278, 0, 5609, 5607, 1, 0, 0, 0, 5610,
|
|
5613, 1, 0, 0, 0, 5611, 5609, 1, 0, 0, 0, 5611, 5612, 1, 0, 0, 0, 5612,
|
|
5618, 1, 0, 0, 0, 5613, 5611, 1, 0, 0, 0, 5614, 5615, 5, 192, 0, 0, 5615,
|
|
5616, 3, 590, 295, 0, 5616, 5617, 5, 18, 0, 0, 5617, 5619, 1, 0, 0, 0,
|
|
5618, 5614, 1, 0, 0, 0, 5618, 5619, 1, 0, 0, 0, 5619, 5621, 1, 0, 0, 0,
|
|
5620, 5603, 1, 0, 0, 0, 5620, 5621, 1, 0, 0, 0, 5621, 5633, 1, 0, 0, 0,
|
|
5622, 5623, 5, 51, 0, 0, 5623, 5624, 5, 76, 0, 0, 5624, 5625, 5, 118, 0,
|
|
0, 5625, 5630, 3, 556, 278, 0, 5626, 5627, 5, 1135, 0, 0, 5627, 5629, 3,
|
|
556, 278, 0, 5628, 5626, 1, 0, 0, 0, 5629, 5632, 1, 0, 0, 0, 5630, 5628,
|
|
1, 0, 0, 0, 5630, 5631, 1, 0, 0, 0, 5631, 5634, 1, 0, 0, 0, 5632, 5630,
|
|
1, 0, 0, 0, 5633, 5622, 1, 0, 0, 0, 5633, 5634, 1, 0, 0, 0, 5634, 471,
|
|
1, 0, 0, 0, 5635, 5636, 5, 26, 0, 0, 5636, 5637, 5, 172, 0, 0, 5637, 5641,
|
|
3, 620, 310, 0, 5638, 5640, 3, 480, 240, 0, 5639, 5638, 1, 0, 0, 0, 5640,
|
|
5643, 1, 0, 0, 0, 5641, 5639, 1, 0, 0, 0, 5641, 5642, 1, 0, 0, 0, 5642,
|
|
473, 1, 0, 0, 0, 5643, 5641, 1, 0, 0, 0, 5644, 5645, 5, 356, 0, 0, 5645,
|
|
5646, 5, 172, 0, 0, 5646, 5648, 3, 620, 310, 0, 5647, 5649, 7, 73, 0, 0,
|
|
5648, 5647, 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 475, 1, 0, 0, 0,
|
|
5650, 5652, 5, 119, 0, 0, 5651, 5653, 7, 72, 0, 0, 5652, 5651, 1, 0, 0,
|
|
0, 5652, 5653, 1, 0, 0, 0, 5653, 5654, 1, 0, 0, 0, 5654, 5655, 7, 54, 0,
|
|
0, 5655, 5656, 3, 620, 310, 0, 5656, 477, 1, 0, 0, 0, 5657, 5659, 5, 580,
|
|
0, 0, 5658, 5660, 7, 72, 0, 0, 5659, 5658, 1, 0, 0, 0, 5659, 5660, 1, 0,
|
|
0, 0, 5660, 5661, 1, 0, 0, 0, 5661, 5662, 5, 172, 0, 0, 5662, 5664, 3,
|
|
620, 310, 0, 5663, 5665, 5, 568, 0, 0, 5664, 5663, 1, 0, 0, 0, 5664, 5665,
|
|
1, 0, 0, 0, 5665, 5667, 1, 0, 0, 0, 5666, 5668, 5, 422, 0, 0, 5667, 5666,
|
|
1, 0, 0, 0, 5667, 5668, 1, 0, 0, 0, 5668, 5670, 1, 0, 0, 0, 5669, 5671,
|
|
5, 666, 0, 0, 5670, 5669, 1, 0, 0, 0, 5670, 5671, 1, 0, 0, 0, 5671, 479,
|
|
1, 0, 0, 0, 5672, 5673, 5, 65, 0, 0, 5673, 5680, 5, 664, 0, 0, 5674, 5680,
|
|
5, 568, 0, 0, 5675, 5680, 5, 425, 0, 0, 5676, 5680, 5, 504, 0, 0, 5677,
|
|
5680, 5, 422, 0, 0, 5678, 5680, 5, 354, 0, 0, 5679, 5672, 1, 0, 0, 0, 5679,
|
|
5674, 1, 0, 0, 0, 5679, 5675, 1, 0, 0, 0, 5679, 5676, 1, 0, 0, 0, 5679,
|
|
5677, 1, 0, 0, 0, 5679, 5678, 1, 0, 0, 0, 5680, 481, 1, 0, 0, 0, 5681,
|
|
5683, 5, 33, 0, 0, 5682, 5684, 5, 335, 0, 0, 5683, 5682, 1, 0, 0, 0, 5683,
|
|
5684, 1, 0, 0, 0, 5684, 5685, 1, 0, 0, 0, 5685, 5687, 5, 437, 0, 0, 5686,
|
|
5688, 3, 642, 321, 0, 5687, 5686, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, 0, 5688,
|
|
5689, 1, 0, 0, 0, 5689, 5690, 3, 584, 292, 0, 5690, 5691, 5, 594, 0, 0,
|
|
5691, 5692, 7, 74, 0, 0, 5692, 5693, 5, 619, 0, 0, 5693, 5694, 5, 1148,
|
|
0, 0, 5694, 483, 1, 0, 0, 0, 5695, 5696, 5, 456, 0, 0, 5696, 5697, 5, 554,
|
|
0, 0, 5697, 5698, 3, 584, 292, 0, 5698, 5699, 5, 619, 0, 0, 5699, 5700,
|
|
5, 1148, 0, 0, 5700, 485, 1, 0, 0, 0, 5701, 5702, 5, 661, 0, 0, 5702, 5703,
|
|
5, 554, 0, 0, 5703, 5704, 3, 584, 292, 0, 5704, 487, 1, 0, 0, 0, 5705,
|
|
5706, 5, 153, 0, 0, 5706, 5707, 3, 492, 246, 0, 5707, 5710, 7, 75, 0, 0,
|
|
5708, 5711, 3, 688, 344, 0, 5709, 5711, 5, 118, 0, 0, 5710, 5708, 1, 0,
|
|
0, 0, 5710, 5709, 1, 0, 0, 0, 5711, 5721, 1, 0, 0, 0, 5712, 5713, 5, 1135,
|
|
0, 0, 5713, 5714, 3, 492, 246, 0, 5714, 5717, 7, 75, 0, 0, 5715, 5718,
|
|
3, 688, 344, 0, 5716, 5718, 5, 118, 0, 0, 5717, 5715, 1, 0, 0, 0, 5717,
|
|
5716, 1, 0, 0, 0, 5718, 5720, 1, 0, 0, 0, 5719, 5712, 1, 0, 0, 0, 5720,
|
|
5723, 1, 0, 0, 0, 5721, 5719, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722,
|
|
5758, 1, 0, 0, 0, 5723, 5721, 1, 0, 0, 0, 5724, 5725, 5, 153, 0, 0, 5725,
|
|
5728, 3, 60, 30, 0, 5726, 5729, 3, 568, 284, 0, 5727, 5729, 5, 42, 0, 0,
|
|
5728, 5726, 1, 0, 0, 0, 5728, 5727, 1, 0, 0, 0, 5729, 5758, 1, 0, 0, 0,
|
|
5730, 5731, 5, 153, 0, 0, 5731, 5738, 5, 517, 0, 0, 5732, 5735, 3, 568,
|
|
284, 0, 5733, 5734, 5, 27, 0, 0, 5734, 5736, 3, 570, 285, 0, 5735, 5733,
|
|
1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, 5739, 1, 0, 0, 0, 5737, 5739,
|
|
5, 42, 0, 0, 5738, 5732, 1, 0, 0, 0, 5738, 5737, 1, 0, 0, 0, 5739, 5758,
|
|
1, 0, 0, 0, 5740, 5758, 3, 444, 222, 0, 5741, 5758, 3, 318, 159, 0, 5742,
|
|
5758, 3, 316, 158, 0, 5743, 5744, 5, 153, 0, 0, 5744, 5745, 3, 550, 275,
|
|
0, 5745, 5746, 7, 75, 0, 0, 5746, 5754, 3, 688, 344, 0, 5747, 5748, 5,
|
|
1135, 0, 0, 5748, 5749, 3, 550, 275, 0, 5749, 5750, 7, 75, 0, 0, 5750,
|
|
5751, 3, 688, 344, 0, 5751, 5753, 1, 0, 0, 0, 5752, 5747, 1, 0, 0, 0, 5753,
|
|
5756, 1, 0, 0, 0, 5754, 5752, 1, 0, 0, 0, 5754, 5755, 1, 0, 0, 0, 5755,
|
|
5758, 1, 0, 0, 0, 5756, 5754, 1, 0, 0, 0, 5757, 5705, 1, 0, 0, 0, 5757,
|
|
5724, 1, 0, 0, 0, 5757, 5730, 1, 0, 0, 0, 5757, 5740, 1, 0, 0, 0, 5757,
|
|
5741, 1, 0, 0, 0, 5757, 5742, 1, 0, 0, 0, 5757, 5743, 1, 0, 0, 0, 5758,
|
|
489, 1, 0, 0, 0, 5759, 5760, 5, 155, 0, 0, 5760, 5761, 7, 56, 0, 0, 5761,
|
|
5913, 5, 476, 0, 0, 5762, 5763, 5, 155, 0, 0, 5763, 5764, 7, 76, 0, 0,
|
|
5764, 5767, 5, 416, 0, 0, 5765, 5766, 5, 80, 0, 0, 5766, 5768, 5, 1148,
|
|
0, 0, 5767, 5765, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, 5768, 5771, 1, 0,
|
|
0, 0, 5769, 5770, 5, 68, 0, 0, 5770, 5772, 3, 590, 295, 0, 5771, 5769,
|
|
1, 0, 0, 0, 5771, 5772, 1, 0, 0, 0, 5772, 5780, 1, 0, 0, 0, 5773, 5777,
|
|
5, 99, 0, 0, 5774, 5775, 3, 590, 295, 0, 5775, 5776, 5, 1135, 0, 0, 5776,
|
|
5778, 1, 0, 0, 0, 5777, 5774, 1, 0, 0, 0, 5777, 5778, 1, 0, 0, 0, 5778,
|
|
5779, 1, 0, 0, 0, 5779, 5781, 3, 590, 295, 0, 5780, 5773, 1, 0, 0, 0, 5780,
|
|
5781, 1, 0, 0, 0, 5781, 5913, 1, 0, 0, 0, 5782, 5783, 5, 155, 0, 0, 5783,
|
|
5785, 3, 494, 247, 0, 5784, 5786, 3, 496, 248, 0, 5785, 5784, 1, 0, 0,
|
|
0, 5785, 5786, 1, 0, 0, 0, 5786, 5913, 1, 0, 0, 0, 5787, 5789, 5, 155,
|
|
0, 0, 5788, 5790, 5, 436, 0, 0, 5789, 5788, 1, 0, 0, 0, 5789, 5790, 1,
|
|
0, 0, 0, 5790, 5791, 1, 0, 0, 0, 5791, 5792, 7, 41, 0, 0, 5792, 5793, 7,
|
|
77, 0, 0, 5793, 5796, 3, 552, 276, 0, 5794, 5795, 7, 77, 0, 0, 5795, 5797,
|
|
3, 584, 292, 0, 5796, 5794, 1, 0, 0, 0, 5796, 5797, 1, 0, 0, 0, 5797, 5799,
|
|
1, 0, 0, 0, 5798, 5800, 3, 496, 248, 0, 5799, 5798, 1, 0, 0, 0, 5799, 5800,
|
|
1, 0, 0, 0, 5800, 5913, 1, 0, 0, 0, 5801, 5802, 5, 155, 0, 0, 5802, 5803,
|
|
5, 33, 0, 0, 5803, 5805, 7, 0, 0, 0, 5804, 5806, 3, 642, 321, 0, 5805,
|
|
5804, 1, 0, 0, 0, 5805, 5806, 1, 0, 0, 0, 5806, 5807, 1, 0, 0, 0, 5807,
|
|
5913, 3, 584, 292, 0, 5808, 5809, 5, 155, 0, 0, 5809, 5810, 5, 33, 0, 0,
|
|
5810, 5811, 7, 78, 0, 0, 5811, 5913, 3, 550, 275, 0, 5812, 5813, 5, 155,
|
|
0, 0, 5813, 5814, 5, 33, 0, 0, 5814, 5815, 5, 665, 0, 0, 5815, 5913, 3,
|
|
564, 282, 0, 5816, 5817, 5, 155, 0, 0, 5817, 5818, 5, 409, 0, 0, 5818,
|
|
5819, 3, 572, 286, 0, 5819, 5820, 7, 79, 0, 0, 5820, 5913, 1, 0, 0, 0,
|
|
5821, 5822, 5, 155, 0, 0, 5822, 5913, 3, 498, 249, 0, 5823, 5824, 5, 155,
|
|
0, 0, 5824, 5832, 7, 80, 0, 0, 5825, 5829, 5, 99, 0, 0, 5826, 5827, 3,
|
|
590, 295, 0, 5827, 5828, 5, 1135, 0, 0, 5828, 5830, 1, 0, 0, 0, 5829, 5826,
|
|
1, 0, 0, 0, 5829, 5830, 1, 0, 0, 0, 5830, 5831, 1, 0, 0, 0, 5831, 5833,
|
|
3, 590, 295, 0, 5832, 5825, 1, 0, 0, 0, 5832, 5833, 1, 0, 0, 0, 5833, 5913,
|
|
1, 0, 0, 0, 5834, 5835, 5, 155, 0, 0, 5835, 5836, 5, 290, 0, 0, 5836, 5837,
|
|
5, 1133, 0, 0, 5837, 5838, 5, 1117, 0, 0, 5838, 5839, 5, 1134, 0, 0, 5839,
|
|
5913, 7, 80, 0, 0, 5840, 5841, 5, 155, 0, 0, 5841, 5844, 3, 500, 250, 0,
|
|
5842, 5843, 7, 77, 0, 0, 5843, 5845, 3, 584, 292, 0, 5844, 5842, 1, 0,
|
|
0, 0, 5844, 5845, 1, 0, 0, 0, 5845, 5847, 1, 0, 0, 0, 5846, 5848, 3, 496,
|
|
248, 0, 5847, 5846, 1, 0, 0, 0, 5847, 5848, 1, 0, 0, 0, 5848, 5913, 1,
|
|
0, 0, 0, 5849, 5850, 5, 155, 0, 0, 5850, 5851, 7, 81, 0, 0, 5851, 5852,
|
|
5, 364, 0, 0, 5852, 5913, 3, 550, 275, 0, 5853, 5854, 5, 155, 0, 0, 5854,
|
|
5857, 5, 440, 0, 0, 5855, 5856, 5, 65, 0, 0, 5856, 5858, 3, 564, 282, 0,
|
|
5857, 5855, 1, 0, 0, 0, 5857, 5858, 1, 0, 0, 0, 5858, 5913, 1, 0, 0, 0,
|
|
5859, 5860, 5, 155, 0, 0, 5860, 5861, 7, 82, 0, 0, 5861, 5862, 7, 77, 0,
|
|
0, 5862, 5865, 3, 552, 276, 0, 5863, 5864, 7, 77, 0, 0, 5864, 5866, 3,
|
|
584, 292, 0, 5865, 5863, 1, 0, 0, 0, 5865, 5866, 1, 0, 0, 0, 5866, 5869,
|
|
1, 0, 0, 0, 5867, 5868, 5, 190, 0, 0, 5868, 5870, 3, 688, 344, 0, 5869,
|
|
5867, 1, 0, 0, 0, 5869, 5870, 1, 0, 0, 0, 5870, 5913, 1, 0, 0, 0, 5871,
|
|
5872, 5, 155, 0, 0, 5872, 5873, 5, 539, 0, 0, 5873, 5876, 5, 742, 0, 0,
|
|
5874, 5875, 7, 77, 0, 0, 5875, 5877, 3, 584, 292, 0, 5876, 5874, 1, 0,
|
|
0, 0, 5876, 5877, 1, 0, 0, 0, 5877, 5879, 1, 0, 0, 0, 5878, 5880, 3, 496,
|
|
248, 0, 5879, 5878, 1, 0, 0, 0, 5879, 5880, 1, 0, 0, 0, 5880, 5913, 1,
|
|
0, 0, 0, 5881, 5882, 5, 155, 0, 0, 5882, 5883, 5, 564, 0, 0, 5883, 5888,
|
|
3, 502, 251, 0, 5884, 5885, 5, 1135, 0, 0, 5885, 5887, 3, 502, 251, 0,
|
|
5886, 5884, 1, 0, 0, 0, 5887, 5890, 1, 0, 0, 0, 5888, 5886, 1, 0, 0, 0,
|
|
5888, 5889, 1, 0, 0, 0, 5889, 5894, 1, 0, 0, 0, 5890, 5888, 1, 0, 0, 0,
|
|
5891, 5892, 5, 65, 0, 0, 5892, 5893, 5, 567, 0, 0, 5893, 5895, 3, 590,
|
|
295, 0, 5894, 5891, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5896, 1,
|
|
0, 0, 0, 5896, 5900, 5, 99, 0, 0, 5897, 5898, 3, 590, 295, 0, 5898, 5899,
|
|
5, 1135, 0, 0, 5899, 5901, 1, 0, 0, 0, 5900, 5897, 1, 0, 0, 0, 5900, 5901,
|
|
1, 0, 0, 0, 5901, 5902, 1, 0, 0, 0, 5902, 5903, 3, 590, 295, 0, 5903, 5913,
|
|
1, 0, 0, 0, 5904, 5905, 5, 155, 0, 0, 5905, 5906, 5, 614, 0, 0, 5906, 5910,
|
|
5, 634, 0, 0, 5907, 5908, 5, 65, 0, 0, 5908, 5909, 5, 355, 0, 0, 5909,
|
|
5911, 5, 1148, 0, 0, 5910, 5907, 1, 0, 0, 0, 5910, 5911, 1, 0, 0, 0, 5911,
|
|
5913, 1, 0, 0, 0, 5912, 5759, 1, 0, 0, 0, 5912, 5762, 1, 0, 0, 0, 5912,
|
|
5782, 1, 0, 0, 0, 5912, 5787, 1, 0, 0, 0, 5912, 5801, 1, 0, 0, 0, 5912,
|
|
5808, 1, 0, 0, 0, 5912, 5812, 1, 0, 0, 0, 5912, 5816, 1, 0, 0, 0, 5912,
|
|
5821, 1, 0, 0, 0, 5912, 5823, 1, 0, 0, 0, 5912, 5834, 1, 0, 0, 0, 5912,
|
|
5840, 1, 0, 0, 0, 5912, 5849, 1, 0, 0, 0, 5912, 5853, 1, 0, 0, 0, 5912,
|
|
5859, 1, 0, 0, 0, 5912, 5871, 1, 0, 0, 0, 5912, 5881, 1, 0, 0, 0, 5912,
|
|
5904, 1, 0, 0, 0, 5913, 491, 1, 0, 0, 0, 5914, 5925, 5, 1159, 0, 0, 5915,
|
|
5925, 5, 1160, 0, 0, 5916, 5917, 5, 1137, 0, 0, 5917, 5919, 5, 1137, 0,
|
|
0, 5918, 5916, 1, 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5920, 1, 0, 0,
|
|
0, 5920, 5922, 7, 83, 0, 0, 5921, 5918, 1, 0, 0, 0, 5921, 5922, 1, 0, 0,
|
|
0, 5922, 5923, 1, 0, 0, 0, 5923, 5925, 3, 584, 292, 0, 5924, 5914, 1, 0,
|
|
0, 0, 5924, 5915, 1, 0, 0, 0, 5924, 5921, 1, 0, 0, 0, 5925, 493, 1, 0,
|
|
0, 0, 5926, 5927, 5, 25, 0, 0, 5927, 5940, 5, 153, 0, 0, 5928, 5940, 5,
|
|
844, 0, 0, 5929, 5940, 5, 40, 0, 0, 5930, 5940, 5, 151, 0, 0, 5931, 5932,
|
|
5, 437, 0, 0, 5932, 5940, 5, 634, 0, 0, 5933, 5934, 5, 131, 0, 0, 5934,
|
|
5940, 5, 634, 0, 0, 5935, 5937, 7, 55, 0, 0, 5936, 5935, 1, 0, 0, 0, 5936,
|
|
5937, 1, 0, 0, 0, 5937, 5938, 1, 0, 0, 0, 5938, 5940, 7, 84, 0, 0, 5939,
|
|
5926, 1, 0, 0, 0, 5939, 5928, 1, 0, 0, 0, 5939, 5929, 1, 0, 0, 0, 5939,
|
|
5930, 1, 0, 0, 0, 5939, 5931, 1, 0, 0, 0, 5939, 5933, 1, 0, 0, 0, 5939,
|
|
5936, 1, 0, 0, 0, 5940, 495, 1, 0, 0, 0, 5941, 5942, 5, 98, 0, 0, 5942,
|
|
5946, 5, 1148, 0, 0, 5943, 5944, 5, 190, 0, 0, 5944, 5946, 3, 688, 344,
|
|
0, 5945, 5941, 1, 0, 0, 0, 5945, 5943, 1, 0, 0, 0, 5946, 497, 1, 0, 0,
|
|
0, 5947, 5949, 5, 636, 0, 0, 5948, 5947, 1, 0, 0, 0, 5948, 5949, 1, 0,
|
|
0, 0, 5949, 5950, 1, 0, 0, 0, 5950, 5965, 5, 410, 0, 0, 5951, 5952, 5,
|
|
477, 0, 0, 5952, 5965, 5, 634, 0, 0, 5953, 5965, 5, 556, 0, 0, 5954, 5965,
|
|
5, 725, 0, 0, 5955, 5957, 5, 436, 0, 0, 5956, 5955, 1, 0, 0, 0, 5956, 5957,
|
|
1, 0, 0, 0, 5957, 5958, 1, 0, 0, 0, 5958, 5965, 5, 563, 0, 0, 5959, 5965,
|
|
5, 565, 0, 0, 5960, 5961, 5, 614, 0, 0, 5961, 5965, 5, 447, 0, 0, 5962,
|
|
5965, 5, 339, 0, 0, 5963, 5965, 5, 383, 0, 0, 5964, 5948, 1, 0, 0, 0, 5964,
|
|
5951, 1, 0, 0, 0, 5964, 5953, 1, 0, 0, 0, 5964, 5954, 1, 0, 0, 0, 5964,
|
|
5956, 1, 0, 0, 0, 5964, 5959, 1, 0, 0, 0, 5964, 5960, 1, 0, 0, 0, 5964,
|
|
5962, 1, 0, 0, 0, 5964, 5963, 1, 0, 0, 0, 5965, 499, 1, 0, 0, 0, 5966,
|
|
5975, 5, 416, 0, 0, 5967, 5968, 5, 172, 0, 0, 5968, 5975, 5, 634, 0, 0,
|
|
5969, 5971, 5, 436, 0, 0, 5970, 5969, 1, 0, 0, 0, 5970, 5971, 1, 0, 0,
|
|
0, 5971, 5972, 1, 0, 0, 0, 5972, 5975, 5, 742, 0, 0, 5973, 5975, 5, 655,
|
|
0, 0, 5974, 5966, 1, 0, 0, 0, 5974, 5967, 1, 0, 0, 0, 5974, 5970, 1, 0,
|
|
0, 0, 5974, 5973, 1, 0, 0, 0, 5975, 501, 1, 0, 0, 0, 5976, 5989, 5, 6,
|
|
0, 0, 5977, 5978, 5, 347, 0, 0, 5978, 5989, 5, 461, 0, 0, 5979, 5980, 5,
|
|
382, 0, 0, 5980, 5989, 5, 645, 0, 0, 5981, 5989, 5, 385, 0, 0, 5982, 5989,
|
|
5, 463, 0, 0, 5983, 5989, 5, 792, 0, 0, 5984, 5985, 5, 544, 0, 0, 5985,
|
|
5989, 5, 426, 0, 0, 5986, 5989, 5, 621, 0, 0, 5987, 5989, 5, 644, 0, 0,
|
|
5988, 5976, 1, 0, 0, 0, 5988, 5977, 1, 0, 0, 0, 5988, 5979, 1, 0, 0, 0,
|
|
5988, 5981, 1, 0, 0, 0, 5988, 5982, 1, 0, 0, 0, 5988, 5983, 1, 0, 0, 0,
|
|
5988, 5984, 1, 0, 0, 0, 5988, 5986, 1, 0, 0, 0, 5988, 5987, 1, 0, 0, 0,
|
|
5989, 503, 1, 0, 0, 0, 5990, 5991, 5, 345, 0, 0, 5991, 5992, 5, 1148, 0,
|
|
0, 5992, 505, 1, 0, 0, 0, 5993, 5994, 5, 351, 0, 0, 5994, 5995, 5, 81,
|
|
0, 0, 5995, 6000, 3, 518, 259, 0, 5996, 5997, 5, 1135, 0, 0, 5997, 5999,
|
|
3, 518, 259, 0, 5998, 5996, 1, 0, 0, 0, 5999, 6002, 1, 0, 0, 0, 6000, 5998,
|
|
1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, 6001, 6010, 1, 0, 0, 0, 6002, 6000,
|
|
1, 0, 0, 0, 6003, 6004, 5, 129, 0, 0, 6004, 6007, 5, 1133, 0, 0, 6005,
|
|
6008, 3, 616, 308, 0, 6006, 6008, 5, 6, 0, 0, 6007, 6005, 1, 0, 0, 0, 6007,
|
|
6006, 1, 0, 0, 0, 6008, 6009, 1, 0, 0, 0, 6009, 6011, 5, 1134, 0, 0, 6010,
|
|
6003, 1, 0, 0, 0, 6010, 6011, 1, 0, 0, 0, 6011, 6012, 1, 0, 0, 0, 6012,
|
|
6013, 5, 80, 0, 0, 6013, 6014, 3, 584, 292, 0, 6014, 507, 1, 0, 0, 0, 6015,
|
|
6017, 5, 432, 0, 0, 6016, 6018, 7, 72, 0, 0, 6017, 6016, 1, 0, 0, 0, 6017,
|
|
6018, 1, 0, 0, 0, 6018, 6019, 1, 0, 0, 0, 6019, 6024, 3, 520, 260, 0, 6020,
|
|
6021, 5, 1135, 0, 0, 6021, 6023, 3, 520, 260, 0, 6022, 6020, 1, 0, 0, 0,
|
|
6023, 6026, 1, 0, 0, 0, 6024, 6022, 1, 0, 0, 0, 6024, 6025, 1, 0, 0, 0,
|
|
6025, 509, 1, 0, 0, 0, 6026, 6024, 1, 0, 0, 0, 6027, 6029, 5, 93, 0, 0,
|
|
6028, 6030, 7, 85, 0, 0, 6029, 6028, 1, 0, 0, 0, 6029, 6030, 1, 0, 0, 0,
|
|
6030, 6031, 1, 0, 0, 0, 6031, 6032, 3, 688, 344, 0, 6032, 511, 1, 0, 0,
|
|
0, 6033, 6034, 5, 102, 0, 0, 6034, 6035, 5, 81, 0, 0, 6035, 6036, 5, 87,
|
|
0, 0, 6036, 6037, 5, 351, 0, 0, 6037, 6042, 3, 524, 262, 0, 6038, 6039,
|
|
5, 1135, 0, 0, 6039, 6041, 3, 524, 262, 0, 6040, 6038, 1, 0, 0, 0, 6041,
|
|
6044, 1, 0, 0, 0, 6042, 6040, 1, 0, 0, 0, 6042, 6043, 1, 0, 0, 0, 6043,
|
|
513, 1, 0, 0, 0, 6044, 6042, 1, 0, 0, 0, 6045, 6046, 5, 589, 0, 0, 6046,
|
|
6047, 5, 567, 0, 0, 6047, 6048, 5, 351, 0, 0, 6048, 515, 1, 0, 0, 0, 6049,
|
|
6050, 5, 739, 0, 0, 6050, 517, 1, 0, 0, 0, 6051, 6059, 3, 552, 276, 0,
|
|
6052, 6054, 7, 20, 0, 0, 6053, 6052, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, 0,
|
|
6054, 6055, 1, 0, 0, 0, 6055, 6056, 5, 1133, 0, 0, 6056, 6057, 3, 616,
|
|
308, 0, 6057, 6058, 5, 1134, 0, 0, 6058, 6060, 1, 0, 0, 0, 6059, 6053,
|
|
1, 0, 0, 0, 6059, 6060, 1, 0, 0, 0, 6060, 519, 1, 0, 0, 0, 6061, 6080,
|
|
5, 394, 0, 0, 6062, 6080, 5, 447, 0, 0, 6063, 6065, 7, 86, 0, 0, 6064,
|
|
6063, 1, 0, 0, 0, 6064, 6065, 1, 0, 0, 0, 6065, 6066, 1, 0, 0, 0, 6066,
|
|
6080, 5, 476, 0, 0, 6067, 6080, 5, 540, 0, 0, 6068, 6080, 5, 725, 0, 0,
|
|
6069, 6070, 5, 567, 0, 0, 6070, 6080, 5, 351, 0, 0, 6071, 6080, 5, 634,
|
|
0, 0, 6072, 6080, 5, 667, 0, 0, 6073, 6077, 5, 742, 0, 0, 6074, 6075, 5,
|
|
192, 0, 0, 6075, 6076, 5, 134, 0, 0, 6076, 6078, 5, 103, 0, 0, 6077, 6074,
|
|
1, 0, 0, 0, 6077, 6078, 1, 0, 0, 0, 6078, 6080, 1, 0, 0, 0, 6079, 6061,
|
|
1, 0, 0, 0, 6079, 6062, 1, 0, 0, 0, 6079, 6064, 1, 0, 0, 0, 6079, 6067,
|
|
1, 0, 0, 0, 6079, 6068, 1, 0, 0, 0, 6079, 6069, 1, 0, 0, 0, 6079, 6071,
|
|
1, 0, 0, 0, 6079, 6072, 1, 0, 0, 0, 6079, 6073, 1, 0, 0, 0, 6080, 6094,
|
|
1, 0, 0, 0, 6081, 6082, 5, 574, 0, 0, 6082, 6084, 5, 476, 0, 0, 6083, 6085,
|
|
3, 356, 178, 0, 6084, 6083, 1, 0, 0, 0, 6084, 6085, 1, 0, 0, 0, 6085, 6094,
|
|
1, 0, 0, 0, 6086, 6088, 7, 54, 0, 0, 6087, 6089, 3, 620, 310, 0, 6088,
|
|
6087, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 6091, 1, 0, 0, 0, 6090,
|
|
6092, 3, 522, 261, 0, 6091, 6090, 1, 0, 0, 0, 6091, 6092, 1, 0, 0, 0, 6092,
|
|
6094, 1, 0, 0, 0, 6093, 6079, 1, 0, 0, 0, 6093, 6081, 1, 0, 0, 0, 6093,
|
|
6086, 1, 0, 0, 0, 6094, 521, 1, 0, 0, 0, 6095, 6096, 5, 192, 0, 0, 6096,
|
|
6097, 5, 134, 0, 0, 6097, 6101, 5, 103, 0, 0, 6098, 6099, 5, 65, 0, 0,
|
|
6099, 6101, 5, 421, 0, 0, 6100, 6095, 1, 0, 0, 0, 6100, 6098, 1, 0, 0,
|
|
0, 6101, 523, 1, 0, 0, 0, 6102, 6110, 3, 552, 276, 0, 6103, 6104, 5, 129,
|
|
0, 0, 6104, 6107, 5, 1133, 0, 0, 6105, 6108, 3, 616, 308, 0, 6106, 6108,
|
|
5, 6, 0, 0, 6107, 6105, 1, 0, 0, 0, 6107, 6106, 1, 0, 0, 0, 6108, 6109,
|
|
1, 0, 0, 0, 6109, 6111, 5, 1134, 0, 0, 6110, 6103, 1, 0, 0, 0, 6110, 6111,
|
|
1, 0, 0, 0, 6111, 6119, 1, 0, 0, 0, 6112, 6114, 7, 20, 0, 0, 6113, 6112,
|
|
1, 0, 0, 0, 6113, 6114, 1, 0, 0, 0, 6114, 6115, 1, 0, 0, 0, 6115, 6116,
|
|
5, 1133, 0, 0, 6116, 6117, 3, 616, 308, 0, 6117, 6118, 5, 1134, 0, 0, 6118,
|
|
6120, 1, 0, 0, 0, 6119, 6113, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120,
|
|
6123, 1, 0, 0, 0, 6121, 6122, 5, 78, 0, 0, 6122, 6124, 5, 470, 0, 0, 6123,
|
|
6121, 1, 0, 0, 0, 6123, 6124, 1, 0, 0, 0, 6124, 525, 1, 0, 0, 0, 6125,
|
|
6126, 7, 87, 0, 0, 6126, 6129, 3, 552, 276, 0, 6127, 6130, 3, 584, 292,
|
|
0, 6128, 6130, 5, 1148, 0, 0, 6129, 6127, 1, 0, 0, 0, 6129, 6128, 1, 0,
|
|
0, 0, 6129, 6130, 1, 0, 0, 0, 6130, 527, 1, 0, 0, 0, 6131, 6135, 7, 87,
|
|
0, 0, 6132, 6133, 7, 88, 0, 0, 6133, 6134, 5, 1124, 0, 0, 6134, 6136, 7,
|
|
89, 0, 0, 6135, 6132, 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 6137, 1,
|
|
0, 0, 0, 6137, 6138, 3, 548, 274, 0, 6138, 529, 1, 0, 0, 0, 6139, 6140,
|
|
5, 444, 0, 0, 6140, 6141, 5, 1148, 0, 0, 6141, 531, 1, 0, 0, 0, 6142, 6143,
|
|
5, 186, 0, 0, 6143, 6144, 3, 584, 292, 0, 6144, 533, 1, 0, 0, 0, 6145,
|
|
6153, 5, 156, 0, 0, 6146, 6148, 5, 162, 0, 0, 6147, 6149, 5, 669, 0, 0,
|
|
6148, 6147, 1, 0, 0, 0, 6148, 6149, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0,
|
|
6150, 6154, 3, 594, 297, 0, 6151, 6154, 5, 1156, 0, 0, 6152, 6154, 5, 1157,
|
|
0, 0, 6153, 6146, 1, 0, 0, 0, 6153, 6151, 1, 0, 0, 0, 6153, 6152, 1, 0,
|
|
0, 0, 6154, 6164, 1, 0, 0, 0, 6155, 6156, 5, 153, 0, 0, 6156, 6161, 3,
|
|
538, 269, 0, 6157, 6158, 5, 1135, 0, 0, 6158, 6160, 3, 538, 269, 0, 6159,
|
|
6157, 1, 0, 0, 0, 6160, 6163, 1, 0, 0, 0, 6161, 6159, 1, 0, 0, 0, 6161,
|
|
6162, 1, 0, 0, 0, 6162, 6165, 1, 0, 0, 0, 6163, 6161, 1, 0, 0, 0, 6164,
|
|
6155, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 535, 1, 0, 0, 0, 6166,
|
|
6174, 5, 143, 0, 0, 6167, 6169, 5, 162, 0, 0, 6168, 6170, 5, 669, 0, 0,
|
|
6169, 6168, 1, 0, 0, 0, 6169, 6170, 1, 0, 0, 0, 6170, 6171, 1, 0, 0, 0,
|
|
6171, 6175, 3, 594, 297, 0, 6172, 6175, 5, 1156, 0, 0, 6173, 6175, 5, 1157,
|
|
0, 0, 6174, 6167, 1, 0, 0, 0, 6174, 6172, 1, 0, 0, 0, 6174, 6173, 1, 0,
|
|
0, 0, 6174, 6175, 1, 0, 0, 0, 6175, 6185, 1, 0, 0, 0, 6176, 6177, 5, 153,
|
|
0, 0, 6177, 6182, 3, 538, 269, 0, 6178, 6179, 5, 1135, 0, 0, 6179, 6181,
|
|
3, 538, 269, 0, 6180, 6178, 1, 0, 0, 0, 6181, 6184, 1, 0, 0, 0, 6182, 6180,
|
|
1, 0, 0, 0, 6182, 6183, 1, 0, 0, 0, 6183, 6186, 1, 0, 0, 0, 6184, 6182,
|
|
1, 0, 0, 0, 6185, 6176, 1, 0, 0, 0, 6185, 6186, 1, 0, 0, 0, 6186, 537,
|
|
1, 0, 0, 0, 6187, 6188, 7, 90, 0, 0, 6188, 6193, 5, 1124, 0, 0, 6189, 6194,
|
|
3, 594, 297, 0, 6190, 6194, 5, 1149, 0, 0, 6191, 6194, 3, 566, 283, 0,
|
|
6192, 6194, 3, 586, 293, 0, 6193, 6189, 1, 0, 0, 0, 6193, 6190, 1, 0, 0,
|
|
0, 6193, 6191, 1, 0, 0, 0, 6193, 6192, 1, 0, 0, 0, 6194, 539, 1, 0, 0,
|
|
0, 6195, 6197, 5, 192, 0, 0, 6196, 6198, 5, 571, 0, 0, 6197, 6196, 1, 0,
|
|
0, 0, 6197, 6198, 1, 0, 0, 0, 6198, 6199, 1, 0, 0, 0, 6199, 6204, 3, 50,
|
|
25, 0, 6200, 6201, 5, 1135, 0, 0, 6201, 6203, 3, 50, 25, 0, 6202, 6200,
|
|
1, 0, 0, 0, 6203, 6206, 1, 0, 0, 0, 6204, 6202, 1, 0, 0, 0, 6204, 6205,
|
|
1, 0, 0, 0, 6205, 541, 1, 0, 0, 0, 6206, 6204, 1, 0, 0, 0, 6207, 6208,
|
|
5, 172, 0, 0, 6208, 6210, 3, 552, 276, 0, 6209, 6211, 3, 230, 115, 0, 6210,
|
|
6209, 1, 0, 0, 0, 6210, 6211, 1, 0, 0, 0, 6211, 6213, 1, 0, 0, 0, 6212,
|
|
6214, 3, 294, 147, 0, 6213, 6212, 1, 0, 0, 0, 6213, 6214, 1, 0, 0, 0, 6214,
|
|
543, 1, 0, 0, 0, 6215, 6217, 5, 71, 0, 0, 6216, 6218, 7, 91, 0, 0, 6217,
|
|
6216, 1, 0, 0, 0, 6217, 6218, 1, 0, 0, 0, 6218, 6219, 1, 0, 0, 0, 6219,
|
|
6251, 5, 48, 0, 0, 6220, 6221, 3, 492, 246, 0, 6221, 6222, 5, 1124, 0,
|
|
0, 6222, 6230, 7, 92, 0, 0, 6223, 6224, 5, 1135, 0, 0, 6224, 6225, 3, 492,
|
|
246, 0, 6225, 6226, 5, 1124, 0, 0, 6226, 6227, 7, 92, 0, 0, 6227, 6229,
|
|
1, 0, 0, 0, 6228, 6223, 1, 0, 0, 0, 6229, 6232, 1, 0, 0, 0, 6230, 6228,
|
|
1, 0, 0, 0, 6230, 6231, 1, 0, 0, 0, 6231, 6252, 1, 0, 0, 0, 6232, 6230,
|
|
1, 0, 0, 0, 6233, 6236, 5, 29, 0, 0, 6234, 6237, 3, 590, 295, 0, 6235,
|
|
6237, 3, 492, 246, 0, 6236, 6234, 1, 0, 0, 0, 6236, 6235, 1, 0, 0, 0, 6237,
|
|
6238, 1, 0, 0, 0, 6238, 6239, 3, 492, 246, 0, 6239, 6240, 5, 1124, 0, 0,
|
|
6240, 6248, 3, 546, 273, 0, 6241, 6242, 5, 1135, 0, 0, 6242, 6243, 3, 492,
|
|
246, 0, 6243, 6244, 5, 1124, 0, 0, 6244, 6245, 3, 546, 273, 0, 6245, 6247,
|
|
1, 0, 0, 0, 6246, 6241, 1, 0, 0, 0, 6247, 6250, 1, 0, 0, 0, 6248, 6246,
|
|
1, 0, 0, 0, 6248, 6249, 1, 0, 0, 0, 6249, 6252, 1, 0, 0, 0, 6250, 6248,
|
|
1, 0, 0, 0, 6251, 6220, 1, 0, 0, 0, 6251, 6233, 1, 0, 0, 0, 6252, 545,
|
|
1, 0, 0, 0, 6253, 6254, 7, 93, 0, 0, 6254, 547, 1, 0, 0, 0, 6255, 6261,
|
|
3, 200, 100, 0, 6256, 6261, 3, 186, 93, 0, 6257, 6261, 3, 192, 96, 0, 6258,
|
|
6261, 3, 198, 99, 0, 6259, 6261, 3, 202, 101, 0, 6260, 6255, 1, 0, 0, 0,
|
|
6260, 6256, 1, 0, 0, 0, 6260, 6257, 1, 0, 0, 0, 6260, 6258, 1, 0, 0, 0,
|
|
6260, 6259, 1, 0, 0, 0, 6261, 6266, 1, 0, 0, 0, 6262, 6263, 5, 65, 0, 0,
|
|
6263, 6264, 5, 376, 0, 0, 6264, 6266, 3, 584, 292, 0, 6265, 6260, 1, 0,
|
|
0, 0, 6265, 6262, 1, 0, 0, 0, 6266, 549, 1, 0, 0, 0, 6267, 6271, 3, 584,
|
|
292, 0, 6268, 6272, 5, 1155, 0, 0, 6269, 6270, 5, 1132, 0, 0, 6270, 6272,
|
|
3, 584, 292, 0, 6271, 6268, 1, 0, 0, 0, 6271, 6269, 1, 0, 0, 0, 6271, 6272,
|
|
1, 0, 0, 0, 6272, 551, 1, 0, 0, 0, 6273, 6274, 3, 550, 275, 0, 6274, 553,
|
|
1, 0, 0, 0, 6275, 6278, 3, 564, 282, 0, 6276, 6278, 3, 584, 292, 0, 6277,
|
|
6275, 1, 0, 0, 0, 6277, 6276, 1, 0, 0, 0, 6278, 555, 1, 0, 0, 0, 6279,
|
|
6284, 3, 584, 292, 0, 6280, 6282, 3, 588, 294, 0, 6281, 6283, 3, 588, 294,
|
|
0, 6282, 6281, 1, 0, 0, 0, 6282, 6283, 1, 0, 0, 0, 6283, 6285, 1, 0, 0,
|
|
0, 6284, 6280, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6294, 1, 0, 0,
|
|
0, 6286, 6288, 9, 0, 0, 0, 6287, 6286, 1, 0, 0, 0, 6287, 6288, 1, 0, 0,
|
|
0, 6288, 6289, 1, 0, 0, 0, 6289, 6291, 3, 588, 294, 0, 6290, 6292, 3, 588,
|
|
294, 0, 6291, 6290, 1, 0, 0, 0, 6291, 6292, 1, 0, 0, 0, 6292, 6294, 1,
|
|
0, 0, 0, 6293, 6279, 1, 0, 0, 0, 6293, 6287, 1, 0, 0, 0, 6294, 557, 1,
|
|
0, 0, 0, 6295, 6298, 3, 584, 292, 0, 6296, 6298, 5, 1148, 0, 0, 6297, 6295,
|
|
1, 0, 0, 0, 6297, 6296, 1, 0, 0, 0, 6298, 6303, 1, 0, 0, 0, 6299, 6300,
|
|
5, 1133, 0, 0, 6300, 6301, 3, 590, 295, 0, 6301, 6302, 5, 1134, 0, 0, 6302,
|
|
6304, 1, 0, 0, 0, 6303, 6299, 1, 0, 0, 0, 6303, 6304, 1, 0, 0, 0, 6304,
|
|
6307, 1, 0, 0, 0, 6305, 6307, 3, 688, 344, 0, 6306, 6297, 1, 0, 0, 0, 6306,
|
|
6305, 1, 0, 0, 0, 6307, 6309, 1, 0, 0, 0, 6308, 6310, 7, 48, 0, 0, 6309,
|
|
6308, 1, 0, 0, 0, 6309, 6310, 1, 0, 0, 0, 6310, 559, 1, 0, 0, 0, 6311,
|
|
6316, 5, 1148, 0, 0, 6312, 6316, 5, 1156, 0, 0, 6313, 6316, 5, 697, 0,
|
|
0, 6314, 6316, 3, 718, 359, 0, 6315, 6311, 1, 0, 0, 0, 6315, 6312, 1, 0,
|
|
0, 0, 6315, 6313, 1, 0, 0, 0, 6315, 6314, 1, 0, 0, 0, 6316, 561, 1, 0,
|
|
0, 0, 6317, 6318, 7, 94, 0, 0, 6318, 563, 1, 0, 0, 0, 6319, 6325, 3, 560,
|
|
280, 0, 6320, 6321, 3, 560, 280, 0, 6321, 6322, 3, 562, 281, 0, 6322, 6325,
|
|
1, 0, 0, 0, 6323, 6325, 3, 62, 31, 0, 6324, 6319, 1, 0, 0, 0, 6324, 6320,
|
|
1, 0, 0, 0, 6324, 6323, 1, 0, 0, 0, 6325, 565, 1, 0, 0, 0, 6326, 6327,
|
|
7, 95, 0, 0, 6327, 567, 1, 0, 0, 0, 6328, 6333, 5, 226, 0, 0, 6329, 6333,
|
|
3, 708, 354, 0, 6330, 6333, 5, 1148, 0, 0, 6331, 6333, 5, 1145, 0, 0, 6332,
|
|
6328, 1, 0, 0, 0, 6332, 6329, 1, 0, 0, 0, 6332, 6330, 1, 0, 0, 0, 6332,
|
|
6331, 1, 0, 0, 0, 6333, 569, 1, 0, 0, 0, 6334, 6337, 3, 584, 292, 0, 6335,
|
|
6337, 5, 1148, 0, 0, 6336, 6334, 1, 0, 0, 0, 6336, 6335, 1, 0, 0, 0, 6337,
|
|
571, 1, 0, 0, 0, 6338, 6342, 3, 574, 287, 0, 6339, 6342, 5, 1156, 0, 0,
|
|
6340, 6342, 5, 1148, 0, 0, 6341, 6338, 1, 0, 0, 0, 6341, 6339, 1, 0, 0,
|
|
0, 6341, 6340, 1, 0, 0, 0, 6342, 573, 1, 0, 0, 0, 6343, 6344, 7, 96, 0,
|
|
0, 6344, 575, 1, 0, 0, 0, 6345, 6346, 3, 590, 295, 0, 6346, 6347, 5, 1121,
|
|
0, 0, 6347, 6348, 3, 590, 295, 0, 6348, 6349, 5, 1121, 0, 0, 6349, 6350,
|
|
3, 590, 295, 0, 6350, 6351, 5, 1121, 0, 0, 6351, 6352, 3, 590, 295, 0,
|
|
6352, 6353, 5, 1121, 0, 0, 6353, 6359, 3, 590, 295, 0, 6354, 6355, 5, 1144,
|
|
0, 0, 6355, 6356, 3, 590, 295, 0, 6356, 6357, 5, 1121, 0, 0, 6357, 6358,
|
|
3, 590, 295, 0, 6358, 6360, 1, 0, 0, 0, 6359, 6354, 1, 0, 0, 0, 6360, 6361,
|
|
1, 0, 0, 0, 6361, 6359, 1, 0, 0, 0, 6361, 6362, 1, 0, 0, 0, 6362, 577,
|
|
1, 0, 0, 0, 6363, 6370, 3, 580, 290, 0, 6364, 6365, 5, 1135, 0, 0, 6365,
|
|
6368, 3, 580, 290, 0, 6366, 6367, 5, 1135, 0, 0, 6367, 6369, 3, 590, 295,
|
|
0, 6368, 6366, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, 6371, 1, 0, 0,
|
|
0, 6370, 6364, 1, 0, 0, 0, 6370, 6371, 1, 0, 0, 0, 6371, 579, 1, 0, 0,
|
|
0, 6372, 6380, 5, 1148, 0, 0, 6373, 6380, 5, 1153, 0, 0, 6374, 6376, 5,
|
|
1150, 0, 0, 6375, 6374, 1, 0, 0, 0, 6376, 6377, 1, 0, 0, 0, 6377, 6375,
|
|
1, 0, 0, 0, 6377, 6378, 1, 0, 0, 0, 6378, 6380, 1, 0, 0, 0, 6379, 6372,
|
|
1, 0, 0, 0, 6379, 6373, 1, 0, 0, 0, 6379, 6375, 1, 0, 0, 0, 6380, 581,
|
|
1, 0, 0, 0, 6381, 6384, 3, 584, 292, 0, 6382, 6384, 5, 1148, 0, 0, 6383,
|
|
6381, 1, 0, 0, 0, 6383, 6382, 1, 0, 0, 0, 6384, 583, 1, 0, 0, 0, 6385,
|
|
6389, 3, 586, 293, 0, 6386, 6389, 5, 1145, 0, 0, 6387, 6389, 5, 1148, 0,
|
|
0, 6388, 6385, 1, 0, 0, 0, 6388, 6386, 1, 0, 0, 0, 6388, 6387, 1, 0, 0,
|
|
0, 6389, 585, 1, 0, 0, 0, 6390, 6400, 5, 1156, 0, 0, 6391, 6400, 3, 708,
|
|
354, 0, 6392, 6400, 3, 710, 355, 0, 6393, 6400, 3, 574, 287, 0, 6394, 6400,
|
|
3, 712, 356, 0, 6395, 6400, 3, 714, 357, 0, 6396, 6400, 3, 716, 358, 0,
|
|
6397, 6400, 3, 718, 359, 0, 6398, 6400, 3, 680, 340, 0, 6399, 6390, 1,
|
|
0, 0, 0, 6399, 6391, 1, 0, 0, 0, 6399, 6392, 1, 0, 0, 0, 6399, 6393, 1,
|
|
0, 0, 0, 6399, 6394, 1, 0, 0, 0, 6399, 6395, 1, 0, 0, 0, 6399, 6396, 1,
|
|
0, 0, 0, 6399, 6397, 1, 0, 0, 0, 6399, 6398, 1, 0, 0, 0, 6400, 587, 1,
|
|
0, 0, 0, 6401, 6405, 5, 1155, 0, 0, 6402, 6403, 5, 1132, 0, 0, 6403, 6405,
|
|
3, 584, 292, 0, 6404, 6401, 1, 0, 0, 0, 6404, 6402, 1, 0, 0, 0, 6405, 589,
|
|
1, 0, 0, 0, 6406, 6407, 7, 97, 0, 0, 6407, 591, 1, 0, 0, 0, 6408, 6411,
|
|
5, 1146, 0, 0, 6409, 6411, 3, 590, 295, 0, 6410, 6408, 1, 0, 0, 0, 6410,
|
|
6409, 1, 0, 0, 0, 6411, 593, 1, 0, 0, 0, 6412, 6414, 5, 1154, 0, 0, 6413,
|
|
6412, 1, 0, 0, 0, 6413, 6414, 1, 0, 0, 0, 6414, 6415, 1, 0, 0, 0, 6415,
|
|
6418, 5, 1148, 0, 0, 6416, 6418, 5, 1147, 0, 0, 6417, 6413, 1, 0, 0, 0,
|
|
6417, 6416, 1, 0, 0, 0, 6418, 6420, 1, 0, 0, 0, 6419, 6421, 5, 1148, 0,
|
|
0, 6420, 6419, 1, 0, 0, 0, 6421, 6422, 1, 0, 0, 0, 6422, 6420, 1, 0, 0,
|
|
0, 6422, 6423, 1, 0, 0, 0, 6423, 6436, 1, 0, 0, 0, 6424, 6426, 5, 1154,
|
|
0, 0, 6425, 6424, 1, 0, 0, 0, 6425, 6426, 1, 0, 0, 0, 6426, 6427, 1, 0,
|
|
0, 0, 6427, 6430, 5, 1148, 0, 0, 6428, 6430, 5, 1147, 0, 0, 6429, 6425,
|
|
1, 0, 0, 0, 6429, 6428, 1, 0, 0, 0, 6430, 6433, 1, 0, 0, 0, 6431, 6432,
|
|
5, 27, 0, 0, 6432, 6434, 3, 570, 285, 0, 6433, 6431, 1, 0, 0, 0, 6433,
|
|
6434, 1, 0, 0, 0, 6434, 6436, 1, 0, 0, 0, 6435, 6417, 1, 0, 0, 0, 6435,
|
|
6429, 1, 0, 0, 0, 6436, 595, 1, 0, 0, 0, 6437, 6438, 7, 98, 0, 0, 6438,
|
|
597, 1, 0, 0, 0, 6439, 6441, 5, 1154, 0, 0, 6440, 6439, 1, 0, 0, 0, 6440,
|
|
6441, 1, 0, 0, 0, 6441, 6442, 1, 0, 0, 0, 6442, 6443, 5, 1150, 0, 0, 6443,
|
|
599, 1, 0, 0, 0, 6444, 6446, 5, 114, 0, 0, 6445, 6444, 1, 0, 0, 0, 6445,
|
|
6446, 1, 0, 0, 0, 6446, 6447, 1, 0, 0, 0, 6447, 6448, 7, 99, 0, 0, 6448,
|
|
601, 1, 0, 0, 0, 6449, 6462, 3, 594, 297, 0, 6450, 6462, 3, 590, 295, 0,
|
|
6451, 6452, 5, 1121, 0, 0, 6452, 6462, 3, 590, 295, 0, 6453, 6462, 3, 598,
|
|
299, 0, 6454, 6462, 3, 596, 298, 0, 6455, 6462, 5, 1151, 0, 0, 6456, 6462,
|
|
5, 1153, 0, 0, 6457, 6459, 5, 114, 0, 0, 6458, 6457, 1, 0, 0, 0, 6458,
|
|
6459, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6462, 7, 99, 0, 0, 6461,
|
|
6449, 1, 0, 0, 0, 6461, 6450, 1, 0, 0, 0, 6461, 6451, 1, 0, 0, 0, 6461,
|
|
6453, 1, 0, 0, 0, 6461, 6454, 1, 0, 0, 0, 6461, 6455, 1, 0, 0, 0, 6461,
|
|
6456, 1, 0, 0, 0, 6461, 6458, 1, 0, 0, 0, 6462, 603, 1, 0, 0, 0, 6463,
|
|
6465, 7, 100, 0, 0, 6464, 6466, 5, 238, 0, 0, 6465, 6464, 1, 0, 0, 0, 6465,
|
|
6466, 1, 0, 0, 0, 6466, 6468, 1, 0, 0, 0, 6467, 6469, 3, 610, 305, 0, 6468,
|
|
6467, 1, 0, 0, 0, 6468, 6469, 1, 0, 0, 0, 6469, 6471, 1, 0, 0, 0, 6470,
|
|
6472, 5, 226, 0, 0, 6471, 6470, 1, 0, 0, 0, 6471, 6472, 1, 0, 0, 0, 6472,
|
|
6476, 1, 0, 0, 0, 6473, 6474, 3, 60, 30, 0, 6474, 6475, 3, 568, 284, 0,
|
|
6475, 6477, 1, 0, 0, 0, 6476, 6473, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0,
|
|
6477, 6481, 1, 0, 0, 0, 6478, 6479, 5, 27, 0, 0, 6479, 6482, 3, 570, 285,
|
|
0, 6480, 6482, 5, 226, 0, 0, 6481, 6478, 1, 0, 0, 0, 6481, 6480, 1, 0,
|
|
0, 0, 6481, 6482, 1, 0, 0, 0, 6482, 6590, 1, 0, 0, 0, 6483, 6484, 5, 225,
|
|
0, 0, 6484, 6485, 7, 101, 0, 0, 6485, 6487, 5, 238, 0, 0, 6486, 6488, 3,
|
|
610, 305, 0, 6487, 6486, 1, 0, 0, 0, 6487, 6488, 1, 0, 0, 0, 6488, 6490,
|
|
1, 0, 0, 0, 6489, 6491, 5, 226, 0, 0, 6490, 6489, 1, 0, 0, 0, 6490, 6491,
|
|
1, 0, 0, 0, 6491, 6590, 1, 0, 0, 0, 6492, 6493, 5, 225, 0, 0, 6493, 6495,
|
|
7, 102, 0, 0, 6494, 6496, 3, 610, 305, 0, 6495, 6494, 1, 0, 0, 0, 6495,
|
|
6496, 1, 0, 0, 0, 6496, 6498, 1, 0, 0, 0, 6497, 6499, 5, 226, 0, 0, 6498,
|
|
6497, 1, 0, 0, 0, 6498, 6499, 1, 0, 0, 0, 6499, 6590, 1, 0, 0, 0, 6500,
|
|
6501, 5, 518, 0, 0, 6501, 6503, 5, 223, 0, 0, 6502, 6504, 3, 610, 305,
|
|
0, 6503, 6502, 1, 0, 0, 0, 6503, 6504, 1, 0, 0, 0, 6504, 6506, 1, 0, 0,
|
|
0, 6505, 6507, 5, 226, 0, 0, 6506, 6505, 1, 0, 0, 0, 6506, 6507, 1, 0,
|
|
0, 0, 6507, 6590, 1, 0, 0, 0, 6508, 6510, 7, 103, 0, 0, 6509, 6511, 3,
|
|
610, 305, 0, 6510, 6509, 1, 0, 0, 0, 6510, 6511, 1, 0, 0, 0, 6511, 6515,
|
|
1, 0, 0, 0, 6512, 6514, 7, 104, 0, 0, 6513, 6512, 1, 0, 0, 0, 6514, 6517,
|
|
1, 0, 0, 0, 6515, 6513, 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6590,
|
|
1, 0, 0, 0, 6517, 6515, 1, 0, 0, 0, 6518, 6520, 5, 208, 0, 0, 6519, 6521,
|
|
3, 612, 306, 0, 6520, 6519, 1, 0, 0, 0, 6520, 6521, 1, 0, 0, 0, 6521, 6525,
|
|
1, 0, 0, 0, 6522, 6524, 7, 104, 0, 0, 6523, 6522, 1, 0, 0, 0, 6524, 6527,
|
|
1, 0, 0, 0, 6525, 6523, 1, 0, 0, 0, 6525, 6526, 1, 0, 0, 0, 6526, 6590,
|
|
1, 0, 0, 0, 6527, 6525, 1, 0, 0, 0, 6528, 6530, 5, 209, 0, 0, 6529, 6531,
|
|
5, 210, 0, 0, 6530, 6529, 1, 0, 0, 0, 6530, 6531, 1, 0, 0, 0, 6531, 6533,
|
|
1, 0, 0, 0, 6532, 6534, 3, 612, 306, 0, 6533, 6532, 1, 0, 0, 0, 6533, 6534,
|
|
1, 0, 0, 0, 6534, 6538, 1, 0, 0, 0, 6535, 6537, 7, 104, 0, 0, 6536, 6535,
|
|
1, 0, 0, 0, 6537, 6540, 1, 0, 0, 0, 6538, 6536, 1, 0, 0, 0, 6538, 6539,
|
|
1, 0, 0, 0, 6539, 6590, 1, 0, 0, 0, 6540, 6538, 1, 0, 0, 0, 6541, 6543,
|
|
7, 105, 0, 0, 6542, 6544, 3, 614, 307, 0, 6543, 6542, 1, 0, 0, 0, 6543,
|
|
6544, 1, 0, 0, 0, 6544, 6548, 1, 0, 0, 0, 6545, 6547, 7, 104, 0, 0, 6546,
|
|
6545, 1, 0, 0, 0, 6547, 6550, 1, 0, 0, 0, 6548, 6546, 1, 0, 0, 0, 6548,
|
|
6549, 1, 0, 0, 0, 6549, 6590, 1, 0, 0, 0, 6550, 6548, 1, 0, 0, 0, 6551,
|
|
6590, 7, 106, 0, 0, 6552, 6554, 7, 107, 0, 0, 6553, 6555, 3, 610, 305,
|
|
0, 6554, 6553, 1, 0, 0, 0, 6554, 6555, 1, 0, 0, 0, 6555, 6590, 1, 0, 0,
|
|
0, 6556, 6557, 7, 108, 0, 0, 6557, 6559, 3, 606, 303, 0, 6558, 6560, 5,
|
|
226, 0, 0, 6559, 6558, 1, 0, 0, 0, 6559, 6560, 1, 0, 0, 0, 6560, 6564,
|
|
1, 0, 0, 0, 6561, 6562, 3, 60, 30, 0, 6562, 6563, 3, 568, 284, 0, 6563,
|
|
6565, 1, 0, 0, 0, 6564, 6561, 1, 0, 0, 0, 6564, 6565, 1, 0, 0, 0, 6565,
|
|
6590, 1, 0, 0, 0, 6566, 6569, 7, 109, 0, 0, 6567, 6568, 5, 1012, 0, 0,
|
|
6568, 6570, 3, 590, 295, 0, 6569, 6567, 1, 0, 0, 0, 6569, 6570, 1, 0, 0,
|
|
0, 6570, 6590, 1, 0, 0, 0, 6571, 6573, 5, 231, 0, 0, 6572, 6574, 5, 223,
|
|
0, 0, 6573, 6572, 1, 0, 0, 0, 6573, 6574, 1, 0, 0, 0, 6574, 6576, 1, 0,
|
|
0, 0, 6575, 6577, 5, 226, 0, 0, 6576, 6575, 1, 0, 0, 0, 6576, 6577, 1,
|
|
0, 0, 0, 6577, 6581, 1, 0, 0, 0, 6578, 6579, 3, 60, 30, 0, 6579, 6580,
|
|
3, 568, 284, 0, 6580, 6582, 1, 0, 0, 0, 6581, 6578, 1, 0, 0, 0, 6581, 6582,
|
|
1, 0, 0, 0, 6582, 6585, 1, 0, 0, 0, 6583, 6584, 5, 27, 0, 0, 6584, 6586,
|
|
3, 570, 285, 0, 6585, 6583, 1, 0, 0, 0, 6585, 6586, 1, 0, 0, 0, 6586, 6590,
|
|
1, 0, 0, 0, 6587, 6588, 5, 231, 0, 0, 6588, 6590, 5, 227, 0, 0, 6589, 6463,
|
|
1, 0, 0, 0, 6589, 6483, 1, 0, 0, 0, 6589, 6492, 1, 0, 0, 0, 6589, 6500,
|
|
1, 0, 0, 0, 6589, 6508, 1, 0, 0, 0, 6589, 6518, 1, 0, 0, 0, 6589, 6528,
|
|
1, 0, 0, 0, 6589, 6541, 1, 0, 0, 0, 6589, 6551, 1, 0, 0, 0, 6589, 6552,
|
|
1, 0, 0, 0, 6589, 6556, 1, 0, 0, 0, 6589, 6566, 1, 0, 0, 0, 6589, 6571,
|
|
1, 0, 0, 0, 6589, 6587, 1, 0, 0, 0, 6590, 605, 1, 0, 0, 0, 6591, 6592,
|
|
5, 1133, 0, 0, 6592, 6597, 5, 1148, 0, 0, 6593, 6594, 5, 1135, 0, 0, 6594,
|
|
6596, 5, 1148, 0, 0, 6595, 6593, 1, 0, 0, 0, 6596, 6599, 1, 0, 0, 0, 6597,
|
|
6595, 1, 0, 0, 0, 6597, 6598, 1, 0, 0, 0, 6598, 6600, 1, 0, 0, 0, 6599,
|
|
6597, 1, 0, 0, 0, 6600, 6601, 5, 1134, 0, 0, 6601, 607, 1, 0, 0, 0, 6602,
|
|
6604, 7, 110, 0, 0, 6603, 6605, 3, 610, 305, 0, 6604, 6603, 1, 0, 0, 0,
|
|
6604, 6605, 1, 0, 0, 0, 6605, 6625, 1, 0, 0, 0, 6606, 6608, 5, 222, 0,
|
|
0, 6607, 6609, 3, 610, 305, 0, 6608, 6607, 1, 0, 0, 0, 6608, 6609, 1, 0,
|
|
0, 0, 6609, 6613, 1, 0, 0, 0, 6610, 6611, 3, 60, 30, 0, 6611, 6612, 3,
|
|
568, 284, 0, 6612, 6614, 1, 0, 0, 0, 6613, 6610, 1, 0, 0, 0, 6613, 6614,
|
|
1, 0, 0, 0, 6614, 6625, 1, 0, 0, 0, 6615, 6625, 7, 111, 0, 0, 6616, 6618,
|
|
7, 112, 0, 0, 6617, 6619, 3, 614, 307, 0, 6618, 6617, 1, 0, 0, 0, 6618,
|
|
6619, 1, 0, 0, 0, 6619, 6625, 1, 0, 0, 0, 6620, 6622, 7, 113, 0, 0, 6621,
|
|
6623, 7, 114, 0, 0, 6622, 6621, 1, 0, 0, 0, 6622, 6623, 1, 0, 0, 0, 6623,
|
|
6625, 1, 0, 0, 0, 6624, 6602, 1, 0, 0, 0, 6624, 6606, 1, 0, 0, 0, 6624,
|
|
6615, 1, 0, 0, 0, 6624, 6616, 1, 0, 0, 0, 6624, 6620, 1, 0, 0, 0, 6625,
|
|
6627, 1, 0, 0, 0, 6626, 6628, 5, 11, 0, 0, 6627, 6626, 1, 0, 0, 0, 6627,
|
|
6628, 1, 0, 0, 0, 6628, 609, 1, 0, 0, 0, 6629, 6630, 5, 1133, 0, 0, 6630,
|
|
6631, 3, 590, 295, 0, 6631, 6632, 5, 1134, 0, 0, 6632, 611, 1, 0, 0, 0,
|
|
6633, 6634, 5, 1133, 0, 0, 6634, 6635, 3, 590, 295, 0, 6635, 6636, 5, 1135,
|
|
0, 0, 6636, 6637, 3, 590, 295, 0, 6637, 6638, 5, 1134, 0, 0, 6638, 613,
|
|
1, 0, 0, 0, 6639, 6640, 5, 1133, 0, 0, 6640, 6643, 3, 590, 295, 0, 6641,
|
|
6642, 5, 1135, 0, 0, 6642, 6644, 3, 590, 295, 0, 6643, 6641, 1, 0, 0, 0,
|
|
6643, 6644, 1, 0, 0, 0, 6644, 6645, 1, 0, 0, 0, 6645, 6646, 5, 1134, 0,
|
|
0, 6646, 615, 1, 0, 0, 0, 6647, 6652, 3, 584, 292, 0, 6648, 6649, 5, 1135,
|
|
0, 0, 6649, 6651, 3, 584, 292, 0, 6650, 6648, 1, 0, 0, 0, 6651, 6654, 1,
|
|
0, 0, 0, 6652, 6650, 1, 0, 0, 0, 6652, 6653, 1, 0, 0, 0, 6653, 617, 1,
|
|
0, 0, 0, 6654, 6652, 1, 0, 0, 0, 6655, 6660, 3, 556, 278, 0, 6656, 6657,
|
|
5, 1135, 0, 0, 6657, 6659, 3, 556, 278, 0, 6658, 6656, 1, 0, 0, 0, 6659,
|
|
6662, 1, 0, 0, 0, 6660, 6658, 1, 0, 0, 0, 6660, 6661, 1, 0, 0, 0, 6661,
|
|
619, 1, 0, 0, 0, 6662, 6660, 1, 0, 0, 0, 6663, 6668, 3, 552, 276, 0, 6664,
|
|
6665, 5, 1135, 0, 0, 6665, 6667, 3, 552, 276, 0, 6666, 6664, 1, 0, 0, 0,
|
|
6667, 6670, 1, 0, 0, 0, 6668, 6666, 1, 0, 0, 0, 6668, 6669, 1, 0, 0, 0,
|
|
6669, 621, 1, 0, 0, 0, 6670, 6668, 1, 0, 0, 0, 6671, 6672, 5, 1133, 0,
|
|
0, 6672, 6677, 3, 558, 279, 0, 6673, 6674, 5, 1135, 0, 0, 6674, 6676, 3,
|
|
558, 279, 0, 6675, 6673, 1, 0, 0, 0, 6676, 6679, 1, 0, 0, 0, 6677, 6675,
|
|
1, 0, 0, 0, 6677, 6678, 1, 0, 0, 0, 6678, 6680, 1, 0, 0, 0, 6679, 6677,
|
|
1, 0, 0, 0, 6680, 6681, 5, 1134, 0, 0, 6681, 623, 1, 0, 0, 0, 6682, 6687,
|
|
3, 688, 344, 0, 6683, 6684, 5, 1135, 0, 0, 6684, 6686, 3, 688, 344, 0,
|
|
6685, 6683, 1, 0, 0, 0, 6686, 6689, 1, 0, 0, 0, 6687, 6685, 1, 0, 0, 0,
|
|
6687, 6688, 1, 0, 0, 0, 6688, 625, 1, 0, 0, 0, 6689, 6687, 1, 0, 0, 0,
|
|
6690, 6695, 3, 638, 319, 0, 6691, 6692, 5, 1135, 0, 0, 6692, 6694, 3, 638,
|
|
319, 0, 6693, 6691, 1, 0, 0, 0, 6694, 6697, 1, 0, 0, 0, 6695, 6693, 1,
|
|
0, 0, 0, 6695, 6696, 1, 0, 0, 0, 6696, 627, 1, 0, 0, 0, 6697, 6695, 1,
|
|
0, 0, 0, 6698, 6703, 3, 602, 301, 0, 6699, 6700, 5, 1135, 0, 0, 6700, 6702,
|
|
3, 602, 301, 0, 6701, 6699, 1, 0, 0, 0, 6702, 6705, 1, 0, 0, 0, 6703, 6701,
|
|
1, 0, 0, 0, 6703, 6704, 1, 0, 0, 0, 6704, 629, 1, 0, 0, 0, 6705, 6703,
|
|
1, 0, 0, 0, 6706, 6711, 5, 1148, 0, 0, 6707, 6708, 5, 1135, 0, 0, 6708,
|
|
6710, 5, 1148, 0, 0, 6709, 6707, 1, 0, 0, 0, 6710, 6713, 1, 0, 0, 0, 6711,
|
|
6709, 1, 0, 0, 0, 6711, 6712, 1, 0, 0, 0, 6712, 631, 1, 0, 0, 0, 6713,
|
|
6711, 1, 0, 0, 0, 6714, 6719, 5, 1159, 0, 0, 6715, 6716, 5, 1135, 0, 0,
|
|
6716, 6718, 5, 1159, 0, 0, 6717, 6715, 1, 0, 0, 0, 6718, 6721, 1, 0, 0,
|
|
0, 6719, 6717, 1, 0, 0, 0, 6719, 6720, 1, 0, 0, 0, 6720, 633, 1, 0, 0,
|
|
0, 6721, 6719, 1, 0, 0, 0, 6722, 6749, 5, 116, 0, 0, 6723, 6724, 5, 23,
|
|
0, 0, 6724, 6725, 5, 1133, 0, 0, 6725, 6726, 3, 688, 344, 0, 6726, 6727,
|
|
5, 12, 0, 0, 6727, 6728, 3, 608, 304, 0, 6728, 6729, 5, 1134, 0, 0, 6729,
|
|
6749, 1, 0, 0, 0, 6730, 6732, 3, 694, 347, 0, 6731, 6730, 1, 0, 0, 0, 6731,
|
|
6732, 1, 0, 0, 0, 6732, 6733, 1, 0, 0, 0, 6733, 6749, 3, 602, 301, 0, 6734,
|
|
6738, 3, 636, 318, 0, 6735, 6736, 5, 118, 0, 0, 6736, 6737, 5, 184, 0,
|
|
0, 6737, 6739, 3, 636, 318, 0, 6738, 6735, 1, 0, 0, 0, 6738, 6739, 1, 0,
|
|
0, 0, 6739, 6749, 1, 0, 0, 0, 6740, 6741, 5, 1133, 0, 0, 6741, 6742, 3,
|
|
688, 344, 0, 6742, 6743, 5, 1134, 0, 0, 6743, 6749, 1, 0, 0, 0, 6744, 6745,
|
|
5, 1133, 0, 0, 6745, 6746, 3, 550, 275, 0, 6746, 6747, 5, 1134, 0, 0, 6747,
|
|
6749, 1, 0, 0, 0, 6748, 6722, 1, 0, 0, 0, 6748, 6723, 1, 0, 0, 0, 6748,
|
|
6731, 1, 0, 0, 0, 6748, 6734, 1, 0, 0, 0, 6748, 6740, 1, 0, 0, 0, 6748,
|
|
6744, 1, 0, 0, 0, 6749, 635, 1, 0, 0, 0, 6750, 6756, 7, 115, 0, 0, 6751,
|
|
6753, 5, 1133, 0, 0, 6752, 6754, 3, 590, 295, 0, 6753, 6752, 1, 0, 0, 0,
|
|
6753, 6754, 1, 0, 0, 0, 6754, 6755, 1, 0, 0, 0, 6755, 6757, 5, 1134, 0,
|
|
0, 6756, 6751, 1, 0, 0, 0, 6756, 6757, 1, 0, 0, 0, 6757, 6765, 1, 0, 0,
|
|
0, 6758, 6759, 5, 323, 0, 0, 6759, 6761, 5, 1133, 0, 0, 6760, 6762, 3,
|
|
590, 295, 0, 6761, 6760, 1, 0, 0, 0, 6761, 6762, 1, 0, 0, 0, 6762, 6763,
|
|
1, 0, 0, 0, 6763, 6765, 5, 1134, 0, 0, 6764, 6750, 1, 0, 0, 0, 6764, 6758,
|
|
1, 0, 0, 0, 6765, 637, 1, 0, 0, 0, 6766, 6769, 3, 688, 344, 0, 6767, 6769,
|
|
5, 42, 0, 0, 6768, 6766, 1, 0, 0, 0, 6768, 6767, 1, 0, 0, 0, 6769, 639,
|
|
1, 0, 0, 0, 6770, 6771, 5, 77, 0, 0, 6771, 6772, 5, 60, 0, 0, 6772, 641,
|
|
1, 0, 0, 0, 6773, 6774, 5, 77, 0, 0, 6774, 6775, 5, 114, 0, 0, 6775, 6776,
|
|
5, 60, 0, 0, 6776, 643, 1, 0, 0, 0, 6777, 6778, 5, 123, 0, 0, 6778, 6779,
|
|
5, 141, 0, 0, 6779, 645, 1, 0, 0, 0, 6780, 6781, 5, 674, 0, 0, 6781, 6784,
|
|
3, 590, 295, 0, 6782, 6784, 5, 527, 0, 0, 6783, 6780, 1, 0, 0, 0, 6783,
|
|
6782, 1, 0, 0, 0, 6784, 647, 1, 0, 0, 0, 6785, 6804, 3, 650, 325, 0, 6786,
|
|
6804, 3, 658, 329, 0, 6787, 6804, 3, 660, 330, 0, 6788, 6789, 3, 680, 340,
|
|
0, 6789, 6791, 5, 1133, 0, 0, 6790, 6792, 3, 684, 342, 0, 6791, 6790, 1,
|
|
0, 0, 0, 6791, 6792, 1, 0, 0, 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, 5,
|
|
1134, 0, 0, 6794, 6804, 1, 0, 0, 0, 6795, 6796, 3, 550, 275, 0, 6796, 6798,
|
|
5, 1133, 0, 0, 6797, 6799, 3, 684, 342, 0, 6798, 6797, 1, 0, 0, 0, 6798,
|
|
6799, 1, 0, 0, 0, 6799, 6800, 1, 0, 0, 0, 6800, 6801, 5, 1134, 0, 0, 6801,
|
|
6804, 1, 0, 0, 0, 6802, 6804, 3, 682, 341, 0, 6803, 6785, 1, 0, 0, 0, 6803,
|
|
6786, 1, 0, 0, 0, 6803, 6787, 1, 0, 0, 0, 6803, 6788, 1, 0, 0, 0, 6803,
|
|
6795, 1, 0, 0, 0, 6803, 6802, 1, 0, 0, 0, 6804, 649, 1, 0, 0, 0, 6805,
|
|
6808, 7, 116, 0, 0, 6806, 6807, 5, 1133, 0, 0, 6807, 6809, 5, 1134, 0,
|
|
0, 6808, 6806, 1, 0, 0, 0, 6808, 6809, 1, 0, 0, 0, 6809, 6985, 1, 0, 0,
|
|
0, 6810, 6985, 3, 62, 31, 0, 6811, 6812, 5, 32, 0, 0, 6812, 6813, 5, 1133,
|
|
0, 0, 6813, 6814, 3, 688, 344, 0, 6814, 6815, 5, 1135, 0, 0, 6815, 6816,
|
|
3, 608, 304, 0, 6816, 6817, 5, 1134, 0, 0, 6817, 6985, 1, 0, 0, 0, 6818,
|
|
6819, 5, 32, 0, 0, 6819, 6820, 5, 1133, 0, 0, 6820, 6821, 3, 688, 344,
|
|
0, 6821, 6822, 5, 187, 0, 0, 6822, 6823, 3, 568, 284, 0, 6823, 6824, 5,
|
|
1134, 0, 0, 6824, 6985, 1, 0, 0, 0, 6825, 6826, 5, 23, 0, 0, 6826, 6827,
|
|
5, 1133, 0, 0, 6827, 6828, 3, 688, 344, 0, 6828, 6829, 5, 12, 0, 0, 6829,
|
|
6830, 3, 608, 304, 0, 6830, 6831, 5, 1134, 0, 0, 6831, 6985, 1, 0, 0, 0,
|
|
6832, 6833, 5, 188, 0, 0, 6833, 6834, 5, 1133, 0, 0, 6834, 6835, 3, 556,
|
|
278, 0, 6835, 6836, 5, 1134, 0, 0, 6836, 6985, 1, 0, 0, 0, 6837, 6838,
|
|
5, 22, 0, 0, 6838, 6840, 3, 688, 344, 0, 6839, 6841, 3, 652, 326, 0, 6840,
|
|
6839, 1, 0, 0, 0, 6841, 6842, 1, 0, 0, 0, 6842, 6840, 1, 0, 0, 0, 6842,
|
|
6843, 1, 0, 0, 0, 6843, 6846, 1, 0, 0, 0, 6844, 6845, 5, 53, 0, 0, 6845,
|
|
6847, 3, 686, 343, 0, 6846, 6844, 1, 0, 0, 0, 6846, 6847, 1, 0, 0, 0, 6847,
|
|
6848, 1, 0, 0, 0, 6848, 6849, 5, 407, 0, 0, 6849, 6985, 1, 0, 0, 0, 6850,
|
|
6852, 5, 22, 0, 0, 6851, 6853, 3, 652, 326, 0, 6852, 6851, 1, 0, 0, 0,
|
|
6853, 6854, 1, 0, 0, 0, 6854, 6852, 1, 0, 0, 0, 6854, 6855, 1, 0, 0, 0,
|
|
6855, 6858, 1, 0, 0, 0, 6856, 6857, 5, 53, 0, 0, 6857, 6859, 3, 686, 343,
|
|
0, 6858, 6856, 1, 0, 0, 0, 6858, 6859, 1, 0, 0, 0, 6859, 6860, 1, 0, 0,
|
|
0, 6860, 6861, 5, 407, 0, 0, 6861, 6985, 1, 0, 0, 0, 6862, 6863, 5, 222,
|
|
0, 0, 6863, 6864, 5, 1133, 0, 0, 6864, 6867, 3, 684, 342, 0, 6865, 6866,
|
|
5, 187, 0, 0, 6866, 6868, 3, 568, 284, 0, 6867, 6865, 1, 0, 0, 0, 6867,
|
|
6868, 1, 0, 0, 0, 6868, 6869, 1, 0, 0, 0, 6869, 6870, 5, 1134, 0, 0, 6870,
|
|
6985, 1, 0, 0, 0, 6871, 6872, 5, 324, 0, 0, 6872, 6875, 5, 1133, 0, 0,
|
|
6873, 6876, 3, 594, 297, 0, 6874, 6876, 3, 688, 344, 0, 6875, 6873, 1,
|
|
0, 0, 0, 6875, 6874, 1, 0, 0, 0, 6876, 6877, 1, 0, 0, 0, 6877, 6880, 5,
|
|
80, 0, 0, 6878, 6881, 3, 594, 297, 0, 6879, 6881, 3, 688, 344, 0, 6880,
|
|
6878, 1, 0, 0, 0, 6880, 6879, 1, 0, 0, 0, 6881, 6882, 1, 0, 0, 0, 6882,
|
|
6883, 5, 1134, 0, 0, 6883, 6985, 1, 0, 0, 0, 6884, 6885, 7, 117, 0, 0,
|
|
6885, 6888, 5, 1133, 0, 0, 6886, 6889, 3, 594, 297, 0, 6887, 6889, 3, 688,
|
|
344, 0, 6888, 6886, 1, 0, 0, 0, 6888, 6887, 1, 0, 0, 0, 6889, 6890, 1,
|
|
0, 0, 0, 6890, 6893, 5, 68, 0, 0, 6891, 6894, 3, 590, 295, 0, 6892, 6894,
|
|
3, 688, 344, 0, 6893, 6891, 1, 0, 0, 0, 6893, 6892, 1, 0, 0, 0, 6894, 6900,
|
|
1, 0, 0, 0, 6895, 6898, 5, 65, 0, 0, 6896, 6899, 3, 590, 295, 0, 6897,
|
|
6899, 3, 688, 344, 0, 6898, 6896, 1, 0, 0, 0, 6898, 6897, 1, 0, 0, 0, 6899,
|
|
6901, 1, 0, 0, 0, 6900, 6895, 1, 0, 0, 0, 6900, 6901, 1, 0, 0, 0, 6901,
|
|
6902, 1, 0, 0, 0, 6902, 6903, 5, 1134, 0, 0, 6903, 6985, 1, 0, 0, 0, 6904,
|
|
6905, 5, 328, 0, 0, 6905, 6906, 5, 1133, 0, 0, 6906, 6909, 7, 118, 0, 0,
|
|
6907, 6910, 3, 594, 297, 0, 6908, 6910, 3, 688, 344, 0, 6909, 6907, 1,
|
|
0, 0, 0, 6909, 6908, 1, 0, 0, 0, 6909, 6910, 1, 0, 0, 0, 6910, 6911, 1,
|
|
0, 0, 0, 6911, 6914, 5, 68, 0, 0, 6912, 6915, 3, 594, 297, 0, 6913, 6915,
|
|
3, 688, 344, 0, 6914, 6912, 1, 0, 0, 0, 6914, 6913, 1, 0, 0, 0, 6915, 6916,
|
|
1, 0, 0, 0, 6916, 6917, 5, 1134, 0, 0, 6917, 6985, 1, 0, 0, 0, 6918, 6919,
|
|
5, 328, 0, 0, 6919, 6922, 5, 1133, 0, 0, 6920, 6923, 3, 594, 297, 0, 6921,
|
|
6923, 3, 688, 344, 0, 6922, 6920, 1, 0, 0, 0, 6922, 6921, 1, 0, 0, 0, 6923,
|
|
6924, 1, 0, 0, 0, 6924, 6927, 5, 68, 0, 0, 6925, 6928, 3, 594, 297, 0,
|
|
6926, 6928, 3, 688, 344, 0, 6927, 6925, 1, 0, 0, 0, 6927, 6926, 1, 0, 0,
|
|
0, 6928, 6929, 1, 0, 0, 0, 6929, 6930, 5, 1134, 0, 0, 6930, 6985, 1, 0,
|
|
0, 0, 6931, 6932, 5, 1103, 0, 0, 6932, 6935, 5, 1133, 0, 0, 6933, 6936,
|
|
3, 594, 297, 0, 6934, 6936, 3, 688, 344, 0, 6935, 6933, 1, 0, 0, 0, 6935,
|
|
6934, 1, 0, 0, 0, 6936, 6943, 1, 0, 0, 0, 6937, 6938, 5, 12, 0, 0, 6938,
|
|
6939, 7, 119, 0, 0, 6939, 6940, 5, 1133, 0, 0, 6940, 6941, 3, 590, 295,
|
|
0, 6941, 6942, 5, 1134, 0, 0, 6942, 6944, 1, 0, 0, 0, 6943, 6937, 1, 0,
|
|
0, 0, 6943, 6944, 1, 0, 0, 0, 6944, 6946, 1, 0, 0, 0, 6945, 6947, 3, 654,
|
|
327, 0, 6946, 6945, 1, 0, 0, 0, 6946, 6947, 1, 0, 0, 0, 6947, 6948, 1,
|
|
0, 0, 0, 6948, 6949, 5, 1134, 0, 0, 6949, 6985, 1, 0, 0, 0, 6950, 6951,
|
|
5, 321, 0, 0, 6951, 6952, 5, 1133, 0, 0, 6952, 6953, 3, 72, 36, 0, 6953,
|
|
6956, 5, 68, 0, 0, 6954, 6957, 3, 594, 297, 0, 6955, 6957, 3, 688, 344,
|
|
0, 6956, 6954, 1, 0, 0, 0, 6956, 6955, 1, 0, 0, 0, 6957, 6958, 1, 0, 0,
|
|
0, 6958, 6959, 5, 1134, 0, 0, 6959, 6985, 1, 0, 0, 0, 6960, 6961, 5, 900,
|
|
0, 0, 6961, 6962, 5, 1133, 0, 0, 6962, 6963, 7, 120, 0, 0, 6963, 6964,
|
|
5, 1135, 0, 0, 6964, 6965, 3, 594, 297, 0, 6965, 6966, 5, 1134, 0, 0, 6966,
|
|
6985, 1, 0, 0, 0, 6967, 6968, 5, 282, 0, 0, 6968, 6969, 5, 1133, 0, 0,
|
|
6969, 6970, 3, 688, 344, 0, 6970, 6971, 5, 1135, 0, 0, 6971, 6974, 3, 688,
|
|
344, 0, 6972, 6973, 5, 593, 0, 0, 6973, 6975, 3, 608, 304, 0, 6974, 6972,
|
|
1, 0, 0, 0, 6974, 6975, 1, 0, 0, 0, 6975, 6977, 1, 0, 0, 0, 6976, 6978,
|
|
3, 268, 134, 0, 6977, 6976, 1, 0, 0, 0, 6977, 6978, 1, 0, 0, 0, 6978, 6980,
|
|
1, 0, 0, 0, 6979, 6981, 3, 270, 135, 0, 6980, 6979, 1, 0, 0, 0, 6980, 6981,
|
|
1, 0, 0, 0, 6981, 6982, 1, 0, 0, 0, 6982, 6983, 5, 1134, 0, 0, 6983, 6985,
|
|
1, 0, 0, 0, 6984, 6805, 1, 0, 0, 0, 6984, 6810, 1, 0, 0, 0, 6984, 6811,
|
|
1, 0, 0, 0, 6984, 6818, 1, 0, 0, 0, 6984, 6825, 1, 0, 0, 0, 6984, 6832,
|
|
1, 0, 0, 0, 6984, 6837, 1, 0, 0, 0, 6984, 6850, 1, 0, 0, 0, 6984, 6862,
|
|
1, 0, 0, 0, 6984, 6871, 1, 0, 0, 0, 6984, 6884, 1, 0, 0, 0, 6984, 6904,
|
|
1, 0, 0, 0, 6984, 6918, 1, 0, 0, 0, 6984, 6931, 1, 0, 0, 0, 6984, 6950,
|
|
1, 0, 0, 0, 6984, 6960, 1, 0, 0, 0, 6984, 6967, 1, 0, 0, 0, 6985, 651,
|
|
1, 0, 0, 0, 6986, 6987, 5, 189, 0, 0, 6987, 6988, 3, 686, 343, 0, 6988,
|
|
6989, 5, 174, 0, 0, 6989, 6990, 3, 686, 343, 0, 6990, 653, 1, 0, 0, 0,
|
|
6991, 6992, 5, 472, 0, 0, 6992, 6997, 3, 656, 328, 0, 6993, 6994, 5, 1135,
|
|
0, 0, 6994, 6996, 3, 656, 328, 0, 6995, 6993, 1, 0, 0, 0, 6996, 6999, 1,
|
|
0, 0, 0, 6997, 6995, 1, 0, 0, 0, 6997, 6998, 1, 0, 0, 0, 6998, 7006, 1,
|
|
0, 0, 0, 6999, 6997, 1, 0, 0, 0, 7000, 7001, 5, 472, 0, 0, 7001, 7002,
|
|
3, 590, 295, 0, 7002, 7003, 5, 1121, 0, 0, 7003, 7004, 3, 590, 295, 0,
|
|
7004, 7006, 1, 0, 0, 0, 7005, 6991, 1, 0, 0, 0, 7005, 7000, 1, 0, 0, 0,
|
|
7006, 655, 1, 0, 0, 0, 7007, 7009, 3, 590, 295, 0, 7008, 7010, 7, 121,
|
|
0, 0, 7009, 7008, 1, 0, 0, 0, 7009, 7010, 1, 0, 0, 0, 7010, 657, 1, 0,
|
|
0, 0, 7011, 7012, 7, 122, 0, 0, 7012, 7014, 5, 1133, 0, 0, 7013, 7015,
|
|
7, 44, 0, 0, 7014, 7013, 1, 0, 0, 0, 7014, 7015, 1, 0, 0, 0, 7015, 7016,
|
|
1, 0, 0, 0, 7016, 7017, 3, 686, 343, 0, 7017, 7019, 5, 1134, 0, 0, 7018,
|
|
7020, 3, 662, 331, 0, 7019, 7018, 1, 0, 0, 0, 7019, 7020, 1, 0, 0, 0, 7020,
|
|
7071, 1, 0, 0, 0, 7021, 7022, 5, 290, 0, 0, 7022, 7030, 5, 1133, 0, 0,
|
|
7023, 7031, 5, 1117, 0, 0, 7024, 7026, 5, 6, 0, 0, 7025, 7024, 1, 0, 0,
|
|
0, 7025, 7026, 1, 0, 0, 0, 7026, 7027, 1, 0, 0, 0, 7027, 7031, 3, 686,
|
|
343, 0, 7028, 7029, 5, 49, 0, 0, 7029, 7031, 3, 684, 342, 0, 7030, 7023,
|
|
1, 0, 0, 0, 7030, 7025, 1, 0, 0, 0, 7030, 7028, 1, 0, 0, 0, 7031, 7032,
|
|
1, 0, 0, 0, 7032, 7034, 5, 1134, 0, 0, 7033, 7035, 3, 662, 331, 0, 7034,
|
|
7033, 1, 0, 0, 0, 7034, 7035, 1, 0, 0, 0, 7035, 7071, 1, 0, 0, 0, 7036,
|
|
7037, 7, 123, 0, 0, 7037, 7039, 5, 1133, 0, 0, 7038, 7040, 5, 6, 0, 0,
|
|
7039, 7038, 1, 0, 0, 0, 7039, 7040, 1, 0, 0, 0, 7040, 7041, 1, 0, 0, 0,
|
|
7041, 7042, 3, 686, 343, 0, 7042, 7044, 5, 1134, 0, 0, 7043, 7045, 3, 662,
|
|
331, 0, 7044, 7043, 1, 0, 0, 0, 7044, 7045, 1, 0, 0, 0, 7045, 7071, 1,
|
|
0, 0, 0, 7046, 7047, 5, 294, 0, 0, 7047, 7049, 5, 1133, 0, 0, 7048, 7050,
|
|
5, 49, 0, 0, 7049, 7048, 1, 0, 0, 0, 7049, 7050, 1, 0, 0, 0, 7050, 7051,
|
|
1, 0, 0, 0, 7051, 7062, 3, 684, 342, 0, 7052, 7053, 5, 124, 0, 0, 7053,
|
|
7054, 5, 19, 0, 0, 7054, 7059, 3, 232, 116, 0, 7055, 7056, 5, 1135, 0,
|
|
0, 7056, 7058, 3, 232, 116, 0, 7057, 7055, 1, 0, 0, 0, 7058, 7061, 1, 0,
|
|
0, 0, 7059, 7057, 1, 0, 0, 0, 7059, 7060, 1, 0, 0, 0, 7060, 7063, 1, 0,
|
|
0, 0, 7061, 7059, 1, 0, 0, 0, 7062, 7052, 1, 0, 0, 0, 7062, 7063, 1, 0,
|
|
0, 0, 7063, 7066, 1, 0, 0, 0, 7064, 7065, 5, 154, 0, 0, 7065, 7067, 5,
|
|
1148, 0, 0, 7066, 7064, 1, 0, 0, 0, 7066, 7067, 1, 0, 0, 0, 7067, 7068,
|
|
1, 0, 0, 0, 7068, 7069, 5, 1134, 0, 0, 7069, 7071, 1, 0, 0, 0, 7070, 7011,
|
|
1, 0, 0, 0, 7070, 7021, 1, 0, 0, 0, 7070, 7036, 1, 0, 0, 0, 7070, 7046,
|
|
1, 0, 0, 0, 7071, 659, 1, 0, 0, 0, 7072, 7073, 7, 124, 0, 0, 7073, 7074,
|
|
5, 1133, 0, 0, 7074, 7077, 3, 688, 344, 0, 7075, 7076, 5, 1135, 0, 0, 7076,
|
|
7078, 3, 590, 295, 0, 7077, 7075, 1, 0, 0, 0, 7077, 7078, 1, 0, 0, 0, 7078,
|
|
7081, 1, 0, 0, 0, 7079, 7080, 5, 1135, 0, 0, 7080, 7082, 3, 590, 295, 0,
|
|
7081, 7079, 1, 0, 0, 0, 7081, 7082, 1, 0, 0, 0, 7082, 7083, 1, 0, 0, 0,
|
|
7083, 7084, 5, 1134, 0, 0, 7084, 7085, 3, 662, 331, 0, 7085, 7111, 1, 0,
|
|
0, 0, 7086, 7087, 7, 125, 0, 0, 7087, 7088, 5, 1133, 0, 0, 7088, 7089,
|
|
3, 688, 344, 0, 7089, 7090, 5, 1134, 0, 0, 7090, 7091, 3, 662, 331, 0,
|
|
7091, 7111, 1, 0, 0, 0, 7092, 7093, 7, 126, 0, 0, 7093, 7094, 5, 1133,
|
|
0, 0, 7094, 7095, 5, 1134, 0, 0, 7095, 7111, 3, 662, 331, 0, 7096, 7097,
|
|
5, 301, 0, 0, 7097, 7098, 5, 1133, 0, 0, 7098, 7099, 3, 688, 344, 0, 7099,
|
|
7100, 5, 1135, 0, 0, 7100, 7101, 3, 590, 295, 0, 7101, 7102, 5, 1134, 0,
|
|
0, 7102, 7103, 3, 662, 331, 0, 7103, 7111, 1, 0, 0, 0, 7104, 7105, 5, 300,
|
|
0, 0, 7105, 7106, 5, 1133, 0, 0, 7106, 7107, 3, 590, 295, 0, 7107, 7108,
|
|
5, 1134, 0, 0, 7108, 7109, 3, 662, 331, 0, 7109, 7111, 1, 0, 0, 0, 7110,
|
|
7072, 1, 0, 0, 0, 7110, 7086, 1, 0, 0, 0, 7110, 7092, 1, 0, 0, 0, 7110,
|
|
7096, 1, 0, 0, 0, 7110, 7104, 1, 0, 0, 0, 7111, 661, 1, 0, 0, 0, 7112,
|
|
7118, 5, 128, 0, 0, 7113, 7114, 5, 1133, 0, 0, 7114, 7115, 3, 664, 332,
|
|
0, 7115, 7116, 5, 1134, 0, 0, 7116, 7119, 1, 0, 0, 0, 7117, 7119, 3, 666,
|
|
333, 0, 7118, 7113, 1, 0, 0, 0, 7118, 7117, 1, 0, 0, 0, 7119, 663, 1, 0,
|
|
0, 0, 7120, 7122, 3, 666, 333, 0, 7121, 7120, 1, 0, 0, 0, 7121, 7122, 1,
|
|
0, 0, 0, 7122, 7124, 1, 0, 0, 0, 7123, 7125, 3, 678, 339, 0, 7124, 7123,
|
|
1, 0, 0, 0, 7124, 7125, 1, 0, 0, 0, 7125, 7127, 1, 0, 0, 0, 7126, 7128,
|
|
3, 230, 115, 0, 7127, 7126, 1, 0, 0, 0, 7127, 7128, 1, 0, 0, 0, 7128, 7130,
|
|
1, 0, 0, 0, 7129, 7131, 3, 668, 334, 0, 7130, 7129, 1, 0, 0, 0, 7130, 7131,
|
|
1, 0, 0, 0, 7131, 665, 1, 0, 0, 0, 7132, 7133, 3, 584, 292, 0, 7133, 667,
|
|
1, 0, 0, 0, 7134, 7135, 3, 670, 335, 0, 7135, 7136, 3, 672, 336, 0, 7136,
|
|
669, 1, 0, 0, 0, 7137, 7138, 7, 127, 0, 0, 7138, 671, 1, 0, 0, 0, 7139,
|
|
7142, 3, 676, 338, 0, 7140, 7142, 3, 674, 337, 0, 7141, 7139, 1, 0, 0,
|
|
0, 7141, 7140, 1, 0, 0, 0, 7142, 673, 1, 0, 0, 0, 7143, 7144, 5, 16, 0,
|
|
0, 7144, 7145, 3, 676, 338, 0, 7145, 7146, 5, 10, 0, 0, 7146, 7147, 3,
|
|
676, 338, 0, 7147, 675, 1, 0, 0, 0, 7148, 7149, 5, 35, 0, 0, 7149, 7156,
|
|
5, 600, 0, 0, 7150, 7151, 5, 657, 0, 0, 7151, 7156, 7, 128, 0, 0, 7152,
|
|
7153, 3, 688, 344, 0, 7153, 7154, 7, 128, 0, 0, 7154, 7156, 1, 0, 0, 0,
|
|
7155, 7148, 1, 0, 0, 0, 7155, 7150, 1, 0, 0, 0, 7155, 7152, 1, 0, 0, 0,
|
|
7156, 677, 1, 0, 0, 0, 7157, 7158, 5, 129, 0, 0, 7158, 7159, 5, 19, 0,
|
|
0, 7159, 7164, 3, 688, 344, 0, 7160, 7161, 5, 1135, 0, 0, 7161, 7163, 3,
|
|
688, 344, 0, 7162, 7160, 1, 0, 0, 0, 7163, 7166, 1, 0, 0, 0, 7164, 7162,
|
|
1, 0, 0, 0, 7164, 7165, 1, 0, 0, 0, 7165, 679, 1, 0, 0, 0, 7166, 7164,
|
|
1, 0, 0, 0, 7167, 7192, 3, 720, 360, 0, 7168, 7192, 5, 747, 0, 0, 7169,
|
|
7192, 5, 317, 0, 0, 7170, 7192, 5, 313, 0, 0, 7171, 7192, 5, 314, 0, 0,
|
|
7172, 7192, 5, 315, 0, 0, 7173, 7192, 5, 318, 0, 0, 7174, 7192, 5, 319,
|
|
0, 0, 7175, 7192, 5, 320, 0, 0, 7176, 7192, 5, 77, 0, 0, 7177, 7192, 5,
|
|
85, 0, 0, 7178, 7192, 5, 316, 0, 0, 7179, 7192, 5, 322, 0, 0, 7180, 7192,
|
|
5, 508, 0, 0, 7181, 7192, 5, 323, 0, 0, 7182, 7192, 5, 140, 0, 0, 7183,
|
|
7192, 5, 141, 0, 0, 7184, 7192, 5, 325, 0, 0, 7185, 7192, 5, 326, 0, 0,
|
|
7186, 7192, 5, 327, 0, 0, 7187, 7192, 5, 328, 0, 0, 7188, 7192, 5, 329,
|
|
0, 0, 7189, 7192, 5, 330, 0, 0, 7190, 7192, 5, 331, 0, 0, 7191, 7167, 1,
|
|
0, 0, 0, 7191, 7168, 1, 0, 0, 0, 7191, 7169, 1, 0, 0, 0, 7191, 7170, 1,
|
|
0, 0, 0, 7191, 7171, 1, 0, 0, 0, 7191, 7172, 1, 0, 0, 0, 7191, 7173, 1,
|
|
0, 0, 0, 7191, 7174, 1, 0, 0, 0, 7191, 7175, 1, 0, 0, 0, 7191, 7176, 1,
|
|
0, 0, 0, 7191, 7177, 1, 0, 0, 0, 7191, 7178, 1, 0, 0, 0, 7191, 7179, 1,
|
|
0, 0, 0, 7191, 7180, 1, 0, 0, 0, 7191, 7181, 1, 0, 0, 0, 7191, 7182, 1,
|
|
0, 0, 0, 7191, 7183, 1, 0, 0, 0, 7191, 7184, 1, 0, 0, 0, 7191, 7185, 1,
|
|
0, 0, 0, 7191, 7186, 1, 0, 0, 0, 7191, 7187, 1, 0, 0, 0, 7191, 7188, 1,
|
|
0, 0, 0, 7191, 7189, 1, 0, 0, 0, 7191, 7190, 1, 0, 0, 0, 7192, 681, 1,
|
|
0, 0, 0, 7193, 7194, 7, 129, 0, 0, 7194, 7195, 5, 1133, 0, 0, 7195, 7196,
|
|
3, 686, 343, 0, 7196, 7197, 5, 1134, 0, 0, 7197, 683, 1, 0, 0, 0, 7198,
|
|
7203, 3, 602, 301, 0, 7199, 7203, 3, 556, 278, 0, 7200, 7203, 3, 648, 324,
|
|
0, 7201, 7203, 3, 688, 344, 0, 7202, 7198, 1, 0, 0, 0, 7202, 7199, 1, 0,
|
|
0, 0, 7202, 7200, 1, 0, 0, 0, 7202, 7201, 1, 0, 0, 0, 7203, 7213, 1, 0,
|
|
0, 0, 7204, 7209, 5, 1135, 0, 0, 7205, 7210, 3, 602, 301, 0, 7206, 7210,
|
|
3, 556, 278, 0, 7207, 7210, 3, 648, 324, 0, 7208, 7210, 3, 688, 344, 0,
|
|
7209, 7205, 1, 0, 0, 0, 7209, 7206, 1, 0, 0, 0, 7209, 7207, 1, 0, 0, 0,
|
|
7209, 7208, 1, 0, 0, 0, 7210, 7212, 1, 0, 0, 0, 7211, 7204, 1, 0, 0, 0,
|
|
7212, 7215, 1, 0, 0, 0, 7213, 7211, 1, 0, 0, 0, 7213, 7214, 1, 0, 0, 0,
|
|
7214, 685, 1, 0, 0, 0, 7215, 7213, 1, 0, 0, 0, 7216, 7221, 3, 602, 301,
|
|
0, 7217, 7221, 3, 556, 278, 0, 7218, 7221, 3, 648, 324, 0, 7219, 7221,
|
|
3, 688, 344, 0, 7220, 7216, 1, 0, 0, 0, 7220, 7217, 1, 0, 0, 0, 7220, 7218,
|
|
1, 0, 0, 0, 7220, 7219, 1, 0, 0, 0, 7221, 687, 1, 0, 0, 0, 7222, 7223,
|
|
6, 344, -1, 0, 7223, 7224, 7, 130, 0, 0, 7224, 7234, 3, 688, 344, 4, 7225,
|
|
7226, 3, 690, 345, 0, 7226, 7228, 5, 88, 0, 0, 7227, 7229, 5, 114, 0, 0,
|
|
7228, 7227, 1, 0, 0, 0, 7228, 7229, 1, 0, 0, 0, 7229, 7230, 1, 0, 0, 0,
|
|
7230, 7231, 7, 131, 0, 0, 7231, 7234, 1, 0, 0, 0, 7232, 7234, 3, 690, 345,
|
|
0, 7233, 7222, 1, 0, 0, 0, 7233, 7225, 1, 0, 0, 0, 7233, 7232, 1, 0, 0,
|
|
0, 7234, 7241, 1, 0, 0, 0, 7235, 7236, 10, 3, 0, 0, 7236, 7237, 3, 698,
|
|
349, 0, 7237, 7238, 3, 688, 344, 4, 7238, 7240, 1, 0, 0, 0, 7239, 7235,
|
|
1, 0, 0, 0, 7240, 7243, 1, 0, 0, 0, 7241, 7239, 1, 0, 0, 0, 7241, 7242,
|
|
1, 0, 0, 0, 7242, 689, 1, 0, 0, 0, 7243, 7241, 1, 0, 0, 0, 7244, 7245,
|
|
6, 345, -1, 0, 7245, 7246, 3, 692, 346, 0, 7246, 7311, 1, 0, 0, 0, 7247,
|
|
7248, 10, 8, 0, 0, 7248, 7249, 3, 696, 348, 0, 7249, 7250, 3, 690, 345,
|
|
9, 7250, 7310, 1, 0, 0, 0, 7251, 7253, 10, 6, 0, 0, 7252, 7254, 5, 114,
|
|
0, 0, 7253, 7252, 1, 0, 0, 0, 7253, 7254, 1, 0, 0, 0, 7254, 7255, 1, 0,
|
|
0, 0, 7255, 7256, 5, 16, 0, 0, 7256, 7257, 3, 690, 345, 0, 7257, 7258,
|
|
5, 10, 0, 0, 7258, 7259, 3, 690, 345, 7, 7259, 7310, 1, 0, 0, 0, 7260,
|
|
7261, 10, 5, 0, 0, 7261, 7262, 5, 620, 0, 0, 7262, 7263, 5, 98, 0, 0, 7263,
|
|
7310, 3, 690, 345, 6, 7264, 7266, 10, 3, 0, 0, 7265, 7267, 5, 114, 0, 0,
|
|
7266, 7265, 1, 0, 0, 0, 7266, 7267, 1, 0, 0, 0, 7267, 7268, 1, 0, 0, 0,
|
|
7268, 7269, 7, 132, 0, 0, 7269, 7310, 3, 690, 345, 4, 7270, 7272, 10, 10,
|
|
0, 0, 7271, 7273, 5, 114, 0, 0, 7272, 7271, 1, 0, 0, 0, 7272, 7273, 1,
|
|
0, 0, 0, 7273, 7274, 1, 0, 0, 0, 7274, 7275, 5, 80, 0, 0, 7275, 7278, 5,
|
|
1133, 0, 0, 7276, 7279, 3, 200, 100, 0, 7277, 7279, 3, 624, 312, 0, 7278,
|
|
7276, 1, 0, 0, 0, 7278, 7277, 1, 0, 0, 0, 7279, 7280, 1, 0, 0, 0, 7280,
|
|
7281, 5, 1134, 0, 0, 7281, 7310, 1, 0, 0, 0, 7282, 7283, 10, 9, 0, 0, 7283,
|
|
7284, 5, 88, 0, 0, 7284, 7310, 3, 600, 300, 0, 7285, 7286, 10, 7, 0, 0,
|
|
7286, 7287, 3, 696, 348, 0, 7287, 7288, 7, 133, 0, 0, 7288, 7289, 5, 1133,
|
|
0, 0, 7289, 7290, 3, 200, 100, 0, 7290, 7291, 5, 1134, 0, 0, 7291, 7310,
|
|
1, 0, 0, 0, 7292, 7294, 10, 4, 0, 0, 7293, 7295, 5, 114, 0, 0, 7294, 7293,
|
|
1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7296, 1, 0, 0, 0, 7296, 7297,
|
|
5, 98, 0, 0, 7297, 7300, 3, 690, 345, 0, 7298, 7299, 5, 413, 0, 0, 7299,
|
|
7301, 5, 1148, 0, 0, 7300, 7298, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301,
|
|
7310, 1, 0, 0, 0, 7302, 7303, 10, 2, 0, 0, 7303, 7304, 5, 505, 0, 0, 7304,
|
|
7305, 5, 533, 0, 0, 7305, 7306, 5, 1133, 0, 0, 7306, 7307, 3, 690, 345,
|
|
0, 7307, 7308, 5, 1134, 0, 0, 7308, 7310, 1, 0, 0, 0, 7309, 7247, 1, 0,
|
|
0, 0, 7309, 7251, 1, 0, 0, 0, 7309, 7260, 1, 0, 0, 0, 7309, 7264, 1, 0,
|
|
0, 0, 7309, 7270, 1, 0, 0, 0, 7309, 7282, 1, 0, 0, 0, 7309, 7285, 1, 0,
|
|
0, 0, 7309, 7292, 1, 0, 0, 0, 7309, 7302, 1, 0, 0, 0, 7310, 7313, 1, 0,
|
|
0, 0, 7311, 7309, 1, 0, 0, 0, 7311, 7312, 1, 0, 0, 0, 7312, 691, 1, 0,
|
|
0, 0, 7313, 7311, 1, 0, 0, 0, 7314, 7315, 6, 346, -1, 0, 7315, 7363, 3,
|
|
602, 301, 0, 7316, 7363, 3, 556, 278, 0, 7317, 7363, 3, 648, 324, 0, 7318,
|
|
7363, 3, 566, 283, 0, 7319, 7320, 3, 694, 347, 0, 7320, 7321, 3, 692, 346,
|
|
12, 7321, 7363, 1, 0, 0, 0, 7322, 7323, 5, 226, 0, 0, 7323, 7363, 3, 692,
|
|
346, 11, 7324, 7325, 5, 1159, 0, 0, 7325, 7326, 5, 1108, 0, 0, 7326, 7363,
|
|
3, 692, 346, 10, 7327, 7328, 5, 1133, 0, 0, 7328, 7333, 3, 688, 344, 0,
|
|
7329, 7330, 5, 1135, 0, 0, 7330, 7332, 3, 688, 344, 0, 7331, 7329, 1, 0,
|
|
0, 0, 7332, 7335, 1, 0, 0, 0, 7333, 7331, 1, 0, 0, 0, 7333, 7334, 1, 0,
|
|
0, 0, 7334, 7336, 1, 0, 0, 0, 7335, 7333, 1, 0, 0, 0, 7336, 7337, 5, 1134,
|
|
0, 0, 7337, 7363, 1, 0, 0, 0, 7338, 7339, 5, 600, 0, 0, 7339, 7340, 5,
|
|
1133, 0, 0, 7340, 7343, 3, 688, 344, 0, 7341, 7342, 5, 1135, 0, 0, 7342,
|
|
7344, 3, 688, 344, 0, 7343, 7341, 1, 0, 0, 0, 7344, 7345, 1, 0, 0, 0, 7345,
|
|
7343, 1, 0, 0, 0, 7345, 7346, 1, 0, 0, 0, 7346, 7347, 1, 0, 0, 0, 7347,
|
|
7348, 5, 1134, 0, 0, 7348, 7363, 1, 0, 0, 0, 7349, 7350, 5, 60, 0, 0, 7350,
|
|
7351, 5, 1133, 0, 0, 7351, 7352, 3, 200, 100, 0, 7352, 7353, 5, 1134, 0,
|
|
0, 7353, 7363, 1, 0, 0, 0, 7354, 7355, 5, 1133, 0, 0, 7355, 7356, 3, 200,
|
|
100, 0, 7356, 7357, 5, 1134, 0, 0, 7357, 7363, 1, 0, 0, 0, 7358, 7359,
|
|
5, 86, 0, 0, 7359, 7360, 3, 688, 344, 0, 7360, 7361, 3, 72, 36, 0, 7361,
|
|
7363, 1, 0, 0, 0, 7362, 7314, 1, 0, 0, 0, 7362, 7316, 1, 0, 0, 0, 7362,
|
|
7317, 1, 0, 0, 0, 7362, 7318, 1, 0, 0, 0, 7362, 7319, 1, 0, 0, 0, 7362,
|
|
7322, 1, 0, 0, 0, 7362, 7324, 1, 0, 0, 0, 7362, 7327, 1, 0, 0, 0, 7362,
|
|
7338, 1, 0, 0, 0, 7362, 7349, 1, 0, 0, 0, 7362, 7354, 1, 0, 0, 0, 7362,
|
|
7358, 1, 0, 0, 0, 7363, 7385, 1, 0, 0, 0, 7364, 7365, 10, 4, 0, 0, 7365,
|
|
7366, 3, 700, 350, 0, 7366, 7367, 3, 692, 346, 5, 7367, 7384, 1, 0, 0,
|
|
0, 7368, 7369, 10, 3, 0, 0, 7369, 7370, 3, 702, 351, 0, 7370, 7371, 3,
|
|
692, 346, 4, 7371, 7384, 1, 0, 0, 0, 7372, 7373, 10, 2, 0, 0, 7373, 7374,
|
|
3, 704, 352, 0, 7374, 7375, 3, 692, 346, 3, 7375, 7384, 1, 0, 0, 0, 7376,
|
|
7377, 10, 1, 0, 0, 7377, 7378, 3, 706, 353, 0, 7378, 7379, 3, 692, 346,
|
|
2, 7379, 7384, 1, 0, 0, 0, 7380, 7381, 10, 14, 0, 0, 7381, 7382, 5, 27,
|
|
0, 0, 7382, 7384, 3, 570, 285, 0, 7383, 7364, 1, 0, 0, 0, 7383, 7368, 1,
|
|
0, 0, 0, 7383, 7372, 1, 0, 0, 0, 7383, 7376, 1, 0, 0, 0, 7383, 7380, 1,
|
|
0, 0, 0, 7384, 7387, 1, 0, 0, 0, 7385, 7383, 1, 0, 0, 0, 7385, 7386, 1,
|
|
0, 0, 0, 7386, 693, 1, 0, 0, 0, 7387, 7385, 1, 0, 0, 0, 7388, 7389, 7,
|
|
134, 0, 0, 7389, 695, 1, 0, 0, 0, 7390, 7405, 5, 1124, 0, 0, 7391, 7405,
|
|
5, 1125, 0, 0, 7392, 7405, 5, 1126, 0, 0, 7393, 7394, 5, 1126, 0, 0, 7394,
|
|
7405, 5, 1124, 0, 0, 7395, 7396, 5, 1125, 0, 0, 7396, 7405, 5, 1124, 0,
|
|
0, 7397, 7398, 5, 1126, 0, 0, 7398, 7405, 5, 1125, 0, 0, 7399, 7400, 5,
|
|
1127, 0, 0, 7400, 7405, 5, 1124, 0, 0, 7401, 7402, 5, 1126, 0, 0, 7402,
|
|
7403, 5, 1124, 0, 0, 7403, 7405, 5, 1125, 0, 0, 7404, 7390, 1, 0, 0, 0,
|
|
7404, 7391, 1, 0, 0, 0, 7404, 7392, 1, 0, 0, 0, 7404, 7393, 1, 0, 0, 0,
|
|
7404, 7395, 1, 0, 0, 0, 7404, 7397, 1, 0, 0, 0, 7404, 7399, 1, 0, 0, 0,
|
|
7404, 7401, 1, 0, 0, 0, 7405, 697, 1, 0, 0, 0, 7406, 7414, 5, 10, 0, 0,
|
|
7407, 7408, 5, 1130, 0, 0, 7408, 7414, 5, 1130, 0, 0, 7409, 7414, 5, 194,
|
|
0, 0, 7410, 7414, 5, 123, 0, 0, 7411, 7412, 5, 1129, 0, 0, 7412, 7414,
|
|
5, 1129, 0, 0, 7413, 7406, 1, 0, 0, 0, 7413, 7407, 1, 0, 0, 0, 7413, 7409,
|
|
1, 0, 0, 0, 7413, 7410, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7414, 699,
|
|
1, 0, 0, 0, 7415, 7416, 5, 1126, 0, 0, 7416, 7423, 5, 1126, 0, 0, 7417,
|
|
7418, 5, 1125, 0, 0, 7418, 7423, 5, 1125, 0, 0, 7419, 7423, 5, 1130, 0,
|
|
0, 7420, 7423, 5, 1131, 0, 0, 7421, 7423, 5, 1129, 0, 0, 7422, 7415, 1,
|
|
0, 0, 0, 7422, 7417, 1, 0, 0, 0, 7422, 7419, 1, 0, 0, 0, 7422, 7420, 1,
|
|
0, 0, 0, 7422, 7421, 1, 0, 0, 0, 7423, 701, 1, 0, 0, 0, 7424, 7425, 7,
|
|
135, 0, 0, 7425, 703, 1, 0, 0, 0, 7426, 7427, 7, 136, 0, 0, 7427, 705,
|
|
1, 0, 0, 0, 7428, 7429, 5, 1121, 0, 0, 7429, 7434, 5, 1125, 0, 0, 7430,
|
|
7431, 5, 1121, 0, 0, 7431, 7432, 5, 1125, 0, 0, 7432, 7434, 5, 1125, 0,
|
|
0, 7433, 7428, 1, 0, 0, 0, 7433, 7430, 1, 0, 0, 0, 7434, 707, 1, 0, 0,
|
|
0, 7435, 7436, 7, 137, 0, 0, 7436, 709, 1, 0, 0, 0, 7437, 7438, 7, 138,
|
|
0, 0, 7438, 711, 1, 0, 0, 0, 7439, 7440, 7, 139, 0, 0, 7440, 713, 1, 0,
|
|
0, 0, 7441, 7442, 7, 140, 0, 0, 7442, 715, 1, 0, 0, 0, 7443, 7444, 7, 141,
|
|
0, 0, 7444, 717, 1, 0, 0, 0, 7445, 7446, 7, 142, 0, 0, 7446, 719, 1, 0,
|
|
0, 0, 7447, 7448, 7, 143, 0, 0, 7448, 721, 1, 0, 0, 0, 1087, 723, 727,
|
|
734, 737, 740, 742, 748, 751, 754, 763, 805, 820, 831, 848, 853, 868, 895,
|
|
904, 909, 915, 920, 924, 933, 936, 939, 943, 950, 953, 958, 966, 971, 976,
|
|
979, 981, 993, 996, 1000, 1003, 1007, 1010, 1014, 1017, 1020, 1024, 1027,
|
|
1031, 1037, 1043, 1049, 1056, 1063, 1066, 1070, 1075, 1081, 1090, 1095,
|
|
1100, 1107, 1124, 1131, 1135, 1145, 1149, 1153, 1157, 1161, 1166, 1169,
|
|
1172, 1175, 1178, 1184, 1188, 1194, 1199, 1202, 1205, 1207, 1218, 1222,
|
|
1225, 1239, 1242, 1246, 1249, 1253, 1256, 1260, 1263, 1267, 1270, 1273,
|
|
1277, 1280, 1284, 1290, 1294, 1306, 1312, 1323, 1328, 1336, 1344, 1349,
|
|
1352, 1357, 1365, 1370, 1376, 1381, 1385, 1387, 1390, 1394, 1398, 1401,
|
|
1405, 1409, 1413, 1419, 1422, 1429, 1434, 1440, 1447, 1453, 1461, 1464,
|
|
1471, 1474, 1476, 1482, 1488, 1505, 1512, 1519, 1531, 1536, 1539, 1542,
|
|
1555, 1568, 1573, 1589, 1597, 1607, 1610, 1613, 1619, 1623, 1626, 1637,
|
|
1640, 1645, 1658, 1665, 1672, 1674, 1681, 1685, 1687, 1692, 1695, 1701,
|
|
1706, 1708, 1712, 1715, 1718, 1724, 1729, 1731, 1736, 1743, 1745, 1752,
|
|
1757, 1761, 1764, 1772, 1780, 1782, 1792, 1796, 1799, 1805, 1810, 1813,
|
|
1819, 1822, 1826, 1829, 1833, 1838, 1843, 1848, 1852, 1856, 1860, 1864,
|
|
1868, 1872, 1877, 1882, 1887, 1893, 1898, 1903, 1908, 1913, 1918, 1924,
|
|
1929, 1934, 1939, 1944, 1949, 1954, 1959, 1966, 1971, 1976, 1981, 1985,
|
|
1990, 1998, 2003, 2009, 2021, 2028, 2030, 2038, 2043, 2046, 2054, 2060,
|
|
2064, 2077, 2089, 2091, 2094, 2102, 2108, 2114, 2127, 2134, 2143, 2148,
|
|
2159, 2168, 2173, 2185, 2192, 2201, 2206, 2218, 2225, 2234, 2239, 2246,
|
|
2255, 2260, 2262, 2267, 2275, 2284, 2288, 2291, 2295, 2300, 2306, 2312,
|
|
2317, 2322, 2327, 2332, 2335, 2340, 2345, 2355, 2359, 2366, 2371, 2374,
|
|
2379, 2382, 2386, 2390, 2398, 2417, 2420, 2423, 2427, 2437, 2450, 2457,
|
|
2460, 2465, 2472, 2475, 2478, 2489, 2492, 2496, 2504, 2507, 2512, 2520,
|
|
2526, 2530, 2534, 2539, 2544, 2551, 2555, 2566, 2574, 2577, 2583, 2589,
|
|
2591, 2596, 2599, 2605, 2611, 2613, 2617, 2620, 2623, 2629, 2635, 2638,
|
|
2644, 2650, 2652, 2657, 2665, 2667, 2676, 2679, 2682, 2687, 2689, 2698,
|
|
2701, 2704, 2709, 2711, 2720, 2725, 2733, 2737, 2745, 2755, 2760, 2767,
|
|
2771, 2775, 2794, 2804, 2810, 2827, 2831, 2841, 2846, 2849, 2858, 2869,
|
|
2877, 2883, 2893, 2905, 2912, 2919, 2934, 2947, 2953, 2959, 2965, 2971,
|
|
2977, 2983, 2988, 2995, 3002, 3009, 3014, 3017, 3019, 3033, 3040, 3047,
|
|
3053, 3057, 3061, 3068, 3071, 3076, 3083, 3090, 3094, 3099, 3106, 3119,
|
|
3122, 3127, 3132, 3136, 3142, 3151, 3160, 3169, 3172, 3176, 3185, 3189,
|
|
3192, 3195, 3201, 3204, 3208, 3211, 3215, 3218, 3226, 3229, 3240, 3243,
|
|
3248, 3251, 3256, 3266, 3271, 3277, 3279, 3285, 3287, 3293, 3301, 3306,
|
|
3314, 3317, 3322, 3325, 3330, 3338, 3346, 3352, 3360, 3365, 3373, 3376,
|
|
3380, 3383, 3391, 3397, 3406, 3409, 3413, 3417, 3421, 3426, 3430, 3434,
|
|
3436, 3439, 3442, 3445, 3451, 3455, 3458, 3461, 3464, 3467, 3474, 3476,
|
|
3480, 3485, 3491, 3496, 3503, 3509, 3514, 3517, 3523, 3527, 3535, 3539,
|
|
3542, 3545, 3550, 3553, 3560, 3564, 3567, 3571, 3575, 3578, 3581, 3586,
|
|
3592, 3596, 3606, 3612, 3616, 3622, 3626, 3632, 3635, 3647, 3651, 3655,
|
|
3663, 3667, 3675, 3678, 3682, 3685, 3693, 3698, 3701, 3704, 3708, 3711,
|
|
3720, 3725, 3734, 3739, 3746, 3753, 3761, 3767, 3775, 3778, 3781, 3788,
|
|
3791, 3798, 3801, 3809, 3815, 3826, 3829, 3833, 3839, 3848, 3853, 3857,
|
|
3863, 3869, 3871, 3875, 3884, 3894, 3904, 3910, 3915, 3919, 3922, 3925,
|
|
3928, 3931, 3937, 3943, 3946, 3949, 3952, 3955, 3958, 3960, 3966, 3972,
|
|
3975, 3978, 3981, 3984, 3987, 3991, 3997, 4001, 4009, 4013, 4016, 4018,
|
|
4031, 4034, 4041, 4051, 4054, 4059, 4061, 4065, 4073, 4079, 4088, 4101,
|
|
4105, 4111, 4120, 4123, 4127, 4130, 4134, 4138, 4141, 4143, 4151, 4163,
|
|
4169, 4171, 4177, 4179, 4181, 4187, 4195, 4203, 4207, 4211, 4220, 4225,
|
|
4245, 4250, 4256, 4263, 4268, 4277, 4280, 4284, 4288, 4292, 4295, 4298,
|
|
4301, 4305, 4309, 4312, 4315, 4318, 4325, 4329, 4344, 4348, 4360, 4368,
|
|
4378, 4382, 4385, 4391, 4394, 4397, 4406, 4415, 4425, 4429, 4439, 4449,
|
|
4457, 4460, 4469, 4472, 4476, 4481, 4485, 4494, 4497, 4528, 4531, 4534,
|
|
4590, 4595, 4623, 4637, 4644, 4648, 4654, 4662, 4664, 4675, 4685, 4692,
|
|
4698, 4706, 4711, 4719, 4727, 4735, 4743, 4749, 4754, 4759, 4764, 4770,
|
|
4772, 4783, 4788, 4795, 4797, 4811, 4817, 4822, 4827, 4833, 4840, 4848,
|
|
4856, 4861, 4867, 4870, 4878, 4885, 4894, 4897, 4914, 4922, 4930, 4934,
|
|
4941, 4947, 4955, 4964, 4970, 4977, 4984, 4989, 4992, 4994, 5000, 5002,
|
|
5006, 5008, 5015, 5020, 5024, 5030, 5039, 5045, 5052, 5058, 5064, 5069,
|
|
5072, 5074, 5080, 5082, 5086, 5088, 5095, 5097, 5102, 5109, 5118, 5123,
|
|
5132, 5139, 5144, 5147, 5149, 5155, 5157, 5160, 5168, 5173, 5178, 5182,
|
|
5188, 5193, 5197, 5203, 5205, 5216, 5219, 5226, 5229, 5241, 5247, 5256,
|
|
5265, 5270, 5279, 5285, 5296, 5302, 5307, 5311, 5317, 5322, 5326, 5329,
|
|
5341, 5348, 5353, 5383, 5387, 5392, 5399, 5402, 5408, 5418, 5428, 5438,
|
|
5444, 5453, 5459, 5466, 5468, 5478, 5482, 5486, 5496, 5501, 5573, 5591,
|
|
5599, 5611, 5618, 5620, 5630, 5633, 5641, 5648, 5652, 5659, 5664, 5667,
|
|
5670, 5679, 5683, 5687, 5710, 5717, 5721, 5728, 5735, 5738, 5754, 5757,
|
|
5767, 5771, 5777, 5780, 5785, 5789, 5796, 5799, 5805, 5829, 5832, 5844,
|
|
5847, 5857, 5865, 5869, 5876, 5879, 5888, 5894, 5900, 5910, 5912, 5918,
|
|
5921, 5924, 5936, 5939, 5945, 5948, 5956, 5964, 5970, 5974, 5988, 6000,
|
|
6007, 6010, 6017, 6024, 6029, 6042, 6053, 6059, 6064, 6077, 6079, 6084,
|
|
6088, 6091, 6093, 6100, 6107, 6110, 6113, 6119, 6123, 6129, 6135, 6148,
|
|
6153, 6161, 6164, 6169, 6174, 6182, 6185, 6193, 6197, 6204, 6210, 6213,
|
|
6217, 6230, 6236, 6248, 6251, 6260, 6265, 6271, 6277, 6282, 6284, 6287,
|
|
6291, 6293, 6297, 6303, 6306, 6309, 6315, 6324, 6332, 6336, 6341, 6361,
|
|
6368, 6370, 6377, 6379, 6383, 6388, 6399, 6404, 6410, 6413, 6417, 6422,
|
|
6425, 6429, 6433, 6435, 6440, 6445, 6458, 6461, 6465, 6468, 6471, 6476,
|
|
6481, 6487, 6490, 6495, 6498, 6503, 6506, 6510, 6515, 6520, 6525, 6530,
|
|
6533, 6538, 6543, 6548, 6554, 6559, 6564, 6569, 6573, 6576, 6581, 6585,
|
|
6589, 6597, 6604, 6608, 6613, 6618, 6622, 6624, 6627, 6643, 6652, 6660,
|
|
6668, 6677, 6687, 6695, 6703, 6711, 6719, 6731, 6738, 6748, 6753, 6756,
|
|
6761, 6764, 6768, 6783, 6791, 6798, 6803, 6808, 6842, 6846, 6854, 6858,
|
|
6867, 6875, 6880, 6888, 6893, 6898, 6900, 6909, 6914, 6922, 6927, 6935,
|
|
6943, 6946, 6956, 6974, 6977, 6980, 6984, 6997, 7005, 7009, 7014, 7019,
|
|
7025, 7030, 7034, 7039, 7044, 7049, 7059, 7062, 7066, 7070, 7077, 7081,
|
|
7110, 7118, 7121, 7124, 7127, 7130, 7141, 7155, 7164, 7191, 7202, 7209,
|
|
7213, 7220, 7228, 7233, 7241, 7253, 7266, 7272, 7278, 7294, 7300, 7309,
|
|
7311, 7333, 7345, 7362, 7383, 7385, 7404, 7413, 7422, 7433,
|
|
}
|
|
deserializer := antlr.NewATNDeserializer(nil)
|
|
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
|
|
atn := staticData.atn
|
|
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
|
|
decisionToDFA := staticData.decisionToDFA
|
|
for index, state := range atn.DecisionToState {
|
|
decisionToDFA[index] = antlr.NewDFA(state, index)
|
|
}
|
|
}
|
|
|
|
// MySqlParserInit initializes any static state used to implement MySqlParser. By default the
|
|
// static state used to implement the parser is lazily initialized during the first call to
|
|
// NewMySqlParser(). You can call this function if you wish to initialize the static state ahead
|
|
// of time.
|
|
func MySqlParserInit() {
|
|
staticData := &MySqlParserParserStaticData
|
|
staticData.once.Do(mysqlparserParserInit)
|
|
}
|
|
|
|
// NewMySqlParser produces a new parser instance for the optional input antlr.TokenStream.
|
|
func NewMySqlParser(input antlr.TokenStream) *MySqlParser {
|
|
MySqlParserInit()
|
|
this := new(MySqlParser)
|
|
this.BaseParser = antlr.NewBaseParser(input)
|
|
staticData := &MySqlParserParserStaticData
|
|
this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
|
|
this.RuleNames = staticData.RuleNames
|
|
this.LiteralNames = staticData.LiteralNames
|
|
this.SymbolicNames = staticData.SymbolicNames
|
|
this.GrammarFileName = "MySqlParser.g4"
|
|
|
|
return this
|
|
}
|
|
|
|
// MySqlParser tokens.
|
|
const (
|
|
MySqlParserEOF = antlr.TokenEOF
|
|
MySqlParserSPACE = 1
|
|
MySqlParserSPEC_MYSQL_COMMENT = 2
|
|
MySqlParserCOMMENT_INPUT = 3
|
|
MySqlParserLINE_COMMENT = 4
|
|
MySqlParserADD = 5
|
|
MySqlParserALL = 6
|
|
MySqlParserALTER = 7
|
|
MySqlParserALWAYS = 8
|
|
MySqlParserANALYZE = 9
|
|
MySqlParserAND = 10
|
|
MySqlParserARRAY = 11
|
|
MySqlParserAS = 12
|
|
MySqlParserASC = 13
|
|
MySqlParserATTRIBUTE = 14
|
|
MySqlParserBEFORE = 15
|
|
MySqlParserBETWEEN = 16
|
|
MySqlParserBOTH = 17
|
|
MySqlParserBUCKETS = 18
|
|
MySqlParserBY = 19
|
|
MySqlParserCALL = 20
|
|
MySqlParserCASCADE = 21
|
|
MySqlParserCASE = 22
|
|
MySqlParserCAST = 23
|
|
MySqlParserCHANGE = 24
|
|
MySqlParserCHARACTER = 25
|
|
MySqlParserCHECK = 26
|
|
MySqlParserCOLLATE = 27
|
|
MySqlParserCOLUMN = 28
|
|
MySqlParserCONDITION = 29
|
|
MySqlParserCONSTRAINT = 30
|
|
MySqlParserCONTINUE = 31
|
|
MySqlParserCONVERT = 32
|
|
MySqlParserCREATE = 33
|
|
MySqlParserCROSS = 34
|
|
MySqlParserCURRENT = 35
|
|
MySqlParserCURRENT_ROLE = 36
|
|
MySqlParserCURRENT_USER = 37
|
|
MySqlParserCURSOR = 38
|
|
MySqlParserDATABASE = 39
|
|
MySqlParserDATABASES = 40
|
|
MySqlParserDECLARE = 41
|
|
MySqlParserDEFAULT = 42
|
|
MySqlParserDELAYED = 43
|
|
MySqlParserDELETE = 44
|
|
MySqlParserDESC = 45
|
|
MySqlParserDESCRIBE = 46
|
|
MySqlParserDETERMINISTIC = 47
|
|
MySqlParserDIAGNOSTICS = 48
|
|
MySqlParserDISTINCT = 49
|
|
MySqlParserDISTINCTROW = 50
|
|
MySqlParserDROP = 51
|
|
MySqlParserEACH = 52
|
|
MySqlParserELSE = 53
|
|
MySqlParserELSEIF = 54
|
|
MySqlParserEMPTY = 55
|
|
MySqlParserENCLOSED = 56
|
|
MySqlParserENFORCED = 57
|
|
MySqlParserESCAPED = 58
|
|
MySqlParserEXCEPT = 59
|
|
MySqlParserEXISTS = 60
|
|
MySqlParserEXIT = 61
|
|
MySqlParserEXPLAIN = 62
|
|
MySqlParserFALSE = 63
|
|
MySqlParserFETCH = 64
|
|
MySqlParserFOR = 65
|
|
MySqlParserFORCE = 66
|
|
MySqlParserFOREIGN = 67
|
|
MySqlParserFROM = 68
|
|
MySqlParserFULLTEXT = 69
|
|
MySqlParserGENERATED = 70
|
|
MySqlParserGET = 71
|
|
MySqlParserGRANT = 72
|
|
MySqlParserGROUP = 73
|
|
MySqlParserHAVING = 74
|
|
MySqlParserHIGH_PRIORITY = 75
|
|
MySqlParserHISTOGRAM = 76
|
|
MySqlParserIF = 77
|
|
MySqlParserIGNORE = 78
|
|
MySqlParserIGNORED = 79
|
|
MySqlParserIN = 80
|
|
MySqlParserINDEX = 81
|
|
MySqlParserINFILE = 82
|
|
MySqlParserINNER = 83
|
|
MySqlParserINOUT = 84
|
|
MySqlParserINSERT = 85
|
|
MySqlParserINTERVAL = 86
|
|
MySqlParserINTO = 87
|
|
MySqlParserIS = 88
|
|
MySqlParserITERATE = 89
|
|
MySqlParserJOIN = 90
|
|
MySqlParserKEY = 91
|
|
MySqlParserKEYS = 92
|
|
MySqlParserKILL = 93
|
|
MySqlParserLATERAL = 94
|
|
MySqlParserLEADING = 95
|
|
MySqlParserLEAVE = 96
|
|
MySqlParserLEFT = 97
|
|
MySqlParserLIKE = 98
|
|
MySqlParserLIMIT = 99
|
|
MySqlParserLINEAR = 100
|
|
MySqlParserLINES = 101
|
|
MySqlParserLOAD = 102
|
|
MySqlParserLOCK = 103
|
|
MySqlParserLOCKED = 104
|
|
MySqlParserLOOP = 105
|
|
MySqlParserLOW_PRIORITY = 106
|
|
MySqlParserMASTER_BIND = 107
|
|
MySqlParserMASTER_SSL_VERIFY_SERVER_CERT = 108
|
|
MySqlParserMATCH = 109
|
|
MySqlParserMAXVALUE = 110
|
|
MySqlParserMINVALUE = 111
|
|
MySqlParserMODIFIES = 112
|
|
MySqlParserNATURAL = 113
|
|
MySqlParserNOT = 114
|
|
MySqlParserNO_WRITE_TO_BINLOG = 115
|
|
MySqlParserNULL_LITERAL = 116
|
|
MySqlParserNUMBER = 117
|
|
MySqlParserON = 118
|
|
MySqlParserOPTIMIZE = 119
|
|
MySqlParserOPTION = 120
|
|
MySqlParserOPTIONAL = 121
|
|
MySqlParserOPTIONALLY = 122
|
|
MySqlParserOR = 123
|
|
MySqlParserORDER = 124
|
|
MySqlParserOUT = 125
|
|
MySqlParserOUTER = 126
|
|
MySqlParserOUTFILE = 127
|
|
MySqlParserOVER = 128
|
|
MySqlParserPARTITION = 129
|
|
MySqlParserPRIMARY = 130
|
|
MySqlParserPROCEDURE = 131
|
|
MySqlParserPURGE = 132
|
|
MySqlParserRANGE = 133
|
|
MySqlParserREAD = 134
|
|
MySqlParserREADS = 135
|
|
MySqlParserREFERENCES = 136
|
|
MySqlParserREGEXP = 137
|
|
MySqlParserRELEASE = 138
|
|
MySqlParserRENAME = 139
|
|
MySqlParserREPEAT = 140
|
|
MySqlParserREPLACE = 141
|
|
MySqlParserREQUIRE = 142
|
|
MySqlParserRESIGNAL = 143
|
|
MySqlParserRESTRICT = 144
|
|
MySqlParserRETAIN = 145
|
|
MySqlParserRETURN = 146
|
|
MySqlParserREVOKE = 147
|
|
MySqlParserRIGHT = 148
|
|
MySqlParserRLIKE = 149
|
|
MySqlParserSCHEMA = 150
|
|
MySqlParserSCHEMAS = 151
|
|
MySqlParserSELECT = 152
|
|
MySqlParserSET = 153
|
|
MySqlParserSEPARATOR = 154
|
|
MySqlParserSHOW = 155
|
|
MySqlParserSIGNAL = 156
|
|
MySqlParserSKIP_ = 157
|
|
MySqlParserSKIP_QUERY_REWRITE = 158
|
|
MySqlParserSPATIAL = 159
|
|
MySqlParserSQL = 160
|
|
MySqlParserSQLEXCEPTION = 161
|
|
MySqlParserSQLSTATE = 162
|
|
MySqlParserSQLWARNING = 163
|
|
MySqlParserSQL_BIG_RESULT = 164
|
|
MySqlParserSQL_CALC_FOUND_ROWS = 165
|
|
MySqlParserSQL_SMALL_RESULT = 166
|
|
MySqlParserSSL = 167
|
|
MySqlParserSTACKED = 168
|
|
MySqlParserSTARTING = 169
|
|
MySqlParserSTATEMENT = 170
|
|
MySqlParserSTRAIGHT_JOIN = 171
|
|
MySqlParserTABLE = 172
|
|
MySqlParserTERMINATED = 173
|
|
MySqlParserTHEN = 174
|
|
MySqlParserTO = 175
|
|
MySqlParserTRAILING = 176
|
|
MySqlParserTRIGGER = 177
|
|
MySqlParserTRUE = 178
|
|
MySqlParserUNDO = 179
|
|
MySqlParserUNION = 180
|
|
MySqlParserUNIQUE = 181
|
|
MySqlParserUNLOCK = 182
|
|
MySqlParserUNSIGNED = 183
|
|
MySqlParserUPDATE = 184
|
|
MySqlParserUSAGE = 185
|
|
MySqlParserUSE = 186
|
|
MySqlParserUSING = 187
|
|
MySqlParserVALUES = 188
|
|
MySqlParserWHEN = 189
|
|
MySqlParserWHERE = 190
|
|
MySqlParserWHILE = 191
|
|
MySqlParserWITH = 192
|
|
MySqlParserWRITE = 193
|
|
MySqlParserXOR = 194
|
|
MySqlParserZEROFILL = 195
|
|
MySqlParserTINYINT = 196
|
|
MySqlParserSMALLINT = 197
|
|
MySqlParserMEDIUMINT = 198
|
|
MySqlParserMIDDLEINT = 199
|
|
MySqlParserINT = 200
|
|
MySqlParserINT1 = 201
|
|
MySqlParserINT2 = 202
|
|
MySqlParserINT3 = 203
|
|
MySqlParserINT4 = 204
|
|
MySqlParserINT8 = 205
|
|
MySqlParserINTEGER = 206
|
|
MySqlParserBIGINT = 207
|
|
MySqlParserREAL = 208
|
|
MySqlParserDOUBLE = 209
|
|
MySqlParserPRECISION = 210
|
|
MySqlParserFLOAT = 211
|
|
MySqlParserFLOAT4 = 212
|
|
MySqlParserFLOAT8 = 213
|
|
MySqlParserDECIMAL = 214
|
|
MySqlParserDEC = 215
|
|
MySqlParserNUMERIC = 216
|
|
MySqlParserDATE = 217
|
|
MySqlParserTIME = 218
|
|
MySqlParserTIMESTAMP = 219
|
|
MySqlParserDATETIME = 220
|
|
MySqlParserYEAR = 221
|
|
MySqlParserCHAR = 222
|
|
MySqlParserVARCHAR = 223
|
|
MySqlParserNVARCHAR = 224
|
|
MySqlParserNATIONAL = 225
|
|
MySqlParserBINARY = 226
|
|
MySqlParserVARBINARY = 227
|
|
MySqlParserTINYBLOB = 228
|
|
MySqlParserBLOB = 229
|
|
MySqlParserMEDIUMBLOB = 230
|
|
MySqlParserLONG = 231
|
|
MySqlParserLONGBLOB = 232
|
|
MySqlParserTINYTEXT = 233
|
|
MySqlParserTEXT = 234
|
|
MySqlParserMEDIUMTEXT = 235
|
|
MySqlParserLONGTEXT = 236
|
|
MySqlParserENUM = 237
|
|
MySqlParserVARYING = 238
|
|
MySqlParserSERIAL = 239
|
|
MySqlParserYEAR_MONTH = 240
|
|
MySqlParserDAY_HOUR = 241
|
|
MySqlParserDAY_MINUTE = 242
|
|
MySqlParserDAY_SECOND = 243
|
|
MySqlParserHOUR_MINUTE = 244
|
|
MySqlParserHOUR_SECOND = 245
|
|
MySqlParserMINUTE_SECOND = 246
|
|
MySqlParserSECOND_MICROSECOND = 247
|
|
MySqlParserMINUTE_MICROSECOND = 248
|
|
MySqlParserHOUR_MICROSECOND = 249
|
|
MySqlParserDAY_MICROSECOND = 250
|
|
MySqlParserJSON_ARRAY = 251
|
|
MySqlParserJSON_ARRAYAGG = 252
|
|
MySqlParserJSON_ARRAY_APPEND = 253
|
|
MySqlParserJSON_ARRAY_INSERT = 254
|
|
MySqlParserJSON_CONTAINS = 255
|
|
MySqlParserJSON_CONTAINS_PATH = 256
|
|
MySqlParserJSON_DEPTH = 257
|
|
MySqlParserJSON_EXTRACT = 258
|
|
MySqlParserJSON_INSERT = 259
|
|
MySqlParserJSON_KEYS = 260
|
|
MySqlParserJSON_LENGTH = 261
|
|
MySqlParserJSON_MERGE = 262
|
|
MySqlParserJSON_MERGE_PATCH = 263
|
|
MySqlParserJSON_MERGE_PRESERVE = 264
|
|
MySqlParserJSON_OBJECT = 265
|
|
MySqlParserJSON_OBJECTAGG = 266
|
|
MySqlParserJSON_OVERLAPS = 267
|
|
MySqlParserJSON_PRETTY = 268
|
|
MySqlParserJSON_QUOTE = 269
|
|
MySqlParserJSON_REMOVE = 270
|
|
MySqlParserJSON_REPLACE = 271
|
|
MySqlParserJSON_SCHEMA_VALID = 272
|
|
MySqlParserJSON_SCHEMA_VALIDATION_REPORT = 273
|
|
MySqlParserJSON_SEARCH = 274
|
|
MySqlParserJSON_SET = 275
|
|
MySqlParserJSON_STORAGE_FREE = 276
|
|
MySqlParserJSON_STORAGE_SIZE = 277
|
|
MySqlParserJSON_TABLE = 278
|
|
MySqlParserJSON_TYPE = 279
|
|
MySqlParserJSON_UNQUOTE = 280
|
|
MySqlParserJSON_VALID = 281
|
|
MySqlParserJSON_VALUE = 282
|
|
MySqlParserNESTED = 283
|
|
MySqlParserORDINALITY = 284
|
|
MySqlParserPATH = 285
|
|
MySqlParserAVG = 286
|
|
MySqlParserBIT_AND = 287
|
|
MySqlParserBIT_OR = 288
|
|
MySqlParserBIT_XOR = 289
|
|
MySqlParserCOUNT = 290
|
|
MySqlParserCUME_DIST = 291
|
|
MySqlParserDENSE_RANK = 292
|
|
MySqlParserFIRST_VALUE = 293
|
|
MySqlParserGROUP_CONCAT = 294
|
|
MySqlParserLAG = 295
|
|
MySqlParserLAST_VALUE = 296
|
|
MySqlParserLEAD = 297
|
|
MySqlParserMAX = 298
|
|
MySqlParserMIN = 299
|
|
MySqlParserNTILE = 300
|
|
MySqlParserNTH_VALUE = 301
|
|
MySqlParserPERCENT_RANK = 302
|
|
MySqlParserRANK = 303
|
|
MySqlParserROW_NUMBER = 304
|
|
MySqlParserSTD = 305
|
|
MySqlParserSTDDEV = 306
|
|
MySqlParserSTDDEV_POP = 307
|
|
MySqlParserSTDDEV_SAMP = 308
|
|
MySqlParserSUM = 309
|
|
MySqlParserVAR_POP = 310
|
|
MySqlParserVAR_SAMP = 311
|
|
MySqlParserVARIANCE = 312
|
|
MySqlParserCURRENT_DATE = 313
|
|
MySqlParserCURRENT_TIME = 314
|
|
MySqlParserCURRENT_TIMESTAMP = 315
|
|
MySqlParserLOCALTIME = 316
|
|
MySqlParserCURDATE = 317
|
|
MySqlParserCURTIME = 318
|
|
MySqlParserDATE_ADD = 319
|
|
MySqlParserDATE_SUB = 320
|
|
MySqlParserEXTRACT = 321
|
|
MySqlParserLOCALTIMESTAMP = 322
|
|
MySqlParserNOW = 323
|
|
MySqlParserPOSITION = 324
|
|
MySqlParserSUBSTR = 325
|
|
MySqlParserSUBSTRING = 326
|
|
MySqlParserSYSDATE = 327
|
|
MySqlParserTRIM = 328
|
|
MySqlParserUTC_DATE = 329
|
|
MySqlParserUTC_TIME = 330
|
|
MySqlParserUTC_TIMESTAMP = 331
|
|
MySqlParserACCOUNT = 332
|
|
MySqlParserACTION = 333
|
|
MySqlParserAFTER = 334
|
|
MySqlParserAGGREGATE = 335
|
|
MySqlParserALGORITHM = 336
|
|
MySqlParserANY = 337
|
|
MySqlParserAT = 338
|
|
MySqlParserAUTHORS = 339
|
|
MySqlParserAUTOCOMMIT = 340
|
|
MySqlParserAUTOEXTEND_SIZE = 341
|
|
MySqlParserAUTO_INCREMENT = 342
|
|
MySqlParserAVG_ROW_LENGTH = 343
|
|
MySqlParserBEGIN = 344
|
|
MySqlParserBINLOG = 345
|
|
MySqlParserBIT = 346
|
|
MySqlParserBLOCK = 347
|
|
MySqlParserBOOL = 348
|
|
MySqlParserBOOLEAN = 349
|
|
MySqlParserBTREE = 350
|
|
MySqlParserCACHE = 351
|
|
MySqlParserCASCADED = 352
|
|
MySqlParserCHAIN = 353
|
|
MySqlParserCHANGED = 354
|
|
MySqlParserCHANNEL = 355
|
|
MySqlParserCHECKSUM = 356
|
|
MySqlParserPAGE_CHECKSUM = 357
|
|
MySqlParserCIPHER = 358
|
|
MySqlParserCLASS_ORIGIN = 359
|
|
MySqlParserCLIENT = 360
|
|
MySqlParserCLOSE = 361
|
|
MySqlParserCLUSTERING = 362
|
|
MySqlParserCOALESCE = 363
|
|
MySqlParserCODE = 364
|
|
MySqlParserCOLUMNS = 365
|
|
MySqlParserCOLUMN_FORMAT = 366
|
|
MySqlParserCOLUMN_NAME = 367
|
|
MySqlParserCOMMENT = 368
|
|
MySqlParserCOMMIT = 369
|
|
MySqlParserCOMPACT = 370
|
|
MySqlParserCOMPLETION = 371
|
|
MySqlParserCOMPRESSED = 372
|
|
MySqlParserCOMPRESSION = 373
|
|
MySqlParserCONCURRENT = 374
|
|
MySqlParserCONNECT = 375
|
|
MySqlParserCONNECTION = 376
|
|
MySqlParserCONSISTENT = 377
|
|
MySqlParserCONSTRAINT_CATALOG = 378
|
|
MySqlParserCONSTRAINT_SCHEMA = 379
|
|
MySqlParserCONSTRAINT_NAME = 380
|
|
MySqlParserCONTAINS = 381
|
|
MySqlParserCONTEXT = 382
|
|
MySqlParserCONTRIBUTORS = 383
|
|
MySqlParserCOPY = 384
|
|
MySqlParserCPU = 385
|
|
MySqlParserCYCLE = 386
|
|
MySqlParserCURSOR_NAME = 387
|
|
MySqlParserDATA = 388
|
|
MySqlParserDATAFILE = 389
|
|
MySqlParserDEALLOCATE = 390
|
|
MySqlParserDEFAULT_AUTH = 391
|
|
MySqlParserDEFINER = 392
|
|
MySqlParserDELAY_KEY_WRITE = 393
|
|
MySqlParserDES_KEY_FILE = 394
|
|
MySqlParserDIRECTORY = 395
|
|
MySqlParserDISABLE = 396
|
|
MySqlParserDISCARD = 397
|
|
MySqlParserDISK = 398
|
|
MySqlParserDO = 399
|
|
MySqlParserDUMPFILE = 400
|
|
MySqlParserDUPLICATE = 401
|
|
MySqlParserDYNAMIC = 402
|
|
MySqlParserENABLE = 403
|
|
MySqlParserENCRYPTED = 404
|
|
MySqlParserENCRYPTION = 405
|
|
MySqlParserENCRYPTION_KEY_ID = 406
|
|
MySqlParserEND = 407
|
|
MySqlParserENDS = 408
|
|
MySqlParserENGINE = 409
|
|
MySqlParserENGINES = 410
|
|
MySqlParserERROR = 411
|
|
MySqlParserERRORS = 412
|
|
MySqlParserESCAPE = 413
|
|
MySqlParserEVEN = 414
|
|
MySqlParserEVENT = 415
|
|
MySqlParserEVENTS = 416
|
|
MySqlParserEVERY = 417
|
|
MySqlParserEXCHANGE = 418
|
|
MySqlParserEXCLUSIVE = 419
|
|
MySqlParserEXPIRE = 420
|
|
MySqlParserEXPORT = 421
|
|
MySqlParserEXTENDED = 422
|
|
MySqlParserEXTENT_SIZE = 423
|
|
MySqlParserFAILED_LOGIN_ATTEMPTS = 424
|
|
MySqlParserFAST = 425
|
|
MySqlParserFAULTS = 426
|
|
MySqlParserFIELDS = 427
|
|
MySqlParserFILE_BLOCK_SIZE = 428
|
|
MySqlParserFILTER = 429
|
|
MySqlParserFIRST = 430
|
|
MySqlParserFIXED = 431
|
|
MySqlParserFLUSH = 432
|
|
MySqlParserFOLLOWING = 433
|
|
MySqlParserFOLLOWS = 434
|
|
MySqlParserFOUND = 435
|
|
MySqlParserFULL = 436
|
|
MySqlParserFUNCTION = 437
|
|
MySqlParserGENERAL = 438
|
|
MySqlParserGLOBAL = 439
|
|
MySqlParserGRANTS = 440
|
|
MySqlParserGROUP_REPLICATION = 441
|
|
MySqlParserHANDLER = 442
|
|
MySqlParserHASH = 443
|
|
MySqlParserHELP = 444
|
|
MySqlParserHISTORY = 445
|
|
MySqlParserHOST = 446
|
|
MySqlParserHOSTS = 447
|
|
MySqlParserIDENTIFIED = 448
|
|
MySqlParserIGNORE_SERVER_IDS = 449
|
|
MySqlParserIMPORT = 450
|
|
MySqlParserINCREMENT = 451
|
|
MySqlParserINDEXES = 452
|
|
MySqlParserINITIAL_SIZE = 453
|
|
MySqlParserINPLACE = 454
|
|
MySqlParserINSERT_METHOD = 455
|
|
MySqlParserINSTALL = 456
|
|
MySqlParserINSTANCE = 457
|
|
MySqlParserINSTANT = 458
|
|
MySqlParserINVISIBLE = 459
|
|
MySqlParserINVOKER = 460
|
|
MySqlParserIO = 461
|
|
MySqlParserIO_THREAD = 462
|
|
MySqlParserIPC = 463
|
|
MySqlParserISOLATION = 464
|
|
MySqlParserISSUER = 465
|
|
MySqlParserJSON = 466
|
|
MySqlParserKEY_BLOCK_SIZE = 467
|
|
MySqlParserLANGUAGE = 468
|
|
MySqlParserLAST = 469
|
|
MySqlParserLEAVES = 470
|
|
MySqlParserLESS = 471
|
|
MySqlParserLEVEL = 472
|
|
MySqlParserLIST = 473
|
|
MySqlParserLOCAL = 474
|
|
MySqlParserLOGFILE = 475
|
|
MySqlParserLOGS = 476
|
|
MySqlParserMASTER = 477
|
|
MySqlParserMASTER_AUTO_POSITION = 478
|
|
MySqlParserMASTER_CONNECT_RETRY = 479
|
|
MySqlParserMASTER_DELAY = 480
|
|
MySqlParserMASTER_HEARTBEAT_PERIOD = 481
|
|
MySqlParserMASTER_HOST = 482
|
|
MySqlParserMASTER_LOG_FILE = 483
|
|
MySqlParserMASTER_LOG_POS = 484
|
|
MySqlParserMASTER_PASSWORD = 485
|
|
MySqlParserMASTER_PORT = 486
|
|
MySqlParserMASTER_RETRY_COUNT = 487
|
|
MySqlParserMASTER_SSL = 488
|
|
MySqlParserMASTER_SSL_CA = 489
|
|
MySqlParserMASTER_SSL_CAPATH = 490
|
|
MySqlParserMASTER_SSL_CERT = 491
|
|
MySqlParserMASTER_SSL_CIPHER = 492
|
|
MySqlParserMASTER_SSL_CRL = 493
|
|
MySqlParserMASTER_SSL_CRLPATH = 494
|
|
MySqlParserMASTER_SSL_KEY = 495
|
|
MySqlParserMASTER_TLS_VERSION = 496
|
|
MySqlParserMASTER_USER = 497
|
|
MySqlParserMAX_CONNECTIONS_PER_HOUR = 498
|
|
MySqlParserMAX_QUERIES_PER_HOUR = 499
|
|
MySqlParserMAX_ROWS = 500
|
|
MySqlParserMAX_SIZE = 501
|
|
MySqlParserMAX_UPDATES_PER_HOUR = 502
|
|
MySqlParserMAX_USER_CONNECTIONS = 503
|
|
MySqlParserMEDIUM = 504
|
|
MySqlParserMEMBER = 505
|
|
MySqlParserMERGE = 506
|
|
MySqlParserMESSAGE_TEXT = 507
|
|
MySqlParserMID = 508
|
|
MySqlParserMIGRATE = 509
|
|
MySqlParserMIN_ROWS = 510
|
|
MySqlParserMODE = 511
|
|
MySqlParserMODIFY = 512
|
|
MySqlParserMUTEX = 513
|
|
MySqlParserMYSQL = 514
|
|
MySqlParserMYSQL_ERRNO = 515
|
|
MySqlParserNAME = 516
|
|
MySqlParserNAMES = 517
|
|
MySqlParserNCHAR = 518
|
|
MySqlParserNEVER = 519
|
|
MySqlParserNEXT = 520
|
|
MySqlParserNO = 521
|
|
MySqlParserNOCACHE = 522
|
|
MySqlParserNOCOPY = 523
|
|
MySqlParserNOCYCLE = 524
|
|
MySqlParserNOMAXVALUE = 525
|
|
MySqlParserNOMINVALUE = 526
|
|
MySqlParserNOWAIT = 527
|
|
MySqlParserNODEGROUP = 528
|
|
MySqlParserNONE = 529
|
|
MySqlParserODBC = 530
|
|
MySqlParserOFFLINE = 531
|
|
MySqlParserOFFSET = 532
|
|
MySqlParserOF = 533
|
|
MySqlParserOJ = 534
|
|
MySqlParserOLD_PASSWORD = 535
|
|
MySqlParserONE = 536
|
|
MySqlParserONLINE = 537
|
|
MySqlParserONLY = 538
|
|
MySqlParserOPEN = 539
|
|
MySqlParserOPTIMIZER_COSTS = 540
|
|
MySqlParserOPTIONS = 541
|
|
MySqlParserOWNER = 542
|
|
MySqlParserPACK_KEYS = 543
|
|
MySqlParserPAGE = 544
|
|
MySqlParserPAGE_COMPRESSED = 545
|
|
MySqlParserPAGE_COMPRESSION_LEVEL = 546
|
|
MySqlParserPARSER = 547
|
|
MySqlParserPARTIAL = 548
|
|
MySqlParserPARTITIONING = 549
|
|
MySqlParserPARTITIONS = 550
|
|
MySqlParserPASSWORD = 551
|
|
MySqlParserPASSWORD_LOCK_TIME = 552
|
|
MySqlParserPHASE = 553
|
|
MySqlParserPLUGIN = 554
|
|
MySqlParserPLUGIN_DIR = 555
|
|
MySqlParserPLUGINS = 556
|
|
MySqlParserPORT = 557
|
|
MySqlParserPRECEDES = 558
|
|
MySqlParserPRECEDING = 559
|
|
MySqlParserPREPARE = 560
|
|
MySqlParserPRESERVE = 561
|
|
MySqlParserPREV = 562
|
|
MySqlParserPROCESSLIST = 563
|
|
MySqlParserPROFILE = 564
|
|
MySqlParserPROFILES = 565
|
|
MySqlParserPROXY = 566
|
|
MySqlParserQUERY = 567
|
|
MySqlParserQUICK = 568
|
|
MySqlParserREBUILD = 569
|
|
MySqlParserRECOVER = 570
|
|
MySqlParserRECURSIVE = 571
|
|
MySqlParserREDO_BUFFER_SIZE = 572
|
|
MySqlParserREDUNDANT = 573
|
|
MySqlParserRELAY = 574
|
|
MySqlParserRELAY_LOG_FILE = 575
|
|
MySqlParserRELAY_LOG_POS = 576
|
|
MySqlParserRELAYLOG = 577
|
|
MySqlParserREMOVE = 578
|
|
MySqlParserREORGANIZE = 579
|
|
MySqlParserREPAIR = 580
|
|
MySqlParserREPLICATE_DO_DB = 581
|
|
MySqlParserREPLICATE_DO_TABLE = 582
|
|
MySqlParserREPLICATE_IGNORE_DB = 583
|
|
MySqlParserREPLICATE_IGNORE_TABLE = 584
|
|
MySqlParserREPLICATE_REWRITE_DB = 585
|
|
MySqlParserREPLICATE_WILD_DO_TABLE = 586
|
|
MySqlParserREPLICATE_WILD_IGNORE_TABLE = 587
|
|
MySqlParserREPLICATION = 588
|
|
MySqlParserRESET = 589
|
|
MySqlParserRESTART = 590
|
|
MySqlParserRESUME = 591
|
|
MySqlParserRETURNED_SQLSTATE = 592
|
|
MySqlParserRETURNING = 593
|
|
MySqlParserRETURNS = 594
|
|
MySqlParserREUSE = 595
|
|
MySqlParserROLE = 596
|
|
MySqlParserROLLBACK = 597
|
|
MySqlParserROLLUP = 598
|
|
MySqlParserROTATE = 599
|
|
MySqlParserROW = 600
|
|
MySqlParserROWS = 601
|
|
MySqlParserROW_FORMAT = 602
|
|
MySqlParserRTREE = 603
|
|
MySqlParserSAVEPOINT = 604
|
|
MySqlParserSCHEDULE = 605
|
|
MySqlParserSECURITY = 606
|
|
MySqlParserSEQUENCE = 607
|
|
MySqlParserSERVER = 608
|
|
MySqlParserSESSION = 609
|
|
MySqlParserSHARE = 610
|
|
MySqlParserSHARED = 611
|
|
MySqlParserSIGNED = 612
|
|
MySqlParserSIMPLE = 613
|
|
MySqlParserSLAVE = 614
|
|
MySqlParserSLOW = 615
|
|
MySqlParserSNAPSHOT = 616
|
|
MySqlParserSOCKET = 617
|
|
MySqlParserSOME = 618
|
|
MySqlParserSONAME = 619
|
|
MySqlParserSOUNDS = 620
|
|
MySqlParserSOURCE = 621
|
|
MySqlParserSQL_AFTER_GTIDS = 622
|
|
MySqlParserSQL_AFTER_MTS_GAPS = 623
|
|
MySqlParserSQL_BEFORE_GTIDS = 624
|
|
MySqlParserSQL_BUFFER_RESULT = 625
|
|
MySqlParserSQL_CACHE = 626
|
|
MySqlParserSQL_NO_CACHE = 627
|
|
MySqlParserSQL_THREAD = 628
|
|
MySqlParserSTART = 629
|
|
MySqlParserSTARTS = 630
|
|
MySqlParserSTATS_AUTO_RECALC = 631
|
|
MySqlParserSTATS_PERSISTENT = 632
|
|
MySqlParserSTATS_SAMPLE_PAGES = 633
|
|
MySqlParserSTATUS = 634
|
|
MySqlParserSTOP = 635
|
|
MySqlParserSTORAGE = 636
|
|
MySqlParserSTORED = 637
|
|
MySqlParserSTRING = 638
|
|
MySqlParserSUBCLASS_ORIGIN = 639
|
|
MySqlParserSUBJECT = 640
|
|
MySqlParserSUBPARTITION = 641
|
|
MySqlParserSUBPARTITIONS = 642
|
|
MySqlParserSUSPEND = 643
|
|
MySqlParserSWAPS = 644
|
|
MySqlParserSWITCHES = 645
|
|
MySqlParserTABLE_NAME = 646
|
|
MySqlParserTABLESPACE = 647
|
|
MySqlParserTABLE_TYPE = 648
|
|
MySqlParserTEMPORARY = 649
|
|
MySqlParserTEMPTABLE = 650
|
|
MySqlParserTHAN = 651
|
|
MySqlParserTRADITIONAL = 652
|
|
MySqlParserTRANSACTION = 653
|
|
MySqlParserTRANSACTIONAL = 654
|
|
MySqlParserTRIGGERS = 655
|
|
MySqlParserTRUNCATE = 656
|
|
MySqlParserUNBOUNDED = 657
|
|
MySqlParserUNDEFINED = 658
|
|
MySqlParserUNDOFILE = 659
|
|
MySqlParserUNDO_BUFFER_SIZE = 660
|
|
MySqlParserUNINSTALL = 661
|
|
MySqlParserUNKNOWN = 662
|
|
MySqlParserUNTIL = 663
|
|
MySqlParserUPGRADE = 664
|
|
MySqlParserUSER = 665
|
|
MySqlParserUSE_FRM = 666
|
|
MySqlParserUSER_RESOURCES = 667
|
|
MySqlParserVALIDATION = 668
|
|
MySqlParserVALUE = 669
|
|
MySqlParserVARIABLES = 670
|
|
MySqlParserVIEW = 671
|
|
MySqlParserVIRTUAL = 672
|
|
MySqlParserVISIBLE = 673
|
|
MySqlParserWAIT = 674
|
|
MySqlParserWARNINGS = 675
|
|
MySqlParserWINDOW = 676
|
|
MySqlParserWITHOUT = 677
|
|
MySqlParserWORK = 678
|
|
MySqlParserWRAPPER = 679
|
|
MySqlParserX509 = 680
|
|
MySqlParserXA = 681
|
|
MySqlParserXML = 682
|
|
MySqlParserYES = 683
|
|
MySqlParserEUR = 684
|
|
MySqlParserUSA = 685
|
|
MySqlParserJIS = 686
|
|
MySqlParserISO = 687
|
|
MySqlParserINTERNAL = 688
|
|
MySqlParserQUARTER = 689
|
|
MySqlParserMONTH = 690
|
|
MySqlParserDAY = 691
|
|
MySqlParserHOUR = 692
|
|
MySqlParserMINUTE = 693
|
|
MySqlParserWEEK = 694
|
|
MySqlParserSECOND = 695
|
|
MySqlParserMICROSECOND = 696
|
|
MySqlParserADMIN = 697
|
|
MySqlParserAPPLICATION_PASSWORD_ADMIN = 698
|
|
MySqlParserAUDIT_ABORT_EXEMPT = 699
|
|
MySqlParserAUDIT_ADMIN = 700
|
|
MySqlParserAUTHENTICATION_POLICY_ADMIN = 701
|
|
MySqlParserBACKUP_ADMIN = 702
|
|
MySqlParserBINLOG_ADMIN = 703
|
|
MySqlParserBINLOG_ENCRYPTION_ADMIN = 704
|
|
MySqlParserCLONE_ADMIN = 705
|
|
MySqlParserCONNECTION_ADMIN = 706
|
|
MySqlParserENCRYPTION_KEY_ADMIN = 707
|
|
MySqlParserEXECUTE = 708
|
|
MySqlParserFILE = 709
|
|
MySqlParserFIREWALL_ADMIN = 710
|
|
MySqlParserFIREWALL_EXEMPT = 711
|
|
MySqlParserFIREWALL_USER = 712
|
|
MySqlParserFLUSH_OPTIMIZER_COSTS = 713
|
|
MySqlParserFLUSH_STATUS = 714
|
|
MySqlParserFLUSH_TABLES = 715
|
|
MySqlParserFLUSH_USER_RESOURCES = 716
|
|
MySqlParserGROUP_REPLICATION_ADMIN = 717
|
|
MySqlParserINNODB_REDO_LOG_ARCHIVE = 718
|
|
MySqlParserINNODB_REDO_LOG_ENABLE = 719
|
|
MySqlParserINVOKE = 720
|
|
MySqlParserLAMBDA = 721
|
|
MySqlParserNDB_STORED_USER = 722
|
|
MySqlParserPASSWORDLESS_USER_ADMIN = 723
|
|
MySqlParserPERSIST_RO_VARIABLES_ADMIN = 724
|
|
MySqlParserPRIVILEGES = 725
|
|
MySqlParserPROCESS = 726
|
|
MySqlParserRELOAD = 727
|
|
MySqlParserREPLICATION_APPLIER = 728
|
|
MySqlParserREPLICATION_SLAVE_ADMIN = 729
|
|
MySqlParserRESOURCE_GROUP_ADMIN = 730
|
|
MySqlParserRESOURCE_GROUP_USER = 731
|
|
MySqlParserROLE_ADMIN = 732
|
|
MySqlParserROUTINE = 733
|
|
MySqlParserS3 = 734
|
|
MySqlParserSERVICE_CONNECTION_ADMIN = 735
|
|
MySqlParserSESSION_VARIABLES_ADMIN = 736
|
|
MySqlParserSET_USER_ID = 737
|
|
MySqlParserSHOW_ROUTINE = 738
|
|
MySqlParserSHUTDOWN = 739
|
|
MySqlParserSUPER = 740
|
|
MySqlParserSYSTEM_VARIABLES_ADMIN = 741
|
|
MySqlParserTABLES = 742
|
|
MySqlParserTABLE_ENCRYPTION_ADMIN = 743
|
|
MySqlParserVERSION_TOKEN_ADMIN = 744
|
|
MySqlParserXA_RECOVER_ADMIN = 745
|
|
MySqlParserARMSCII8 = 746
|
|
MySqlParserASCII = 747
|
|
MySqlParserBIG5 = 748
|
|
MySqlParserCP1250 = 749
|
|
MySqlParserCP1251 = 750
|
|
MySqlParserCP1256 = 751
|
|
MySqlParserCP1257 = 752
|
|
MySqlParserCP850 = 753
|
|
MySqlParserCP852 = 754
|
|
MySqlParserCP866 = 755
|
|
MySqlParserCP932 = 756
|
|
MySqlParserDEC8 = 757
|
|
MySqlParserEUCJPMS = 758
|
|
MySqlParserEUCKR = 759
|
|
MySqlParserGB18030 = 760
|
|
MySqlParserGB2312 = 761
|
|
MySqlParserGBK = 762
|
|
MySqlParserGEOSTD8 = 763
|
|
MySqlParserGREEK = 764
|
|
MySqlParserHEBREW = 765
|
|
MySqlParserHP8 = 766
|
|
MySqlParserKEYBCS2 = 767
|
|
MySqlParserKOI8R = 768
|
|
MySqlParserKOI8U = 769
|
|
MySqlParserLATIN1 = 770
|
|
MySqlParserLATIN2 = 771
|
|
MySqlParserLATIN5 = 772
|
|
MySqlParserLATIN7 = 773
|
|
MySqlParserMACCE = 774
|
|
MySqlParserMACROMAN = 775
|
|
MySqlParserSJIS = 776
|
|
MySqlParserSWE7 = 777
|
|
MySqlParserTIS620 = 778
|
|
MySqlParserUCS2 = 779
|
|
MySqlParserUJIS = 780
|
|
MySqlParserUTF16 = 781
|
|
MySqlParserUTF16LE = 782
|
|
MySqlParserUTF32 = 783
|
|
MySqlParserUTF8 = 784
|
|
MySqlParserUTF8MB3 = 785
|
|
MySqlParserUTF8MB4 = 786
|
|
MySqlParserARCHIVE = 787
|
|
MySqlParserBLACKHOLE = 788
|
|
MySqlParserCSV = 789
|
|
MySqlParserFEDERATED = 790
|
|
MySqlParserINNODB = 791
|
|
MySqlParserMEMORY = 792
|
|
MySqlParserMRG_MYISAM = 793
|
|
MySqlParserMYISAM = 794
|
|
MySqlParserNDB = 795
|
|
MySqlParserNDBCLUSTER = 796
|
|
MySqlParserPERFORMANCE_SCHEMA = 797
|
|
MySqlParserTOKUDB = 798
|
|
MySqlParserREPEATABLE = 799
|
|
MySqlParserCOMMITTED = 800
|
|
MySqlParserUNCOMMITTED = 801
|
|
MySqlParserSERIALIZABLE = 802
|
|
MySqlParserGEOMETRYCOLLECTION = 803
|
|
MySqlParserGEOMCOLLECTION = 804
|
|
MySqlParserGEOMETRY = 805
|
|
MySqlParserLINESTRING = 806
|
|
MySqlParserMULTILINESTRING = 807
|
|
MySqlParserMULTIPOINT = 808
|
|
MySqlParserMULTIPOLYGON = 809
|
|
MySqlParserPOINT = 810
|
|
MySqlParserPOLYGON = 811
|
|
MySqlParserABS = 812
|
|
MySqlParserACOS = 813
|
|
MySqlParserADDDATE = 814
|
|
MySqlParserADDTIME = 815
|
|
MySqlParserAES_DECRYPT = 816
|
|
MySqlParserAES_ENCRYPT = 817
|
|
MySqlParserAREA = 818
|
|
MySqlParserASBINARY = 819
|
|
MySqlParserASIN = 820
|
|
MySqlParserASTEXT = 821
|
|
MySqlParserASWKB = 822
|
|
MySqlParserASWKT = 823
|
|
MySqlParserASYMMETRIC_DECRYPT = 824
|
|
MySqlParserASYMMETRIC_DERIVE = 825
|
|
MySqlParserASYMMETRIC_ENCRYPT = 826
|
|
MySqlParserASYMMETRIC_SIGN = 827
|
|
MySqlParserASYMMETRIC_VERIFY = 828
|
|
MySqlParserATAN = 829
|
|
MySqlParserATAN2 = 830
|
|
MySqlParserBENCHMARK = 831
|
|
MySqlParserBIN = 832
|
|
MySqlParserBIT_COUNT = 833
|
|
MySqlParserBIT_LENGTH = 834
|
|
MySqlParserBUFFER = 835
|
|
MySqlParserCATALOG_NAME = 836
|
|
MySqlParserCEIL = 837
|
|
MySqlParserCEILING = 838
|
|
MySqlParserCENTROID = 839
|
|
MySqlParserCHARACTER_LENGTH = 840
|
|
MySqlParserCHARSET = 841
|
|
MySqlParserCHAR_LENGTH = 842
|
|
MySqlParserCOERCIBILITY = 843
|
|
MySqlParserCOLLATION = 844
|
|
MySqlParserCOMPRESS = 845
|
|
MySqlParserCONCAT = 846
|
|
MySqlParserCONCAT_WS = 847
|
|
MySqlParserCONNECTION_ID = 848
|
|
MySqlParserCONV = 849
|
|
MySqlParserCONVERT_TZ = 850
|
|
MySqlParserCOS = 851
|
|
MySqlParserCOT = 852
|
|
MySqlParserCRC32 = 853
|
|
MySqlParserCREATE_ASYMMETRIC_PRIV_KEY = 854
|
|
MySqlParserCREATE_ASYMMETRIC_PUB_KEY = 855
|
|
MySqlParserCREATE_DH_PARAMETERS = 856
|
|
MySqlParserCREATE_DIGEST = 857
|
|
MySqlParserCROSSES = 858
|
|
MySqlParserDATEDIFF = 859
|
|
MySqlParserDATE_FORMAT = 860
|
|
MySqlParserDAYNAME = 861
|
|
MySqlParserDAYOFMONTH = 862
|
|
MySqlParserDAYOFWEEK = 863
|
|
MySqlParserDAYOFYEAR = 864
|
|
MySqlParserDECODE = 865
|
|
MySqlParserDEGREES = 866
|
|
MySqlParserDES_DECRYPT = 867
|
|
MySqlParserDES_ENCRYPT = 868
|
|
MySqlParserDIMENSION = 869
|
|
MySqlParserDISJOINT = 870
|
|
MySqlParserELT = 871
|
|
MySqlParserENCODE = 872
|
|
MySqlParserENCRYPT = 873
|
|
MySqlParserENDPOINT = 874
|
|
MySqlParserENGINE_ATTRIBUTE = 875
|
|
MySqlParserENVELOPE = 876
|
|
MySqlParserEQUALS = 877
|
|
MySqlParserEXP = 878
|
|
MySqlParserEXPORT_SET = 879
|
|
MySqlParserEXTERIORRING = 880
|
|
MySqlParserEXTRACTVALUE = 881
|
|
MySqlParserFIELD = 882
|
|
MySqlParserFIND_IN_SET = 883
|
|
MySqlParserFLOOR = 884
|
|
MySqlParserFORMAT = 885
|
|
MySqlParserFOUND_ROWS = 886
|
|
MySqlParserFROM_BASE64 = 887
|
|
MySqlParserFROM_DAYS = 888
|
|
MySqlParserFROM_UNIXTIME = 889
|
|
MySqlParserGEOMCOLLFROMTEXT = 890
|
|
MySqlParserGEOMCOLLFROMWKB = 891
|
|
MySqlParserGEOMETRYCOLLECTIONFROMTEXT = 892
|
|
MySqlParserGEOMETRYCOLLECTIONFROMWKB = 893
|
|
MySqlParserGEOMETRYFROMTEXT = 894
|
|
MySqlParserGEOMETRYFROMWKB = 895
|
|
MySqlParserGEOMETRYN = 896
|
|
MySqlParserGEOMETRYTYPE = 897
|
|
MySqlParserGEOMFROMTEXT = 898
|
|
MySqlParserGEOMFROMWKB = 899
|
|
MySqlParserGET_FORMAT = 900
|
|
MySqlParserGET_LOCK = 901
|
|
MySqlParserGLENGTH = 902
|
|
MySqlParserGREATEST = 903
|
|
MySqlParserGTID_SUBSET = 904
|
|
MySqlParserGTID_SUBTRACT = 905
|
|
MySqlParserHEX = 906
|
|
MySqlParserIFNULL = 907
|
|
MySqlParserINET6_ATON = 908
|
|
MySqlParserINET6_NTOA = 909
|
|
MySqlParserINET_ATON = 910
|
|
MySqlParserINET_NTOA = 911
|
|
MySqlParserINSTR = 912
|
|
MySqlParserINTERIORRINGN = 913
|
|
MySqlParserINTERSECTS = 914
|
|
MySqlParserISCLOSED = 915
|
|
MySqlParserISEMPTY = 916
|
|
MySqlParserISNULL = 917
|
|
MySqlParserISSIMPLE = 918
|
|
MySqlParserIS_FREE_LOCK = 919
|
|
MySqlParserIS_IPV4 = 920
|
|
MySqlParserIS_IPV4_COMPAT = 921
|
|
MySqlParserIS_IPV4_MAPPED = 922
|
|
MySqlParserIS_IPV6 = 923
|
|
MySqlParserIS_USED_LOCK = 924
|
|
MySqlParserLAST_INSERT_ID = 925
|
|
MySqlParserLCASE = 926
|
|
MySqlParserLEAST = 927
|
|
MySqlParserLENGTH = 928
|
|
MySqlParserLINEFROMTEXT = 929
|
|
MySqlParserLINEFROMWKB = 930
|
|
MySqlParserLINESTRINGFROMTEXT = 931
|
|
MySqlParserLINESTRINGFROMWKB = 932
|
|
MySqlParserLN = 933
|
|
MySqlParserLOAD_FILE = 934
|
|
MySqlParserLOCATE = 935
|
|
MySqlParserLOG = 936
|
|
MySqlParserLOG10 = 937
|
|
MySqlParserLOG2 = 938
|
|
MySqlParserLOWER = 939
|
|
MySqlParserLPAD = 940
|
|
MySqlParserLTRIM = 941
|
|
MySqlParserMAKEDATE = 942
|
|
MySqlParserMAKETIME = 943
|
|
MySqlParserMAKE_SET = 944
|
|
MySqlParserMASTER_POS_WAIT = 945
|
|
MySqlParserMBRCONTAINS = 946
|
|
MySqlParserMBRDISJOINT = 947
|
|
MySqlParserMBREQUAL = 948
|
|
MySqlParserMBRINTERSECTS = 949
|
|
MySqlParserMBROVERLAPS = 950
|
|
MySqlParserMBRTOUCHES = 951
|
|
MySqlParserMBRWITHIN = 952
|
|
MySqlParserMD5 = 953
|
|
MySqlParserMLINEFROMTEXT = 954
|
|
MySqlParserMLINEFROMWKB = 955
|
|
MySqlParserMONTHNAME = 956
|
|
MySqlParserMPOINTFROMTEXT = 957
|
|
MySqlParserMPOINTFROMWKB = 958
|
|
MySqlParserMPOLYFROMTEXT = 959
|
|
MySqlParserMPOLYFROMWKB = 960
|
|
MySqlParserMULTILINESTRINGFROMTEXT = 961
|
|
MySqlParserMULTILINESTRINGFROMWKB = 962
|
|
MySqlParserMULTIPOINTFROMTEXT = 963
|
|
MySqlParserMULTIPOINTFROMWKB = 964
|
|
MySqlParserMULTIPOLYGONFROMTEXT = 965
|
|
MySqlParserMULTIPOLYGONFROMWKB = 966
|
|
MySqlParserNAME_CONST = 967
|
|
MySqlParserNULLIF = 968
|
|
MySqlParserNUMGEOMETRIES = 969
|
|
MySqlParserNUMINTERIORRINGS = 970
|
|
MySqlParserNUMPOINTS = 971
|
|
MySqlParserOCT = 972
|
|
MySqlParserOCTET_LENGTH = 973
|
|
MySqlParserORD = 974
|
|
MySqlParserOVERLAPS = 975
|
|
MySqlParserPERIOD_ADD = 976
|
|
MySqlParserPERIOD_DIFF = 977
|
|
MySqlParserPI = 978
|
|
MySqlParserPOINTFROMTEXT = 979
|
|
MySqlParserPOINTFROMWKB = 980
|
|
MySqlParserPOINTN = 981
|
|
MySqlParserPOLYFROMTEXT = 982
|
|
MySqlParserPOLYFROMWKB = 983
|
|
MySqlParserPOLYGONFROMTEXT = 984
|
|
MySqlParserPOLYGONFROMWKB = 985
|
|
MySqlParserPOW = 986
|
|
MySqlParserPOWER = 987
|
|
MySqlParserQUOTE = 988
|
|
MySqlParserRADIANS = 989
|
|
MySqlParserRAND = 990
|
|
MySqlParserRANDOM = 991
|
|
MySqlParserRANDOM_BYTES = 992
|
|
MySqlParserRELEASE_LOCK = 993
|
|
MySqlParserREVERSE = 994
|
|
MySqlParserROUND = 995
|
|
MySqlParserROW_COUNT = 996
|
|
MySqlParserRPAD = 997
|
|
MySqlParserRTRIM = 998
|
|
MySqlParserSEC_TO_TIME = 999
|
|
MySqlParserSECONDARY_ENGINE_ATTRIBUTE = 1000
|
|
MySqlParserSESSION_USER = 1001
|
|
MySqlParserSHA = 1002
|
|
MySqlParserSHA1 = 1003
|
|
MySqlParserSHA2 = 1004
|
|
MySqlParserSCHEMA_NAME = 1005
|
|
MySqlParserSIGN = 1006
|
|
MySqlParserSIN = 1007
|
|
MySqlParserSLEEP = 1008
|
|
MySqlParserSOUNDEX = 1009
|
|
MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS = 1010
|
|
MySqlParserSQRT = 1011
|
|
MySqlParserSRID = 1012
|
|
MySqlParserSTARTPOINT = 1013
|
|
MySqlParserSTRCMP = 1014
|
|
MySqlParserSTR_TO_DATE = 1015
|
|
MySqlParserST_AREA = 1016
|
|
MySqlParserST_ASBINARY = 1017
|
|
MySqlParserST_ASTEXT = 1018
|
|
MySqlParserST_ASWKB = 1019
|
|
MySqlParserST_ASWKT = 1020
|
|
MySqlParserST_BUFFER = 1021
|
|
MySqlParserST_CENTROID = 1022
|
|
MySqlParserST_CONTAINS = 1023
|
|
MySqlParserST_CROSSES = 1024
|
|
MySqlParserST_DIFFERENCE = 1025
|
|
MySqlParserST_DIMENSION = 1026
|
|
MySqlParserST_DISJOINT = 1027
|
|
MySqlParserST_DISTANCE = 1028
|
|
MySqlParserST_ENDPOINT = 1029
|
|
MySqlParserST_ENVELOPE = 1030
|
|
MySqlParserST_EQUALS = 1031
|
|
MySqlParserST_EXTERIORRING = 1032
|
|
MySqlParserST_GEOMCOLLFROMTEXT = 1033
|
|
MySqlParserST_GEOMCOLLFROMTXT = 1034
|
|
MySqlParserST_GEOMCOLLFROMWKB = 1035
|
|
MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT = 1036
|
|
MySqlParserST_GEOMETRYCOLLECTIONFROMWKB = 1037
|
|
MySqlParserST_GEOMETRYFROMTEXT = 1038
|
|
MySqlParserST_GEOMETRYFROMWKB = 1039
|
|
MySqlParserST_GEOMETRYN = 1040
|
|
MySqlParserST_GEOMETRYTYPE = 1041
|
|
MySqlParserST_GEOMFROMTEXT = 1042
|
|
MySqlParserST_GEOMFROMWKB = 1043
|
|
MySqlParserST_INTERIORRINGN = 1044
|
|
MySqlParserST_INTERSECTION = 1045
|
|
MySqlParserST_INTERSECTS = 1046
|
|
MySqlParserST_ISCLOSED = 1047
|
|
MySqlParserST_ISEMPTY = 1048
|
|
MySqlParserST_ISSIMPLE = 1049
|
|
MySqlParserST_LINEFROMTEXT = 1050
|
|
MySqlParserST_LINEFROMWKB = 1051
|
|
MySqlParserST_LINESTRINGFROMTEXT = 1052
|
|
MySqlParserST_LINESTRINGFROMWKB = 1053
|
|
MySqlParserST_NUMGEOMETRIES = 1054
|
|
MySqlParserST_NUMINTERIORRING = 1055
|
|
MySqlParserST_NUMINTERIORRINGS = 1056
|
|
MySqlParserST_NUMPOINTS = 1057
|
|
MySqlParserST_OVERLAPS = 1058
|
|
MySqlParserST_POINTFROMTEXT = 1059
|
|
MySqlParserST_POINTFROMWKB = 1060
|
|
MySqlParserST_POINTN = 1061
|
|
MySqlParserST_POLYFROMTEXT = 1062
|
|
MySqlParserST_POLYFROMWKB = 1063
|
|
MySqlParserST_POLYGONFROMTEXT = 1064
|
|
MySqlParserST_POLYGONFROMWKB = 1065
|
|
MySqlParserST_SRID = 1066
|
|
MySqlParserST_STARTPOINT = 1067
|
|
MySqlParserST_SYMDIFFERENCE = 1068
|
|
MySqlParserST_TOUCHES = 1069
|
|
MySqlParserST_UNION = 1070
|
|
MySqlParserST_WITHIN = 1071
|
|
MySqlParserST_X = 1072
|
|
MySqlParserST_Y = 1073
|
|
MySqlParserSUBDATE = 1074
|
|
MySqlParserSUBSTRING_INDEX = 1075
|
|
MySqlParserSUBTIME = 1076
|
|
MySqlParserSYSTEM_USER = 1077
|
|
MySqlParserTAN = 1078
|
|
MySqlParserTIMEDIFF = 1079
|
|
MySqlParserTIMESTAMPADD = 1080
|
|
MySqlParserTIMESTAMPDIFF = 1081
|
|
MySqlParserTIME_FORMAT = 1082
|
|
MySqlParserTIME_TO_SEC = 1083
|
|
MySqlParserTOUCHES = 1084
|
|
MySqlParserTO_BASE64 = 1085
|
|
MySqlParserTO_DAYS = 1086
|
|
MySqlParserTO_SECONDS = 1087
|
|
MySqlParserTP_CONNECTION_ADMIN = 1088
|
|
MySqlParserUCASE = 1089
|
|
MySqlParserUNCOMPRESS = 1090
|
|
MySqlParserUNCOMPRESSED_LENGTH = 1091
|
|
MySqlParserUNHEX = 1092
|
|
MySqlParserUNIX_TIMESTAMP = 1093
|
|
MySqlParserUPDATEXML = 1094
|
|
MySqlParserUPPER = 1095
|
|
MySqlParserUUID = 1096
|
|
MySqlParserUUID_SHORT = 1097
|
|
MySqlParserVALIDATE_PASSWORD_STRENGTH = 1098
|
|
MySqlParserVERSION = 1099
|
|
MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1100
|
|
MySqlParserWEEKDAY = 1101
|
|
MySqlParserWEEKOFYEAR = 1102
|
|
MySqlParserWEIGHT_STRING = 1103
|
|
MySqlParserWITHIN = 1104
|
|
MySqlParserYEARWEEK = 1105
|
|
MySqlParserY_FUNCTION = 1106
|
|
MySqlParserX_FUNCTION = 1107
|
|
MySqlParserVAR_ASSIGN = 1108
|
|
MySqlParserPLUS_ASSIGN = 1109
|
|
MySqlParserMINUS_ASSIGN = 1110
|
|
MySqlParserMULT_ASSIGN = 1111
|
|
MySqlParserDIV_ASSIGN = 1112
|
|
MySqlParserMOD_ASSIGN = 1113
|
|
MySqlParserAND_ASSIGN = 1114
|
|
MySqlParserXOR_ASSIGN = 1115
|
|
MySqlParserOR_ASSIGN = 1116
|
|
MySqlParserSTAR = 1117
|
|
MySqlParserDIVIDE = 1118
|
|
MySqlParserMODULE = 1119
|
|
MySqlParserPLUS = 1120
|
|
MySqlParserMINUS = 1121
|
|
MySqlParserDIV = 1122
|
|
MySqlParserMOD = 1123
|
|
MySqlParserEQUAL_SYMBOL = 1124
|
|
MySqlParserGREATER_SYMBOL = 1125
|
|
MySqlParserLESS_SYMBOL = 1126
|
|
MySqlParserEXCLAMATION_SYMBOL = 1127
|
|
MySqlParserBIT_NOT_OP = 1128
|
|
MySqlParserBIT_OR_OP = 1129
|
|
MySqlParserBIT_AND_OP = 1130
|
|
MySqlParserBIT_XOR_OP = 1131
|
|
MySqlParserDOT = 1132
|
|
MySqlParserLR_BRACKET = 1133
|
|
MySqlParserRR_BRACKET = 1134
|
|
MySqlParserCOMMA = 1135
|
|
MySqlParserSEMI = 1136
|
|
MySqlParserAT_SIGN = 1137
|
|
MySqlParserZERO_DECIMAL = 1138
|
|
MySqlParserONE_DECIMAL = 1139
|
|
MySqlParserTWO_DECIMAL = 1140
|
|
MySqlParserSINGLE_QUOTE_SYMB = 1141
|
|
MySqlParserDOUBLE_QUOTE_SYMB = 1142
|
|
MySqlParserREVERSE_QUOTE_SYMB = 1143
|
|
MySqlParserCOLON_SYMB = 1144
|
|
MySqlParserCHARSET_REVERSE_QOUTE_STRING = 1145
|
|
MySqlParserFILESIZE_LITERAL = 1146
|
|
MySqlParserSTART_NATIONAL_STRING_LITERAL = 1147
|
|
MySqlParserSTRING_LITERAL = 1148
|
|
MySqlParserDECIMAL_LITERAL = 1149
|
|
MySqlParserHEXADECIMAL_LITERAL = 1150
|
|
MySqlParserREAL_LITERAL = 1151
|
|
MySqlParserNULL_SPEC_LITERAL = 1152
|
|
MySqlParserBIT_STRING = 1153
|
|
MySqlParserSTRING_CHARSET_NAME = 1154
|
|
MySqlParserDOT_ID = 1155
|
|
MySqlParserID = 1156
|
|
MySqlParserREVERSE_QUOTE_ID = 1157
|
|
MySqlParserHOST_IP_ADDRESS = 1158
|
|
MySqlParserLOCAL_ID = 1159
|
|
MySqlParserGLOBAL_ID = 1160
|
|
MySqlParserERROR_RECONGNIGION = 1161
|
|
)
|
|
|
|
// MySqlParser rules.
|
|
const (
|
|
MySqlParserRULE_root = 0
|
|
MySqlParserRULE_sqlStatements = 1
|
|
MySqlParserRULE_sqlStatement = 2
|
|
MySqlParserRULE_emptyStatement_ = 3
|
|
MySqlParserRULE_ddlStatement = 4
|
|
MySqlParserRULE_dmlStatement = 5
|
|
MySqlParserRULE_transactionStatement = 6
|
|
MySqlParserRULE_replicationStatement = 7
|
|
MySqlParserRULE_preparedStatement = 8
|
|
MySqlParserRULE_compoundStatement = 9
|
|
MySqlParserRULE_administrationStatement = 10
|
|
MySqlParserRULE_utilityStatement = 11
|
|
MySqlParserRULE_createDatabase = 12
|
|
MySqlParserRULE_createEvent = 13
|
|
MySqlParserRULE_createIndex = 14
|
|
MySqlParserRULE_createLogfileGroup = 15
|
|
MySqlParserRULE_createProcedure = 16
|
|
MySqlParserRULE_createFunction = 17
|
|
MySqlParserRULE_createRole = 18
|
|
MySqlParserRULE_createServer = 19
|
|
MySqlParserRULE_createTable = 20
|
|
MySqlParserRULE_createTablespaceInnodb = 21
|
|
MySqlParserRULE_createTablespaceNdb = 22
|
|
MySqlParserRULE_createTrigger = 23
|
|
MySqlParserRULE_withClause = 24
|
|
MySqlParserRULE_commonTableExpressions = 25
|
|
MySqlParserRULE_cteName = 26
|
|
MySqlParserRULE_cteColumnName = 27
|
|
MySqlParserRULE_createView = 28
|
|
MySqlParserRULE_createDatabaseOption = 29
|
|
MySqlParserRULE_charSet = 30
|
|
MySqlParserRULE_currentUserExpression = 31
|
|
MySqlParserRULE_ownerStatement = 32
|
|
MySqlParserRULE_scheduleExpression = 33
|
|
MySqlParserRULE_timestampValue = 34
|
|
MySqlParserRULE_intervalExpr = 35
|
|
MySqlParserRULE_intervalType = 36
|
|
MySqlParserRULE_enableType = 37
|
|
MySqlParserRULE_indexType = 38
|
|
MySqlParserRULE_indexOption = 39
|
|
MySqlParserRULE_procedureParameter = 40
|
|
MySqlParserRULE_functionParameter = 41
|
|
MySqlParserRULE_routineOption = 42
|
|
MySqlParserRULE_serverOption = 43
|
|
MySqlParserRULE_createDefinitions = 44
|
|
MySqlParserRULE_createDefinition = 45
|
|
MySqlParserRULE_columnDefinition = 46
|
|
MySqlParserRULE_columnConstraint = 47
|
|
MySqlParserRULE_tableConstraint = 48
|
|
MySqlParserRULE_referenceDefinition = 49
|
|
MySqlParserRULE_referenceAction = 50
|
|
MySqlParserRULE_referenceControlType = 51
|
|
MySqlParserRULE_indexColumnDefinition = 52
|
|
MySqlParserRULE_tableOption = 53
|
|
MySqlParserRULE_tableType = 54
|
|
MySqlParserRULE_tablespaceStorage = 55
|
|
MySqlParserRULE_partitionDefinitions = 56
|
|
MySqlParserRULE_partitionFunctionDefinition = 57
|
|
MySqlParserRULE_subpartitionFunctionDefinition = 58
|
|
MySqlParserRULE_partitionDefinition = 59
|
|
MySqlParserRULE_partitionDefinerAtom = 60
|
|
MySqlParserRULE_partitionDefinerVector = 61
|
|
MySqlParserRULE_subpartitionDefinition = 62
|
|
MySqlParserRULE_partitionOption = 63
|
|
MySqlParserRULE_alterDatabase = 64
|
|
MySqlParserRULE_alterEvent = 65
|
|
MySqlParserRULE_alterFunction = 66
|
|
MySqlParserRULE_alterInstance = 67
|
|
MySqlParserRULE_alterLogfileGroup = 68
|
|
MySqlParserRULE_alterProcedure = 69
|
|
MySqlParserRULE_alterServer = 70
|
|
MySqlParserRULE_alterTable = 71
|
|
MySqlParserRULE_alterTablespace = 72
|
|
MySqlParserRULE_alterView = 73
|
|
MySqlParserRULE_alterSpecification = 74
|
|
MySqlParserRULE_alterPartitionSpecification = 75
|
|
MySqlParserRULE_dropDatabase = 76
|
|
MySqlParserRULE_dropEvent = 77
|
|
MySqlParserRULE_dropIndex = 78
|
|
MySqlParserRULE_dropLogfileGroup = 79
|
|
MySqlParserRULE_dropProcedure = 80
|
|
MySqlParserRULE_dropFunction = 81
|
|
MySqlParserRULE_dropServer = 82
|
|
MySqlParserRULE_dropTable = 83
|
|
MySqlParserRULE_dropTablespace = 84
|
|
MySqlParserRULE_dropTrigger = 85
|
|
MySqlParserRULE_dropView = 86
|
|
MySqlParserRULE_dropRole = 87
|
|
MySqlParserRULE_setRole = 88
|
|
MySqlParserRULE_renameTable = 89
|
|
MySqlParserRULE_renameTableClause = 90
|
|
MySqlParserRULE_truncateTable = 91
|
|
MySqlParserRULE_callStatement = 92
|
|
MySqlParserRULE_deleteStatement = 93
|
|
MySqlParserRULE_doStatement = 94
|
|
MySqlParserRULE_handlerStatement = 95
|
|
MySqlParserRULE_insertStatement = 96
|
|
MySqlParserRULE_loadDataStatement = 97
|
|
MySqlParserRULE_loadXmlStatement = 98
|
|
MySqlParserRULE_replaceStatement = 99
|
|
MySqlParserRULE_selectStatement = 100
|
|
MySqlParserRULE_updateStatement = 101
|
|
MySqlParserRULE_valuesStatement = 102
|
|
MySqlParserRULE_insertStatementValue = 103
|
|
MySqlParserRULE_updatedElement = 104
|
|
MySqlParserRULE_assignmentField = 105
|
|
MySqlParserRULE_lockClause = 106
|
|
MySqlParserRULE_singleDeleteStatement = 107
|
|
MySqlParserRULE_multipleDeleteStatement = 108
|
|
MySqlParserRULE_handlerOpenStatement = 109
|
|
MySqlParserRULE_handlerReadIndexStatement = 110
|
|
MySqlParserRULE_handlerReadStatement = 111
|
|
MySqlParserRULE_handlerCloseStatement = 112
|
|
MySqlParserRULE_singleUpdateStatement = 113
|
|
MySqlParserRULE_multipleUpdateStatement = 114
|
|
MySqlParserRULE_orderByClause = 115
|
|
MySqlParserRULE_orderByExpression = 116
|
|
MySqlParserRULE_tableSources = 117
|
|
MySqlParserRULE_tableSource = 118
|
|
MySqlParserRULE_tableSourceItem = 119
|
|
MySqlParserRULE_indexHint = 120
|
|
MySqlParserRULE_indexHintType = 121
|
|
MySqlParserRULE_joinPart = 122
|
|
MySqlParserRULE_joinSpec = 123
|
|
MySqlParserRULE_queryExpression = 124
|
|
MySqlParserRULE_queryExpressionNointo = 125
|
|
MySqlParserRULE_querySpecification = 126
|
|
MySqlParserRULE_querySpecificationNointo = 127
|
|
MySqlParserRULE_unionParenthesis = 128
|
|
MySqlParserRULE_unionStatement = 129
|
|
MySqlParserRULE_lateralStatement = 130
|
|
MySqlParserRULE_jsonTable = 131
|
|
MySqlParserRULE_jsonColumnList = 132
|
|
MySqlParserRULE_jsonColumn = 133
|
|
MySqlParserRULE_jsonOnEmpty = 134
|
|
MySqlParserRULE_jsonOnError = 135
|
|
MySqlParserRULE_selectSpec = 136
|
|
MySqlParserRULE_selectElements = 137
|
|
MySqlParserRULE_selectElement = 138
|
|
MySqlParserRULE_selectIntoExpression = 139
|
|
MySqlParserRULE_selectFieldsInto = 140
|
|
MySqlParserRULE_selectLinesInto = 141
|
|
MySqlParserRULE_fromClause = 142
|
|
MySqlParserRULE_groupByClause = 143
|
|
MySqlParserRULE_havingClause = 144
|
|
MySqlParserRULE_windowClause = 145
|
|
MySqlParserRULE_groupByItem = 146
|
|
MySqlParserRULE_limitClause = 147
|
|
MySqlParserRULE_limitClauseAtom = 148
|
|
MySqlParserRULE_startTransaction = 149
|
|
MySqlParserRULE_beginWork = 150
|
|
MySqlParserRULE_commitWork = 151
|
|
MySqlParserRULE_rollbackWork = 152
|
|
MySqlParserRULE_savepointStatement = 153
|
|
MySqlParserRULE_rollbackStatement = 154
|
|
MySqlParserRULE_releaseStatement = 155
|
|
MySqlParserRULE_lockTables = 156
|
|
MySqlParserRULE_unlockTables = 157
|
|
MySqlParserRULE_setAutocommitStatement = 158
|
|
MySqlParserRULE_setTransactionStatement = 159
|
|
MySqlParserRULE_transactionMode = 160
|
|
MySqlParserRULE_lockTableElement = 161
|
|
MySqlParserRULE_lockAction = 162
|
|
MySqlParserRULE_transactionOption = 163
|
|
MySqlParserRULE_transactionLevel = 164
|
|
MySqlParserRULE_changeMaster = 165
|
|
MySqlParserRULE_changeReplicationFilter = 166
|
|
MySqlParserRULE_purgeBinaryLogs = 167
|
|
MySqlParserRULE_resetMaster = 168
|
|
MySqlParserRULE_resetSlave = 169
|
|
MySqlParserRULE_startSlave = 170
|
|
MySqlParserRULE_stopSlave = 171
|
|
MySqlParserRULE_startGroupReplication = 172
|
|
MySqlParserRULE_stopGroupReplication = 173
|
|
MySqlParserRULE_masterOption = 174
|
|
MySqlParserRULE_stringMasterOption = 175
|
|
MySqlParserRULE_decimalMasterOption = 176
|
|
MySqlParserRULE_boolMasterOption = 177
|
|
MySqlParserRULE_channelOption = 178
|
|
MySqlParserRULE_replicationFilter = 179
|
|
MySqlParserRULE_tablePair = 180
|
|
MySqlParserRULE_threadType = 181
|
|
MySqlParserRULE_untilOption = 182
|
|
MySqlParserRULE_connectionOption = 183
|
|
MySqlParserRULE_gtuidSet = 184
|
|
MySqlParserRULE_xaStartTransaction = 185
|
|
MySqlParserRULE_xaEndTransaction = 186
|
|
MySqlParserRULE_xaPrepareStatement = 187
|
|
MySqlParserRULE_xaCommitWork = 188
|
|
MySqlParserRULE_xaRollbackWork = 189
|
|
MySqlParserRULE_xaRecoverWork = 190
|
|
MySqlParserRULE_prepareStatement = 191
|
|
MySqlParserRULE_executeStatement = 192
|
|
MySqlParserRULE_deallocatePrepare = 193
|
|
MySqlParserRULE_routineBody = 194
|
|
MySqlParserRULE_blockStatement = 195
|
|
MySqlParserRULE_caseStatement = 196
|
|
MySqlParserRULE_ifStatement = 197
|
|
MySqlParserRULE_iterateStatement = 198
|
|
MySqlParserRULE_leaveStatement = 199
|
|
MySqlParserRULE_loopStatement = 200
|
|
MySqlParserRULE_repeatStatement = 201
|
|
MySqlParserRULE_returnStatement = 202
|
|
MySqlParserRULE_whileStatement = 203
|
|
MySqlParserRULE_cursorStatement = 204
|
|
MySqlParserRULE_declareVariable = 205
|
|
MySqlParserRULE_declareCondition = 206
|
|
MySqlParserRULE_declareCursor = 207
|
|
MySqlParserRULE_declareHandler = 208
|
|
MySqlParserRULE_handlerConditionValue = 209
|
|
MySqlParserRULE_procedureSqlStatement = 210
|
|
MySqlParserRULE_caseAlternative = 211
|
|
MySqlParserRULE_elifAlternative = 212
|
|
MySqlParserRULE_alterUser = 213
|
|
MySqlParserRULE_createUser = 214
|
|
MySqlParserRULE_dropUser = 215
|
|
MySqlParserRULE_grantStatement = 216
|
|
MySqlParserRULE_roleOption = 217
|
|
MySqlParserRULE_grantProxy = 218
|
|
MySqlParserRULE_renameUser = 219
|
|
MySqlParserRULE_revokeStatement = 220
|
|
MySqlParserRULE_revokeProxy = 221
|
|
MySqlParserRULE_setPasswordStatement = 222
|
|
MySqlParserRULE_userSpecification = 223
|
|
MySqlParserRULE_userAuthOption = 224
|
|
MySqlParserRULE_authOptionClause = 225
|
|
MySqlParserRULE_authenticationRule = 226
|
|
MySqlParserRULE_tlsOption = 227
|
|
MySqlParserRULE_userResourceOption = 228
|
|
MySqlParserRULE_userPasswordOption = 229
|
|
MySqlParserRULE_userLockOption = 230
|
|
MySqlParserRULE_privelegeClause = 231
|
|
MySqlParserRULE_privilege = 232
|
|
MySqlParserRULE_privilegeLevel = 233
|
|
MySqlParserRULE_renameUserClause = 234
|
|
MySqlParserRULE_analyzeTable = 235
|
|
MySqlParserRULE_checkTable = 236
|
|
MySqlParserRULE_checksumTable = 237
|
|
MySqlParserRULE_optimizeTable = 238
|
|
MySqlParserRULE_repairTable = 239
|
|
MySqlParserRULE_checkTableOption = 240
|
|
MySqlParserRULE_createUdfunction = 241
|
|
MySqlParserRULE_installPlugin = 242
|
|
MySqlParserRULE_uninstallPlugin = 243
|
|
MySqlParserRULE_setStatement = 244
|
|
MySqlParserRULE_showStatement = 245
|
|
MySqlParserRULE_variableClause = 246
|
|
MySqlParserRULE_showCommonEntity = 247
|
|
MySqlParserRULE_showFilter = 248
|
|
MySqlParserRULE_showGlobalInfoClause = 249
|
|
MySqlParserRULE_showSchemaEntity = 250
|
|
MySqlParserRULE_showProfileType = 251
|
|
MySqlParserRULE_binlogStatement = 252
|
|
MySqlParserRULE_cacheIndexStatement = 253
|
|
MySqlParserRULE_flushStatement = 254
|
|
MySqlParserRULE_killStatement = 255
|
|
MySqlParserRULE_loadIndexIntoCache = 256
|
|
MySqlParserRULE_resetStatement = 257
|
|
MySqlParserRULE_shutdownStatement = 258
|
|
MySqlParserRULE_tableIndexes = 259
|
|
MySqlParserRULE_flushOption = 260
|
|
MySqlParserRULE_flushTableOption = 261
|
|
MySqlParserRULE_loadedTableIndexes = 262
|
|
MySqlParserRULE_simpleDescribeStatement = 263
|
|
MySqlParserRULE_fullDescribeStatement = 264
|
|
MySqlParserRULE_helpStatement = 265
|
|
MySqlParserRULE_useStatement = 266
|
|
MySqlParserRULE_signalStatement = 267
|
|
MySqlParserRULE_resignalStatement = 268
|
|
MySqlParserRULE_signalConditionInformation = 269
|
|
MySqlParserRULE_withStatement = 270
|
|
MySqlParserRULE_tableStatement = 271
|
|
MySqlParserRULE_diagnosticsStatement = 272
|
|
MySqlParserRULE_diagnosticsConditionInformationName = 273
|
|
MySqlParserRULE_describeObjectClause = 274
|
|
MySqlParserRULE_fullId = 275
|
|
MySqlParserRULE_tableName = 276
|
|
MySqlParserRULE_roleName = 277
|
|
MySqlParserRULE_fullColumnName = 278
|
|
MySqlParserRULE_indexColumnName = 279
|
|
MySqlParserRULE_simpleUserName = 280
|
|
MySqlParserRULE_hostName = 281
|
|
MySqlParserRULE_userName = 282
|
|
MySqlParserRULE_mysqlVariable = 283
|
|
MySqlParserRULE_charsetName = 284
|
|
MySqlParserRULE_collationName = 285
|
|
MySqlParserRULE_engineName = 286
|
|
MySqlParserRULE_engineNameBase = 287
|
|
MySqlParserRULE_uuidSet = 288
|
|
MySqlParserRULE_xid = 289
|
|
MySqlParserRULE_xuidStringId = 290
|
|
MySqlParserRULE_authPlugin = 291
|
|
MySqlParserRULE_uid = 292
|
|
MySqlParserRULE_simpleId = 293
|
|
MySqlParserRULE_dottedId = 294
|
|
MySqlParserRULE_decimalLiteral = 295
|
|
MySqlParserRULE_fileSizeLiteral = 296
|
|
MySqlParserRULE_stringLiteral = 297
|
|
MySqlParserRULE_booleanLiteral = 298
|
|
MySqlParserRULE_hexadecimalLiteral = 299
|
|
MySqlParserRULE_nullNotnull = 300
|
|
MySqlParserRULE_constant = 301
|
|
MySqlParserRULE_dataType = 302
|
|
MySqlParserRULE_collectionOptions = 303
|
|
MySqlParserRULE_convertedDataType = 304
|
|
MySqlParserRULE_lengthOneDimension = 305
|
|
MySqlParserRULE_lengthTwoDimension = 306
|
|
MySqlParserRULE_lengthTwoOptionalDimension = 307
|
|
MySqlParserRULE_uidList = 308
|
|
MySqlParserRULE_fullColumnNameList = 309
|
|
MySqlParserRULE_tables = 310
|
|
MySqlParserRULE_indexColumnNames = 311
|
|
MySqlParserRULE_expressions = 312
|
|
MySqlParserRULE_expressionsWithDefaults = 313
|
|
MySqlParserRULE_constants = 314
|
|
MySqlParserRULE_simpleStrings = 315
|
|
MySqlParserRULE_userVariables = 316
|
|
MySqlParserRULE_defaultValue = 317
|
|
MySqlParserRULE_currentTimestamp = 318
|
|
MySqlParserRULE_expressionOrDefault = 319
|
|
MySqlParserRULE_ifExists = 320
|
|
MySqlParserRULE_ifNotExists = 321
|
|
MySqlParserRULE_orReplace = 322
|
|
MySqlParserRULE_waitNowaitClause = 323
|
|
MySqlParserRULE_functionCall = 324
|
|
MySqlParserRULE_specificFunction = 325
|
|
MySqlParserRULE_caseFuncAlternative = 326
|
|
MySqlParserRULE_levelsInWeightString = 327
|
|
MySqlParserRULE_levelInWeightListElement = 328
|
|
MySqlParserRULE_aggregateWindowedFunction = 329
|
|
MySqlParserRULE_nonAggregateWindowedFunction = 330
|
|
MySqlParserRULE_overClause = 331
|
|
MySqlParserRULE_windowSpec = 332
|
|
MySqlParserRULE_windowName = 333
|
|
MySqlParserRULE_frameClause = 334
|
|
MySqlParserRULE_frameUnits = 335
|
|
MySqlParserRULE_frameExtent = 336
|
|
MySqlParserRULE_frameBetween = 337
|
|
MySqlParserRULE_frameRange = 338
|
|
MySqlParserRULE_partitionClause = 339
|
|
MySqlParserRULE_scalarFunctionName = 340
|
|
MySqlParserRULE_passwordFunctionClause = 341
|
|
MySqlParserRULE_functionArgs = 342
|
|
MySqlParserRULE_functionArg = 343
|
|
MySqlParserRULE_expression = 344
|
|
MySqlParserRULE_predicate = 345
|
|
MySqlParserRULE_expressionAtom = 346
|
|
MySqlParserRULE_unaryOperator = 347
|
|
MySqlParserRULE_comparisonOperator = 348
|
|
MySqlParserRULE_logicalOperator = 349
|
|
MySqlParserRULE_bitOperator = 350
|
|
MySqlParserRULE_multOperator = 351
|
|
MySqlParserRULE_addOperator = 352
|
|
MySqlParserRULE_jsonOperator = 353
|
|
MySqlParserRULE_charsetNameBase = 354
|
|
MySqlParserRULE_transactionLevelBase = 355
|
|
MySqlParserRULE_privilegesBase = 356
|
|
MySqlParserRULE_intervalTypeBase = 357
|
|
MySqlParserRULE_dataTypeBase = 358
|
|
MySqlParserRULE_keywordsCanBeId = 359
|
|
MySqlParserRULE_functionNameBase = 360
|
|
)
|
|
|
|
// IRootContext is an interface to support dynamic dispatch.
|
|
type IRootContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EOF() antlr.TerminalNode
|
|
SqlStatements() ISqlStatementsContext
|
|
AllMINUS() []antlr.TerminalNode
|
|
MINUS(i int) antlr.TerminalNode
|
|
|
|
// IsRootContext differentiates from other interfaces.
|
|
IsRootContext()
|
|
}
|
|
|
|
type RootContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRootContext() *RootContext {
|
|
var p = new(RootContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_root
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRootContext(p *RootContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_root
|
|
}
|
|
|
|
func (*RootContext) IsRootContext() {}
|
|
|
|
func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext {
|
|
var p = new(RootContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_root
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RootContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RootContext) EOF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEOF, 0)
|
|
}
|
|
|
|
func (s *RootContext) SqlStatements() ISqlStatementsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISqlStatementsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISqlStatementsContext)
|
|
}
|
|
|
|
func (s *RootContext) AllMINUS() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserMINUS)
|
|
}
|
|
|
|
func (s *RootContext) MINUS(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, i)
|
|
}
|
|
|
|
func (s *RootContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoot(s)
|
|
}
|
|
}
|
|
|
|
func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoot(s)
|
|
}
|
|
}
|
|
|
|
func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoot(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Root() (localctx IRootContext) {
|
|
localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 0, MySqlParserRULE_root)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(723)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4614060972218253952) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&2306124490637066243) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&19509751503569451) != 0) || ((int64((_la-344)) & ^0x3f) == 0 && ((int64(1)<<(_la-344))&36099165796700291) != 0) || ((int64((_la-432)) & ^0x3f) == 0 && ((int64(1)<<(_la-432))&16782337) != 0) || ((int64((_la-560)) & ^0x3f) == 0 && ((int64(1)<<(_la-560))&17730162917377) != 0) || ((int64((_la-629)) & ^0x3f) == 0 && ((int64(1)<<(_la-629))&4503604056555585) != 0) || _la == MySqlParserEXECUTE || _la == MySqlParserSHUTDOWN || _la == MySqlParserLR_BRACKET || _la == MySqlParserSEMI {
|
|
{
|
|
p.SetState(722)
|
|
p.SqlStatements()
|
|
}
|
|
|
|
}
|
|
p.SetState(727)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserMINUS {
|
|
{
|
|
p.SetState(725)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(726)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(729)
|
|
p.Match(MySqlParserEOF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISqlStatementsContext is an interface to support dynamic dispatch.
|
|
type ISqlStatementsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllSqlStatement() []ISqlStatementContext
|
|
SqlStatement(i int) ISqlStatementContext
|
|
AllEmptyStatement_() []IEmptyStatement_Context
|
|
EmptyStatement_(i int) IEmptyStatement_Context
|
|
AllSEMI() []antlr.TerminalNode
|
|
SEMI(i int) antlr.TerminalNode
|
|
AllMINUS() []antlr.TerminalNode
|
|
MINUS(i int) antlr.TerminalNode
|
|
|
|
// IsSqlStatementsContext differentiates from other interfaces.
|
|
IsSqlStatementsContext()
|
|
}
|
|
|
|
type SqlStatementsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySqlStatementsContext() *SqlStatementsContext {
|
|
var p = new(SqlStatementsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_sqlStatements
|
|
return p
|
|
}
|
|
|
|
func InitEmptySqlStatementsContext(p *SqlStatementsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_sqlStatements
|
|
}
|
|
|
|
func (*SqlStatementsContext) IsSqlStatementsContext() {}
|
|
|
|
func NewSqlStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlStatementsContext {
|
|
var p = new(SqlStatementsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_sqlStatements
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SqlStatementsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SqlStatementsContext) AllSqlStatement() []ISqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISqlStatementContext); ok {
|
|
tst[i] = t.(ISqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SqlStatementsContext) SqlStatement(i int) ISqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISqlStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) AllEmptyStatement_() []IEmptyStatement_Context {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IEmptyStatement_Context); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IEmptyStatement_Context, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IEmptyStatement_Context); ok {
|
|
tst[i] = t.(IEmptyStatement_Context)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SqlStatementsContext) EmptyStatement_(i int) IEmptyStatement_Context {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEmptyStatement_Context); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEmptyStatement_Context)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) AllSEMI() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSEMI)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) SEMI(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEMI, i)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) AllMINUS() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserMINUS)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) MINUS(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, i)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SqlStatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SqlStatementsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSqlStatements(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlStatementsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSqlStatements(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSqlStatements(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SqlStatements() (localctx ISqlStatementsContext) {
|
|
localctx = NewSqlStatementsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 2, MySqlParserRULE_sqlStatements)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(742)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(740)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(731)
|
|
p.SqlStatement()
|
|
}
|
|
p.SetState(734)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserMINUS {
|
|
{
|
|
p.SetState(732)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(733)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(737)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(736)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserSEMI:
|
|
{
|
|
p.SetState(739)
|
|
p.EmptyStatement_()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(744)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(754)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(745)
|
|
p.SqlStatement()
|
|
}
|
|
p.SetState(751)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 7, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(748)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserMINUS {
|
|
{
|
|
p.SetState(746)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(747)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(750)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserSEMI:
|
|
{
|
|
p.SetState(753)
|
|
p.EmptyStatement_()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISqlStatementContext is an interface to support dynamic dispatch.
|
|
type ISqlStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DdlStatement() IDdlStatementContext
|
|
DmlStatement() IDmlStatementContext
|
|
TransactionStatement() ITransactionStatementContext
|
|
ReplicationStatement() IReplicationStatementContext
|
|
PreparedStatement() IPreparedStatementContext
|
|
AdministrationStatement() IAdministrationStatementContext
|
|
UtilityStatement() IUtilityStatementContext
|
|
|
|
// IsSqlStatementContext differentiates from other interfaces.
|
|
IsSqlStatementContext()
|
|
}
|
|
|
|
type SqlStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySqlStatementContext() *SqlStatementContext {
|
|
var p = new(SqlStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_sqlStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySqlStatementContext(p *SqlStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_sqlStatement
|
|
}
|
|
|
|
func (*SqlStatementContext) IsSqlStatementContext() {}
|
|
|
|
func NewSqlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlStatementContext {
|
|
var p = new(SqlStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_sqlStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SqlStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SqlStatementContext) DdlStatement() IDdlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDdlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDdlStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) DmlStatement() IDmlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDmlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDmlStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) TransactionStatement() ITransactionStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITransactionStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITransactionStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) ReplicationStatement() IReplicationStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReplicationStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReplicationStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) PreparedStatement() IPreparedStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPreparedStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPreparedStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) AdministrationStatement() IAdministrationStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAdministrationStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAdministrationStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) UtilityStatement() IUtilityStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUtilityStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUtilityStatementContext)
|
|
}
|
|
|
|
func (s *SqlStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SqlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SqlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSqlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSqlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSqlStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SqlStatement() (localctx ISqlStatementContext) {
|
|
localctx = NewSqlStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 4, MySqlParserRULE_sqlStatement)
|
|
p.SetState(763)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(756)
|
|
p.DdlStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(757)
|
|
p.DmlStatement()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(758)
|
|
p.TransactionStatement()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(759)
|
|
p.ReplicationStatement()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(760)
|
|
p.PreparedStatement()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(761)
|
|
p.AdministrationStatement()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(762)
|
|
p.UtilityStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IEmptyStatement_Context is an interface to support dynamic dispatch.
|
|
type IEmptyStatement_Context interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SEMI() antlr.TerminalNode
|
|
|
|
// IsEmptyStatement_Context differentiates from other interfaces.
|
|
IsEmptyStatement_Context()
|
|
}
|
|
|
|
type EmptyStatement_Context struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyEmptyStatement_Context() *EmptyStatement_Context {
|
|
var p = new(EmptyStatement_Context)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_emptyStatement_
|
|
return p
|
|
}
|
|
|
|
func InitEmptyEmptyStatement_Context(p *EmptyStatement_Context) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_emptyStatement_
|
|
}
|
|
|
|
func (*EmptyStatement_Context) IsEmptyStatement_Context() {}
|
|
|
|
func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context {
|
|
var p = new(EmptyStatement_Context)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_emptyStatement_
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *EmptyStatement_Context) SEMI() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEMI, 0)
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterEmptyStatement_(s)
|
|
}
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitEmptyStatement_(s)
|
|
}
|
|
}
|
|
|
|
func (s *EmptyStatement_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitEmptyStatement_(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) EmptyStatement_() (localctx IEmptyStatement_Context) {
|
|
localctx = NewEmptyStatement_Context(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 6, MySqlParserRULE_emptyStatement_)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(765)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDdlStatementContext is an interface to support dynamic dispatch.
|
|
type IDdlStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CreateDatabase() ICreateDatabaseContext
|
|
CreateEvent() ICreateEventContext
|
|
CreateIndex() ICreateIndexContext
|
|
CreateLogfileGroup() ICreateLogfileGroupContext
|
|
CreateProcedure() ICreateProcedureContext
|
|
CreateFunction() ICreateFunctionContext
|
|
CreateServer() ICreateServerContext
|
|
CreateTable() ICreateTableContext
|
|
CreateTablespaceInnodb() ICreateTablespaceInnodbContext
|
|
CreateTablespaceNdb() ICreateTablespaceNdbContext
|
|
CreateTrigger() ICreateTriggerContext
|
|
CreateView() ICreateViewContext
|
|
CreateRole() ICreateRoleContext
|
|
AlterDatabase() IAlterDatabaseContext
|
|
AlterEvent() IAlterEventContext
|
|
AlterFunction() IAlterFunctionContext
|
|
AlterInstance() IAlterInstanceContext
|
|
AlterLogfileGroup() IAlterLogfileGroupContext
|
|
AlterProcedure() IAlterProcedureContext
|
|
AlterServer() IAlterServerContext
|
|
AlterTable() IAlterTableContext
|
|
AlterTablespace() IAlterTablespaceContext
|
|
AlterView() IAlterViewContext
|
|
DropDatabase() IDropDatabaseContext
|
|
DropEvent() IDropEventContext
|
|
DropIndex() IDropIndexContext
|
|
DropLogfileGroup() IDropLogfileGroupContext
|
|
DropProcedure() IDropProcedureContext
|
|
DropFunction() IDropFunctionContext
|
|
DropServer() IDropServerContext
|
|
DropTable() IDropTableContext
|
|
DropTablespace() IDropTablespaceContext
|
|
DropTrigger() IDropTriggerContext
|
|
DropView() IDropViewContext
|
|
DropRole() IDropRoleContext
|
|
SetRole() ISetRoleContext
|
|
RenameTable() IRenameTableContext
|
|
TruncateTable() ITruncateTableContext
|
|
|
|
// IsDdlStatementContext differentiates from other interfaces.
|
|
IsDdlStatementContext()
|
|
}
|
|
|
|
type DdlStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDdlStatementContext() *DdlStatementContext {
|
|
var p = new(DdlStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ddlStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDdlStatementContext(p *DdlStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ddlStatement
|
|
}
|
|
|
|
func (*DdlStatementContext) IsDdlStatementContext() {}
|
|
|
|
func NewDdlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DdlStatementContext {
|
|
var p = new(DdlStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_ddlStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DdlStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DdlStatementContext) CreateDatabase() ICreateDatabaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDatabaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDatabaseContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateEvent() ICreateEventContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateEventContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateEventContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateIndex() ICreateIndexContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateIndexContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateIndexContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateLogfileGroup() ICreateLogfileGroupContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateLogfileGroupContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateLogfileGroupContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateProcedure() ICreateProcedureContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateProcedureContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateProcedureContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateFunction() ICreateFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateFunctionContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateServer() ICreateServerContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateServerContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateServerContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateTable() ICreateTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateTableContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateTablespaceInnodb() ICreateTablespaceInnodbContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateTablespaceInnodbContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateTablespaceInnodbContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateTablespaceNdb() ICreateTablespaceNdbContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateTablespaceNdbContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateTablespaceNdbContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateTrigger() ICreateTriggerContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateTriggerContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateTriggerContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateView() ICreateViewContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateViewContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateViewContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) CreateRole() ICreateRoleContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateRoleContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateRoleContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterDatabase() IAlterDatabaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterDatabaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterDatabaseContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterEvent() IAlterEventContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterEventContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterEventContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterFunction() IAlterFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterFunctionContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterInstance() IAlterInstanceContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterInstanceContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterInstanceContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterLogfileGroup() IAlterLogfileGroupContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterLogfileGroupContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterLogfileGroupContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterProcedure() IAlterProcedureContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterProcedureContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterProcedureContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterServer() IAlterServerContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterServerContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterServerContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterTable() IAlterTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterTableContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterTablespace() IAlterTablespaceContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterTablespaceContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterTablespaceContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) AlterView() IAlterViewContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterViewContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterViewContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropDatabase() IDropDatabaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropDatabaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropDatabaseContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropEvent() IDropEventContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropEventContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropEventContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropIndex() IDropIndexContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropIndexContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropIndexContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropLogfileGroup() IDropLogfileGroupContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropLogfileGroupContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropLogfileGroupContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropProcedure() IDropProcedureContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropProcedureContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropProcedureContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropFunction() IDropFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropFunctionContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropServer() IDropServerContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropServerContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropServerContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropTable() IDropTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropTableContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropTablespace() IDropTablespaceContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropTablespaceContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropTablespaceContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropTrigger() IDropTriggerContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropTriggerContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropTriggerContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropView() IDropViewContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropViewContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropViewContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) DropRole() IDropRoleContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropRoleContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropRoleContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) SetRole() ISetRoleContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISetRoleContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISetRoleContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) RenameTable() IRenameTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRenameTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRenameTableContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) TruncateTable() ITruncateTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITruncateTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITruncateTableContext)
|
|
}
|
|
|
|
func (s *DdlStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DdlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DdlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDdlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DdlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDdlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DdlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDdlStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DdlStatement() (localctx IDdlStatementContext) {
|
|
localctx = NewDdlStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 8, MySqlParserRULE_ddlStatement)
|
|
p.SetState(805)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(767)
|
|
p.CreateDatabase()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(768)
|
|
p.CreateEvent()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(769)
|
|
p.CreateIndex()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(770)
|
|
p.CreateLogfileGroup()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(771)
|
|
p.CreateProcedure()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(772)
|
|
p.CreateFunction()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(773)
|
|
p.CreateServer()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(774)
|
|
p.CreateTable()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(775)
|
|
p.CreateTablespaceInnodb()
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(776)
|
|
p.CreateTablespaceNdb()
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(777)
|
|
p.CreateTrigger()
|
|
}
|
|
|
|
case 12:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(778)
|
|
p.CreateView()
|
|
}
|
|
|
|
case 13:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(779)
|
|
p.CreateRole()
|
|
}
|
|
|
|
case 14:
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(780)
|
|
p.AlterDatabase()
|
|
}
|
|
|
|
case 15:
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(781)
|
|
p.AlterEvent()
|
|
}
|
|
|
|
case 16:
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(782)
|
|
p.AlterFunction()
|
|
}
|
|
|
|
case 17:
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(783)
|
|
p.AlterInstance()
|
|
}
|
|
|
|
case 18:
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(784)
|
|
p.AlterLogfileGroup()
|
|
}
|
|
|
|
case 19:
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(785)
|
|
p.AlterProcedure()
|
|
}
|
|
|
|
case 20:
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(786)
|
|
p.AlterServer()
|
|
}
|
|
|
|
case 21:
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(787)
|
|
p.AlterTable()
|
|
}
|
|
|
|
case 22:
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(788)
|
|
p.AlterTablespace()
|
|
}
|
|
|
|
case 23:
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(789)
|
|
p.AlterView()
|
|
}
|
|
|
|
case 24:
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(790)
|
|
p.DropDatabase()
|
|
}
|
|
|
|
case 25:
|
|
p.EnterOuterAlt(localctx, 25)
|
|
{
|
|
p.SetState(791)
|
|
p.DropEvent()
|
|
}
|
|
|
|
case 26:
|
|
p.EnterOuterAlt(localctx, 26)
|
|
{
|
|
p.SetState(792)
|
|
p.DropIndex()
|
|
}
|
|
|
|
case 27:
|
|
p.EnterOuterAlt(localctx, 27)
|
|
{
|
|
p.SetState(793)
|
|
p.DropLogfileGroup()
|
|
}
|
|
|
|
case 28:
|
|
p.EnterOuterAlt(localctx, 28)
|
|
{
|
|
p.SetState(794)
|
|
p.DropProcedure()
|
|
}
|
|
|
|
case 29:
|
|
p.EnterOuterAlt(localctx, 29)
|
|
{
|
|
p.SetState(795)
|
|
p.DropFunction()
|
|
}
|
|
|
|
case 30:
|
|
p.EnterOuterAlt(localctx, 30)
|
|
{
|
|
p.SetState(796)
|
|
p.DropServer()
|
|
}
|
|
|
|
case 31:
|
|
p.EnterOuterAlt(localctx, 31)
|
|
{
|
|
p.SetState(797)
|
|
p.DropTable()
|
|
}
|
|
|
|
case 32:
|
|
p.EnterOuterAlt(localctx, 32)
|
|
{
|
|
p.SetState(798)
|
|
p.DropTablespace()
|
|
}
|
|
|
|
case 33:
|
|
p.EnterOuterAlt(localctx, 33)
|
|
{
|
|
p.SetState(799)
|
|
p.DropTrigger()
|
|
}
|
|
|
|
case 34:
|
|
p.EnterOuterAlt(localctx, 34)
|
|
{
|
|
p.SetState(800)
|
|
p.DropView()
|
|
}
|
|
|
|
case 35:
|
|
p.EnterOuterAlt(localctx, 35)
|
|
{
|
|
p.SetState(801)
|
|
p.DropRole()
|
|
}
|
|
|
|
case 36:
|
|
p.EnterOuterAlt(localctx, 36)
|
|
{
|
|
p.SetState(802)
|
|
p.SetRole()
|
|
}
|
|
|
|
case 37:
|
|
p.EnterOuterAlt(localctx, 37)
|
|
{
|
|
p.SetState(803)
|
|
p.RenameTable()
|
|
}
|
|
|
|
case 38:
|
|
p.EnterOuterAlt(localctx, 38)
|
|
{
|
|
p.SetState(804)
|
|
p.TruncateTable()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDmlStatementContext is an interface to support dynamic dispatch.
|
|
type IDmlStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SelectStatement() ISelectStatementContext
|
|
InsertStatement() IInsertStatementContext
|
|
UpdateStatement() IUpdateStatementContext
|
|
DeleteStatement() IDeleteStatementContext
|
|
ReplaceStatement() IReplaceStatementContext
|
|
CallStatement() ICallStatementContext
|
|
LoadDataStatement() ILoadDataStatementContext
|
|
LoadXmlStatement() ILoadXmlStatementContext
|
|
DoStatement() IDoStatementContext
|
|
HandlerStatement() IHandlerStatementContext
|
|
ValuesStatement() IValuesStatementContext
|
|
WithStatement() IWithStatementContext
|
|
TableStatement() ITableStatementContext
|
|
|
|
// IsDmlStatementContext differentiates from other interfaces.
|
|
IsDmlStatementContext()
|
|
}
|
|
|
|
type DmlStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDmlStatementContext() *DmlStatementContext {
|
|
var p = new(DmlStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dmlStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDmlStatementContext(p *DmlStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dmlStatement
|
|
}
|
|
|
|
func (*DmlStatementContext) IsDmlStatementContext() {}
|
|
|
|
func NewDmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DmlStatementContext {
|
|
var p = new(DmlStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dmlStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DmlStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DmlStatementContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) InsertStatement() IInsertStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IInsertStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IInsertStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) UpdateStatement() IUpdateStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdateStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdateStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) DeleteStatement() IDeleteStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeleteStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeleteStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) ReplaceStatement() IReplaceStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReplaceStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReplaceStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) CallStatement() ICallStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICallStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICallStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) LoadDataStatement() ILoadDataStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILoadDataStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILoadDataStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) LoadXmlStatement() ILoadXmlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILoadXmlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILoadXmlStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) DoStatement() IDoStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDoStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDoStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) HandlerStatement() IHandlerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) ValuesStatement() IValuesStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IValuesStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IValuesStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) WithStatement() IWithStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWithStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWithStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) TableStatement() ITableStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableStatementContext)
|
|
}
|
|
|
|
func (s *DmlStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DmlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDmlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DmlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDmlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DmlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDmlStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DmlStatement() (localctx IDmlStatementContext) {
|
|
localctx = NewDmlStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 10, MySqlParserRULE_dmlStatement)
|
|
p.SetState(820)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 11, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(807)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(808)
|
|
p.InsertStatement()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(809)
|
|
p.UpdateStatement()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(810)
|
|
p.DeleteStatement()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(811)
|
|
p.ReplaceStatement()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(812)
|
|
p.CallStatement()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(813)
|
|
p.LoadDataStatement()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(814)
|
|
p.LoadXmlStatement()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(815)
|
|
p.DoStatement()
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(816)
|
|
p.HandlerStatement()
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(817)
|
|
p.ValuesStatement()
|
|
}
|
|
|
|
case 12:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(818)
|
|
p.WithStatement()
|
|
}
|
|
|
|
case 13:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(819)
|
|
p.TableStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITransactionStatementContext is an interface to support dynamic dispatch.
|
|
type ITransactionStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
StartTransaction() IStartTransactionContext
|
|
BeginWork() IBeginWorkContext
|
|
CommitWork() ICommitWorkContext
|
|
RollbackWork() IRollbackWorkContext
|
|
SavepointStatement() ISavepointStatementContext
|
|
RollbackStatement() IRollbackStatementContext
|
|
ReleaseStatement() IReleaseStatementContext
|
|
LockTables() ILockTablesContext
|
|
UnlockTables() IUnlockTablesContext
|
|
|
|
// IsTransactionStatementContext differentiates from other interfaces.
|
|
IsTransactionStatementContext()
|
|
}
|
|
|
|
type TransactionStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTransactionStatementContext() *TransactionStatementContext {
|
|
var p = new(TransactionStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTransactionStatementContext(p *TransactionStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionStatement
|
|
}
|
|
|
|
func (*TransactionStatementContext) IsTransactionStatementContext() {}
|
|
|
|
func NewTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionStatementContext {
|
|
var p = new(TransactionStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_transactionStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TransactionStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TransactionStatementContext) StartTransaction() IStartTransactionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStartTransactionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStartTransactionContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) BeginWork() IBeginWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBeginWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBeginWorkContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) CommitWork() ICommitWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICommitWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICommitWorkContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) RollbackWork() IRollbackWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRollbackWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRollbackWorkContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) SavepointStatement() ISavepointStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISavepointStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISavepointStatementContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) RollbackStatement() IRollbackStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRollbackStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRollbackStatementContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) ReleaseStatement() IReleaseStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReleaseStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReleaseStatementContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) LockTables() ILockTablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockTablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockTablesContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) UnlockTables() IUnlockTablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnlockTablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnlockTablesContext)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TransactionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTransactionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTransactionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTransactionStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TransactionStatement() (localctx ITransactionStatementContext) {
|
|
localctx = NewTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 12, MySqlParserRULE_transactionStatement)
|
|
p.SetState(831)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(822)
|
|
p.StartTransaction()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(823)
|
|
p.BeginWork()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(824)
|
|
p.CommitWork()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(825)
|
|
p.RollbackWork()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(826)
|
|
p.SavepointStatement()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(827)
|
|
p.RollbackStatement()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(828)
|
|
p.ReleaseStatement()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(829)
|
|
p.LockTables()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(830)
|
|
p.UnlockTables()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReplicationStatementContext is an interface to support dynamic dispatch.
|
|
type IReplicationStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ChangeMaster() IChangeMasterContext
|
|
ChangeReplicationFilter() IChangeReplicationFilterContext
|
|
PurgeBinaryLogs() IPurgeBinaryLogsContext
|
|
ResetMaster() IResetMasterContext
|
|
ResetSlave() IResetSlaveContext
|
|
StartSlave() IStartSlaveContext
|
|
StopSlave() IStopSlaveContext
|
|
StartGroupReplication() IStartGroupReplicationContext
|
|
StopGroupReplication() IStopGroupReplicationContext
|
|
XaStartTransaction() IXaStartTransactionContext
|
|
XaEndTransaction() IXaEndTransactionContext
|
|
XaPrepareStatement() IXaPrepareStatementContext
|
|
XaCommitWork() IXaCommitWorkContext
|
|
XaRollbackWork() IXaRollbackWorkContext
|
|
XaRecoverWork() IXaRecoverWorkContext
|
|
|
|
// IsReplicationStatementContext differentiates from other interfaces.
|
|
IsReplicationStatementContext()
|
|
}
|
|
|
|
type ReplicationStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyReplicationStatementContext() *ReplicationStatementContext {
|
|
var p = new(ReplicationStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replicationStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReplicationStatementContext(p *ReplicationStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replicationStatement
|
|
}
|
|
|
|
func (*ReplicationStatementContext) IsReplicationStatementContext() {}
|
|
|
|
func NewReplicationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationStatementContext {
|
|
var p = new(ReplicationStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_replicationStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReplicationStatementContext) ChangeMaster() IChangeMasterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChangeMasterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChangeMasterContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) ChangeReplicationFilter() IChangeReplicationFilterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChangeReplicationFilterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChangeReplicationFilterContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) PurgeBinaryLogs() IPurgeBinaryLogsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPurgeBinaryLogsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPurgeBinaryLogsContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) ResetMaster() IResetMasterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IResetMasterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IResetMasterContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) ResetSlave() IResetSlaveContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IResetSlaveContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IResetSlaveContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) StartSlave() IStartSlaveContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStartSlaveContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStartSlaveContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) StopSlave() IStopSlaveContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStopSlaveContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStopSlaveContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) StartGroupReplication() IStartGroupReplicationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStartGroupReplicationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStartGroupReplicationContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) StopGroupReplication() IStopGroupReplicationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStopGroupReplicationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStopGroupReplicationContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaStartTransaction() IXaStartTransactionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaStartTransactionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaStartTransactionContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaEndTransaction() IXaEndTransactionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaEndTransactionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaEndTransactionContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaPrepareStatement() IXaPrepareStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaPrepareStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaPrepareStatementContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaCommitWork() IXaCommitWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaCommitWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaCommitWorkContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaRollbackWork() IXaRollbackWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaRollbackWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaRollbackWorkContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) XaRecoverWork() IXaRecoverWorkContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXaRecoverWorkContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXaRecoverWorkContext)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReplicationStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReplicationStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReplicationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReplicationStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReplicationStatement() (localctx IReplicationStatementContext) {
|
|
localctx = NewReplicationStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 14, MySqlParserRULE_replicationStatement)
|
|
p.SetState(848)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(833)
|
|
p.ChangeMaster()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(834)
|
|
p.ChangeReplicationFilter()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(835)
|
|
p.PurgeBinaryLogs()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(836)
|
|
p.ResetMaster()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(837)
|
|
p.ResetSlave()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(838)
|
|
p.StartSlave()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(839)
|
|
p.StopSlave()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(840)
|
|
p.StartGroupReplication()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(841)
|
|
p.StopGroupReplication()
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(842)
|
|
p.XaStartTransaction()
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(843)
|
|
p.XaEndTransaction()
|
|
}
|
|
|
|
case 12:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(844)
|
|
p.XaPrepareStatement()
|
|
}
|
|
|
|
case 13:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(845)
|
|
p.XaCommitWork()
|
|
}
|
|
|
|
case 14:
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(846)
|
|
p.XaRollbackWork()
|
|
}
|
|
|
|
case 15:
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(847)
|
|
p.XaRecoverWork()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPreparedStatementContext is an interface to support dynamic dispatch.
|
|
type IPreparedStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
PrepareStatement() IPrepareStatementContext
|
|
ExecuteStatement() IExecuteStatementContext
|
|
DeallocatePrepare() IDeallocatePrepareContext
|
|
|
|
// IsPreparedStatementContext differentiates from other interfaces.
|
|
IsPreparedStatementContext()
|
|
}
|
|
|
|
type PreparedStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPreparedStatementContext() *PreparedStatementContext {
|
|
var p = new(PreparedStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_preparedStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPreparedStatementContext(p *PreparedStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_preparedStatement
|
|
}
|
|
|
|
func (*PreparedStatementContext) IsPreparedStatementContext() {}
|
|
|
|
func NewPreparedStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparedStatementContext {
|
|
var p = new(PreparedStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_preparedStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PreparedStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PreparedStatementContext) PrepareStatement() IPrepareStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrepareStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrepareStatementContext)
|
|
}
|
|
|
|
func (s *PreparedStatementContext) ExecuteStatement() IExecuteStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExecuteStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExecuteStatementContext)
|
|
}
|
|
|
|
func (s *PreparedStatementContext) DeallocatePrepare() IDeallocatePrepareContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeallocatePrepareContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeallocatePrepareContext)
|
|
}
|
|
|
|
func (s *PreparedStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PreparedStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PreparedStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPreparedStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *PreparedStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPreparedStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *PreparedStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPreparedStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PreparedStatement() (localctx IPreparedStatementContext) {
|
|
localctx = NewPreparedStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 16, MySqlParserRULE_preparedStatement)
|
|
p.SetState(853)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserPREPARE:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(850)
|
|
p.PrepareStatement()
|
|
}
|
|
|
|
case MySqlParserEXECUTE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(851)
|
|
p.ExecuteStatement()
|
|
}
|
|
|
|
case MySqlParserDROP, MySqlParserDEALLOCATE:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(852)
|
|
p.DeallocatePrepare()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICompoundStatementContext is an interface to support dynamic dispatch.
|
|
type ICompoundStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BlockStatement() IBlockStatementContext
|
|
CaseStatement() ICaseStatementContext
|
|
IfStatement() IIfStatementContext
|
|
LeaveStatement() ILeaveStatementContext
|
|
LoopStatement() ILoopStatementContext
|
|
RepeatStatement() IRepeatStatementContext
|
|
WhileStatement() IWhileStatementContext
|
|
IterateStatement() IIterateStatementContext
|
|
ReturnStatement() IReturnStatementContext
|
|
CursorStatement() ICursorStatementContext
|
|
WithStatement() IWithStatementContext
|
|
DmlStatement() IDmlStatementContext
|
|
|
|
// IsCompoundStatementContext differentiates from other interfaces.
|
|
IsCompoundStatementContext()
|
|
}
|
|
|
|
type CompoundStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCompoundStatementContext() *CompoundStatementContext {
|
|
var p = new(CompoundStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_compoundStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCompoundStatementContext(p *CompoundStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_compoundStatement
|
|
}
|
|
|
|
func (*CompoundStatementContext) IsCompoundStatementContext() {}
|
|
|
|
func NewCompoundStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundStatementContext {
|
|
var p = new(CompoundStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_compoundStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CompoundStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CompoundStatementContext) BlockStatement() IBlockStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBlockStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBlockStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) CaseStatement() ICaseStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICaseStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICaseStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) IfStatement() IIfStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) LeaveStatement() ILeaveStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILeaveStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILeaveStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) LoopStatement() ILoopStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILoopStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILoopStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) RepeatStatement() IRepeatStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRepeatStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRepeatStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) WhileStatement() IWhileStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWhileStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWhileStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) IterateStatement() IIterateStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIterateStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIterateStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) ReturnStatement() IReturnStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReturnStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReturnStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) CursorStatement() ICursorStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICursorStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICursorStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) WithStatement() IWithStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWithStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWithStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) DmlStatement() IDmlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDmlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDmlStatementContext)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CompoundStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CompoundStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCompoundStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CompoundStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCompoundStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CompoundStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCompoundStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CompoundStatement() (localctx ICompoundStatementContext) {
|
|
localctx = NewCompoundStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 18, MySqlParserRULE_compoundStatement)
|
|
p.SetState(868)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(855)
|
|
p.BlockStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(856)
|
|
p.CaseStatement()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(857)
|
|
p.IfStatement()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(858)
|
|
p.LeaveStatement()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(859)
|
|
p.LoopStatement()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(860)
|
|
p.RepeatStatement()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(861)
|
|
p.WhileStatement()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(862)
|
|
p.IterateStatement()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(863)
|
|
p.ReturnStatement()
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(864)
|
|
p.CursorStatement()
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(865)
|
|
p.WithStatement()
|
|
}
|
|
{
|
|
p.SetState(866)
|
|
p.DmlStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAdministrationStatementContext is an interface to support dynamic dispatch.
|
|
type IAdministrationStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AlterUser() IAlterUserContext
|
|
CreateUser() ICreateUserContext
|
|
DropUser() IDropUserContext
|
|
GrantStatement() IGrantStatementContext
|
|
GrantProxy() IGrantProxyContext
|
|
RenameUser() IRenameUserContext
|
|
RevokeStatement() IRevokeStatementContext
|
|
RevokeProxy() IRevokeProxyContext
|
|
AnalyzeTable() IAnalyzeTableContext
|
|
CheckTable() ICheckTableContext
|
|
ChecksumTable() IChecksumTableContext
|
|
OptimizeTable() IOptimizeTableContext
|
|
RepairTable() IRepairTableContext
|
|
CreateUdfunction() ICreateUdfunctionContext
|
|
InstallPlugin() IInstallPluginContext
|
|
UninstallPlugin() IUninstallPluginContext
|
|
SetStatement() ISetStatementContext
|
|
ShowStatement() IShowStatementContext
|
|
BinlogStatement() IBinlogStatementContext
|
|
CacheIndexStatement() ICacheIndexStatementContext
|
|
FlushStatement() IFlushStatementContext
|
|
KillStatement() IKillStatementContext
|
|
LoadIndexIntoCache() ILoadIndexIntoCacheContext
|
|
ResetStatement() IResetStatementContext
|
|
ShutdownStatement() IShutdownStatementContext
|
|
|
|
// IsAdministrationStatementContext differentiates from other interfaces.
|
|
IsAdministrationStatementContext()
|
|
}
|
|
|
|
type AdministrationStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAdministrationStatementContext() *AdministrationStatementContext {
|
|
var p = new(AdministrationStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_administrationStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAdministrationStatementContext(p *AdministrationStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_administrationStatement
|
|
}
|
|
|
|
func (*AdministrationStatementContext) IsAdministrationStatementContext() {}
|
|
|
|
func NewAdministrationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdministrationStatementContext {
|
|
var p = new(AdministrationStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_administrationStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AdministrationStatementContext) AlterUser() IAlterUserContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterUserContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterUserContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) CreateUser() ICreateUserContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateUserContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateUserContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) DropUser() IDropUserContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDropUserContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDropUserContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) GrantStatement() IGrantStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGrantStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGrantStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) GrantProxy() IGrantProxyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGrantProxyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGrantProxyContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) RenameUser() IRenameUserContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRenameUserContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRenameUserContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) RevokeStatement() IRevokeStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRevokeStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRevokeStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) RevokeProxy() IRevokeProxyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRevokeProxyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRevokeProxyContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) AnalyzeTable() IAnalyzeTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAnalyzeTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAnalyzeTableContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) CheckTable() ICheckTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICheckTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICheckTableContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ChecksumTable() IChecksumTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChecksumTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChecksumTableContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) OptimizeTable() IOptimizeTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOptimizeTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOptimizeTableContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) RepairTable() IRepairTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRepairTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRepairTableContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) CreateUdfunction() ICreateUdfunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateUdfunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateUdfunctionContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) InstallPlugin() IInstallPluginContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IInstallPluginContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IInstallPluginContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) UninstallPlugin() IUninstallPluginContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUninstallPluginContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUninstallPluginContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) SetStatement() ISetStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISetStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISetStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ShowStatement() IShowStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) BinlogStatement() IBinlogStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBinlogStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBinlogStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) CacheIndexStatement() ICacheIndexStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICacheIndexStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICacheIndexStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) FlushStatement() IFlushStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFlushStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFlushStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) KillStatement() IKillStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IKillStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IKillStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) LoadIndexIntoCache() ILoadIndexIntoCacheContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILoadIndexIntoCacheContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILoadIndexIntoCacheContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ResetStatement() IResetStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IResetStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IResetStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ShutdownStatement() IShutdownStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShutdownStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShutdownStatementContext)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAdministrationStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAdministrationStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *AdministrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAdministrationStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AdministrationStatement() (localctx IAdministrationStatementContext) {
|
|
localctx = NewAdministrationStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 20, MySqlParserRULE_administrationStatement)
|
|
p.SetState(895)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(870)
|
|
p.AlterUser()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(871)
|
|
p.CreateUser()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(872)
|
|
p.DropUser()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(873)
|
|
p.GrantStatement()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(874)
|
|
p.GrantProxy()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(875)
|
|
p.RenameUser()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(876)
|
|
p.RevokeStatement()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(877)
|
|
p.RevokeProxy()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(878)
|
|
p.AnalyzeTable()
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(879)
|
|
p.CheckTable()
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(880)
|
|
p.ChecksumTable()
|
|
}
|
|
|
|
case 12:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(881)
|
|
p.OptimizeTable()
|
|
}
|
|
|
|
case 13:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(882)
|
|
p.RepairTable()
|
|
}
|
|
|
|
case 14:
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(883)
|
|
p.CreateUdfunction()
|
|
}
|
|
|
|
case 15:
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(884)
|
|
p.InstallPlugin()
|
|
}
|
|
|
|
case 16:
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(885)
|
|
p.UninstallPlugin()
|
|
}
|
|
|
|
case 17:
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(886)
|
|
p.SetStatement()
|
|
}
|
|
|
|
case 18:
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(887)
|
|
p.ShowStatement()
|
|
}
|
|
|
|
case 19:
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(888)
|
|
p.BinlogStatement()
|
|
}
|
|
|
|
case 20:
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(889)
|
|
p.CacheIndexStatement()
|
|
}
|
|
|
|
case 21:
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(890)
|
|
p.FlushStatement()
|
|
}
|
|
|
|
case 22:
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(891)
|
|
p.KillStatement()
|
|
}
|
|
|
|
case 23:
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(892)
|
|
p.LoadIndexIntoCache()
|
|
}
|
|
|
|
case 24:
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(893)
|
|
p.ResetStatement()
|
|
}
|
|
|
|
case 25:
|
|
p.EnterOuterAlt(localctx, 25)
|
|
{
|
|
p.SetState(894)
|
|
p.ShutdownStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUtilityStatementContext is an interface to support dynamic dispatch.
|
|
type IUtilityStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SimpleDescribeStatement() ISimpleDescribeStatementContext
|
|
FullDescribeStatement() IFullDescribeStatementContext
|
|
HelpStatement() IHelpStatementContext
|
|
UseStatement() IUseStatementContext
|
|
SignalStatement() ISignalStatementContext
|
|
ResignalStatement() IResignalStatementContext
|
|
DiagnosticsStatement() IDiagnosticsStatementContext
|
|
|
|
// IsUtilityStatementContext differentiates from other interfaces.
|
|
IsUtilityStatementContext()
|
|
}
|
|
|
|
type UtilityStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUtilityStatementContext() *UtilityStatementContext {
|
|
var p = new(UtilityStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_utilityStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUtilityStatementContext(p *UtilityStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_utilityStatement
|
|
}
|
|
|
|
func (*UtilityStatementContext) IsUtilityStatementContext() {}
|
|
|
|
func NewUtilityStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UtilityStatementContext {
|
|
var p = new(UtilityStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_utilityStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UtilityStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UtilityStatementContext) SimpleDescribeStatement() ISimpleDescribeStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleDescribeStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleDescribeStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) FullDescribeStatement() IFullDescribeStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullDescribeStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullDescribeStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) HelpStatement() IHelpStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHelpStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHelpStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) UseStatement() IUseStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUseStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUseStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) SignalStatement() ISignalStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISignalStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISignalStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) ResignalStatement() IResignalStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IResignalStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IResignalStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) DiagnosticsStatement() IDiagnosticsStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDiagnosticsStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDiagnosticsStatementContext)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UtilityStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UtilityStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUtilityStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UtilityStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUtilityStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UtilityStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUtilityStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UtilityStatement() (localctx IUtilityStatementContext) {
|
|
localctx = NewUtilityStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 22, MySqlParserRULE_utilityStatement)
|
|
p.SetState(904)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(897)
|
|
p.SimpleDescribeStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(898)
|
|
p.FullDescribeStatement()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(899)
|
|
p.HelpStatement()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(900)
|
|
p.UseStatement()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(901)
|
|
p.SignalStatement()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(902)
|
|
p.ResignalStatement()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(903)
|
|
p.DiagnosticsStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateDatabaseContext is an interface to support dynamic dispatch.
|
|
type ICreateDatabaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDbFormat returns the dbFormat token.
|
|
GetDbFormat() antlr.Token
|
|
|
|
// SetDbFormat sets the dbFormat token.
|
|
SetDbFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
DATABASE() antlr.TerminalNode
|
|
SCHEMA() antlr.TerminalNode
|
|
IfNotExists() IIfNotExistsContext
|
|
AllCreateDatabaseOption() []ICreateDatabaseOptionContext
|
|
CreateDatabaseOption(i int) ICreateDatabaseOptionContext
|
|
|
|
// IsCreateDatabaseContext differentiates from other interfaces.
|
|
IsCreateDatabaseContext()
|
|
}
|
|
|
|
type CreateDatabaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
dbFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateDatabaseContext() *CreateDatabaseContext {
|
|
var p = new(CreateDatabaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDatabase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateDatabaseContext(p *CreateDatabaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDatabase
|
|
}
|
|
|
|
func (*CreateDatabaseContext) IsCreateDatabaseContext() {}
|
|
|
|
func NewCreateDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDatabaseContext {
|
|
var p = new(CreateDatabaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createDatabase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat }
|
|
|
|
func (s *CreateDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v }
|
|
|
|
func (s *CreateDatabaseContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) AllCreateDatabaseOption() []ICreateDatabaseOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICreateDatabaseOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
tst[i] = t.(ICreateDatabaseOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) CreateDatabaseOption(i int) ICreateDatabaseOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDatabaseOptionContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateDatabase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateDatabase() (localctx ICreateDatabaseContext) {
|
|
localctx = NewCreateDatabaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 24, MySqlParserRULE_createDatabase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(906)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(907)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateDatabaseContext).dbFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateDatabaseContext).dbFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(909)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(908)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(911)
|
|
p.Uid()
|
|
}
|
|
p.SetState(915)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4398214283264) != 0) || _la == MySqlParserREAD || _la == MySqlParserCHAR || _la == MySqlParserENCRYPTION || _la == MySqlParserCHARSET {
|
|
{
|
|
p.SetState(912)
|
|
p.CreateDatabaseOption()
|
|
}
|
|
|
|
p.SetState(917)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateEventContext is an interface to support dynamic dispatch.
|
|
type ICreateEventContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
EVENT() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
AllON() []antlr.TerminalNode
|
|
ON(i int) antlr.TerminalNode
|
|
SCHEDULE() antlr.TerminalNode
|
|
ScheduleExpression() IScheduleExpressionContext
|
|
DO() antlr.TerminalNode
|
|
RoutineBody() IRoutineBodyContext
|
|
OwnerStatement() IOwnerStatementContext
|
|
IfNotExists() IIfNotExistsContext
|
|
COMPLETION() antlr.TerminalNode
|
|
PRESERVE() antlr.TerminalNode
|
|
EnableType() IEnableTypeContext
|
|
COMMENT() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
NOT() antlr.TerminalNode
|
|
|
|
// IsCreateEventContext differentiates from other interfaces.
|
|
IsCreateEventContext()
|
|
}
|
|
|
|
type CreateEventContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateEventContext() *CreateEventContext {
|
|
var p = new(CreateEventContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createEvent
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateEventContext(p *CreateEventContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createEvent
|
|
}
|
|
|
|
func (*CreateEventContext) IsCreateEventContext() {}
|
|
|
|
func NewCreateEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateEventContext {
|
|
var p = new(CreateEventContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createEvent
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateEventContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateEventContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *CreateEventContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *CreateEventContext) SCHEDULE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEDULE, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) ScheduleExpression() IScheduleExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IScheduleExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IScheduleExpressionContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) DO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDO, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) COMPLETION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPLETION, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) PRESERVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRESERVE, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) EnableType() IEnableTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEnableTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEnableTypeContext)
|
|
}
|
|
|
|
func (s *CreateEventContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *CreateEventContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateEventContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateEventContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateEvent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateEvent() (localctx ICreateEventContext) {
|
|
localctx = NewCreateEventContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 26, MySqlParserRULE_createEvent)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(918)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(920)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(919)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(922)
|
|
p.Match(MySqlParserEVENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(924)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(923)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(926)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(927)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(928)
|
|
p.Match(MySqlParserSCHEDULE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(929)
|
|
p.ScheduleExpression()
|
|
}
|
|
p.SetState(936)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserON {
|
|
{
|
|
p.SetState(930)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(931)
|
|
p.Match(MySqlParserCOMPLETION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(933)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(932)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(935)
|
|
p.Match(MySqlParserPRESERVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(939)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDISABLE || _la == MySqlParserENABLE {
|
|
{
|
|
p.SetState(938)
|
|
p.EnableType()
|
|
}
|
|
|
|
}
|
|
p.SetState(943)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMENT {
|
|
{
|
|
p.SetState(941)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(942)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(945)
|
|
p.Match(MySqlParserDO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(946)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateIndexContext is an interface to support dynamic dispatch.
|
|
type ICreateIndexContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIntimeAction returns the intimeAction token.
|
|
GetIntimeAction() antlr.Token
|
|
|
|
// GetIndexCategory returns the indexCategory token.
|
|
GetIndexCategory() antlr.Token
|
|
|
|
// GetAlgType returns the algType token.
|
|
GetAlgType() antlr.Token
|
|
|
|
// GetLockType returns the lockType token.
|
|
GetLockType() antlr.Token
|
|
|
|
// SetIntimeAction sets the intimeAction token.
|
|
SetIntimeAction(antlr.Token)
|
|
|
|
// SetIndexCategory sets the indexCategory token.
|
|
SetIndexCategory(antlr.Token)
|
|
|
|
// SetAlgType sets the algType token.
|
|
SetAlgType(antlr.Token)
|
|
|
|
// SetLockType sets the lockType token.
|
|
SetLockType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ON() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
IndexColumnNames() IIndexColumnNamesContext
|
|
IndexType() IIndexTypeContext
|
|
AllIndexOption() []IIndexOptionContext
|
|
IndexOption(i int) IIndexOptionContext
|
|
AllALGORITHM() []antlr.TerminalNode
|
|
ALGORITHM(i int) antlr.TerminalNode
|
|
AllLOCK() []antlr.TerminalNode
|
|
LOCK(i int) antlr.TerminalNode
|
|
ONLINE() antlr.TerminalNode
|
|
OFFLINE() antlr.TerminalNode
|
|
UNIQUE() antlr.TerminalNode
|
|
FULLTEXT() antlr.TerminalNode
|
|
SPATIAL() antlr.TerminalNode
|
|
AllDEFAULT() []antlr.TerminalNode
|
|
DEFAULT(i int) antlr.TerminalNode
|
|
AllINPLACE() []antlr.TerminalNode
|
|
INPLACE(i int) antlr.TerminalNode
|
|
AllCOPY() []antlr.TerminalNode
|
|
COPY(i int) antlr.TerminalNode
|
|
AllNONE() []antlr.TerminalNode
|
|
NONE(i int) antlr.TerminalNode
|
|
AllSHARED() []antlr.TerminalNode
|
|
SHARED(i int) antlr.TerminalNode
|
|
AllEXCLUSIVE() []antlr.TerminalNode
|
|
EXCLUSIVE(i int) antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
|
|
// IsCreateIndexContext differentiates from other interfaces.
|
|
IsCreateIndexContext()
|
|
}
|
|
|
|
type CreateIndexContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
intimeAction antlr.Token
|
|
indexCategory antlr.Token
|
|
algType antlr.Token
|
|
lockType antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateIndexContext() *CreateIndexContext {
|
|
var p = new(CreateIndexContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createIndex
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateIndexContext(p *CreateIndexContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createIndex
|
|
}
|
|
|
|
func (*CreateIndexContext) IsCreateIndexContext() {}
|
|
|
|
func NewCreateIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateIndexContext {
|
|
var p = new(CreateIndexContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createIndex
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateIndexContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateIndexContext) GetIntimeAction() antlr.Token { return s.intimeAction }
|
|
|
|
func (s *CreateIndexContext) GetIndexCategory() antlr.Token { return s.indexCategory }
|
|
|
|
func (s *CreateIndexContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *CreateIndexContext) GetLockType() antlr.Token { return s.lockType }
|
|
|
|
func (s *CreateIndexContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v }
|
|
|
|
func (s *CreateIndexContext) SetIndexCategory(v antlr.Token) { s.indexCategory = v }
|
|
|
|
func (s *CreateIndexContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *CreateIndexContext) SetLockType(v antlr.Token) { s.lockType = v }
|
|
|
|
func (s *CreateIndexContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateIndexContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *CreateIndexContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *CreateIndexContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateIndexContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllALGORITHM() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserALGORITHM)
|
|
}
|
|
|
|
func (s *CreateIndexContext) ALGORITHM(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllLOCK() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLOCK)
|
|
}
|
|
|
|
func (s *CreateIndexContext) LOCK(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) ONLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLINE, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) OFFLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFLINE, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) UNIQUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNIQUE, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) FULLTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULLTEXT, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) SPATIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSPATIAL, 0)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllDEFAULT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserDEFAULT)
|
|
}
|
|
|
|
func (s *CreateIndexContext) DEFAULT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllINPLACE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserINPLACE)
|
|
}
|
|
|
|
func (s *CreateIndexContext) INPLACE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINPLACE, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllCOPY() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOPY)
|
|
}
|
|
|
|
func (s *CreateIndexContext) COPY(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOPY, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllNONE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserNONE)
|
|
}
|
|
|
|
func (s *CreateIndexContext) NONE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllSHARED() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSHARED)
|
|
}
|
|
|
|
func (s *CreateIndexContext) SHARED(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARED, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllEXCLUSIVE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEXCLUSIVE)
|
|
}
|
|
|
|
func (s *CreateIndexContext) EXCLUSIVE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLUSIVE, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *CreateIndexContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *CreateIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateIndex() (localctx ICreateIndexContext) {
|
|
localctx = NewCreateIndexContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 28, MySqlParserRULE_createIndex)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(948)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(950)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOFFLINE || _la == MySqlParserONLINE {
|
|
{
|
|
p.SetState(949)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateIndexContext).intimeAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateIndexContext).intimeAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(953)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL || _la == MySqlParserUNIQUE {
|
|
{
|
|
p.SetState(952)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateIndexContext).indexCategory = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL || _la == MySqlParserUNIQUE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateIndexContext).indexCategory = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(955)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(956)
|
|
p.Uid()
|
|
}
|
|
p.SetState(958)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(957)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(960)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(961)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(962)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(966)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(963)
|
|
p.IndexOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(968)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(981)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(979)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALGORITHM:
|
|
{
|
|
p.SetState(969)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(971)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(970)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(973)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateIndexContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateIndexContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCK:
|
|
{
|
|
p.SetState(974)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(976)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(975)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(978)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateIndexContext).lockType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateIndexContext).lockType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(983)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateLogfileGroupContext is an interface to support dynamic dispatch.
|
|
type ICreateLogfileGroupContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetUndoFile returns the undoFile token.
|
|
GetUndoFile() antlr.Token
|
|
|
|
// GetComment returns the comment token.
|
|
GetComment() antlr.Token
|
|
|
|
// SetUndoFile sets the undoFile token.
|
|
SetUndoFile(antlr.Token)
|
|
|
|
// SetComment sets the comment token.
|
|
SetComment(antlr.Token)
|
|
|
|
// GetInitSize returns the initSize rule contexts.
|
|
GetInitSize() IFileSizeLiteralContext
|
|
|
|
// GetUndoSize returns the undoSize rule contexts.
|
|
GetUndoSize() IFileSizeLiteralContext
|
|
|
|
// GetRedoSize returns the redoSize rule contexts.
|
|
GetRedoSize() IFileSizeLiteralContext
|
|
|
|
// SetInitSize sets the initSize rule contexts.
|
|
SetInitSize(IFileSizeLiteralContext)
|
|
|
|
// SetUndoSize sets the undoSize rule contexts.
|
|
SetUndoSize(IFileSizeLiteralContext)
|
|
|
|
// SetRedoSize sets the redoSize rule contexts.
|
|
SetRedoSize(IFileSizeLiteralContext)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
LOGFILE() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
ADD() antlr.TerminalNode
|
|
UNDOFILE() antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
INITIAL_SIZE() antlr.TerminalNode
|
|
UNDO_BUFFER_SIZE() antlr.TerminalNode
|
|
REDO_BUFFER_SIZE() antlr.TerminalNode
|
|
NODEGROUP() antlr.TerminalNode
|
|
WAIT() antlr.TerminalNode
|
|
COMMENT() antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
AllFileSizeLiteral() []IFileSizeLiteralContext
|
|
FileSizeLiteral(i int) IFileSizeLiteralContext
|
|
|
|
// IsCreateLogfileGroupContext differentiates from other interfaces.
|
|
IsCreateLogfileGroupContext()
|
|
}
|
|
|
|
type CreateLogfileGroupContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
undoFile antlr.Token
|
|
initSize IFileSizeLiteralContext
|
|
undoSize IFileSizeLiteralContext
|
|
redoSize IFileSizeLiteralContext
|
|
comment antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateLogfileGroupContext() *CreateLogfileGroupContext {
|
|
var p = new(CreateLogfileGroupContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createLogfileGroup
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateLogfileGroupContext(p *CreateLogfileGroupContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createLogfileGroup
|
|
}
|
|
|
|
func (*CreateLogfileGroupContext) IsCreateLogfileGroupContext() {}
|
|
|
|
func NewCreateLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateLogfileGroupContext {
|
|
var p = new(CreateLogfileGroupContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createLogfileGroup
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateLogfileGroupContext) GetUndoFile() antlr.Token { return s.undoFile }
|
|
|
|
func (s *CreateLogfileGroupContext) GetComment() antlr.Token { return s.comment }
|
|
|
|
func (s *CreateLogfileGroupContext) SetUndoFile(v antlr.Token) { s.undoFile = v }
|
|
|
|
func (s *CreateLogfileGroupContext) SetComment(v antlr.Token) { s.comment = v }
|
|
|
|
func (s *CreateLogfileGroupContext) GetInitSize() IFileSizeLiteralContext { return s.initSize }
|
|
|
|
func (s *CreateLogfileGroupContext) GetUndoSize() IFileSizeLiteralContext { return s.undoSize }
|
|
|
|
func (s *CreateLogfileGroupContext) GetRedoSize() IFileSizeLiteralContext { return s.redoSize }
|
|
|
|
func (s *CreateLogfileGroupContext) SetInitSize(v IFileSizeLiteralContext) { s.initSize = v }
|
|
|
|
func (s *CreateLogfileGroupContext) SetUndoSize(v IFileSizeLiteralContext) { s.undoSize = v }
|
|
|
|
func (s *CreateLogfileGroupContext) SetRedoSize(v IFileSizeLiteralContext) { s.redoSize = v }
|
|
|
|
func (s *CreateLogfileGroupContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) LOGFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGFILE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) UNDOFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDOFILE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) INITIAL_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINITIAL_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) UNDO_BUFFER_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDO_BUFFER_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) REDO_BUFFER_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREDO_BUFFER_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) NODEGROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNODEGROUP, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) AllFileSizeLiteral() []IFileSizeLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFileSizeLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
tst[i] = t.(IFileSizeLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) FileSizeLiteral(i int) IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateLogfileGroup(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateLogfileGroup() (localctx ICreateLogfileGroupContext) {
|
|
localctx = NewCreateLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 30, MySqlParserRULE_createLogfileGroup)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(984)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(985)
|
|
p.Match(MySqlParserLOGFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(986)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(987)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(988)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(989)
|
|
p.Match(MySqlParserUNDOFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(990)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*CreateLogfileGroupContext).undoFile = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(996)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINITIAL_SIZE {
|
|
{
|
|
p.SetState(991)
|
|
p.Match(MySqlParserINITIAL_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(993)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(992)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(995)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateLogfileGroupContext).initSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1003)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUNDO_BUFFER_SIZE {
|
|
{
|
|
p.SetState(998)
|
|
p.Match(MySqlParserUNDO_BUFFER_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1000)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(999)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1002)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateLogfileGroupContext).undoSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1010)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserREDO_BUFFER_SIZE {
|
|
{
|
|
p.SetState(1005)
|
|
p.Match(MySqlParserREDO_BUFFER_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1007)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1006)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1009)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateLogfileGroupContext).redoSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1017)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNODEGROUP {
|
|
{
|
|
p.SetState(1012)
|
|
p.Match(MySqlParserNODEGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1014)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1013)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1016)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(1020)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(1019)
|
|
p.Match(MySqlParserWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1027)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMENT {
|
|
{
|
|
p.SetState(1022)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1024)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1023)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1026)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*CreateLogfileGroupContext).comment = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1029)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1031)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1030)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1033)
|
|
p.EngineName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateProcedureContext is an interface to support dynamic dispatch.
|
|
type ICreateProcedureContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
PROCEDURE() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
RoutineBody() IRoutineBodyContext
|
|
OwnerStatement() IOwnerStatementContext
|
|
AllProcedureParameter() []IProcedureParameterContext
|
|
ProcedureParameter(i int) IProcedureParameterContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
AllRoutineOption() []IRoutineOptionContext
|
|
RoutineOption(i int) IRoutineOptionContext
|
|
|
|
// IsCreateProcedureContext differentiates from other interfaces.
|
|
IsCreateProcedureContext()
|
|
}
|
|
|
|
type CreateProcedureContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateProcedureContext() *CreateProcedureContext {
|
|
var p = new(CreateProcedureContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createProcedure
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateProcedureContext(p *CreateProcedureContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createProcedure
|
|
}
|
|
|
|
func (*CreateProcedureContext) IsCreateProcedureContext() {}
|
|
|
|
func NewCreateProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateProcedureContext {
|
|
var p = new(CreateProcedureContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createProcedure
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateProcedureContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateProcedureContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) AllProcedureParameter() []IProcedureParameterContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureParameterContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureParameterContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureParameterContext); ok {
|
|
tst[i] = t.(IProcedureParameterContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateProcedureContext) ProcedureParameter(i int) IProcedureParameterContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureParameterContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureParameterContext)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) AllRoutineOption() []IRoutineOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoutineOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoutineOptionContext); ok {
|
|
tst[i] = t.(IRoutineOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateProcedureContext) RoutineOption(i int) IRoutineOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineOptionContext)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateProcedureContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateProcedureContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateProcedure(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateProcedure() (localctx ICreateProcedureContext) {
|
|
localctx = NewCreateProcedureContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 32, MySqlParserRULE_createProcedure)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1035)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1037)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(1036)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1039)
|
|
p.Match(MySqlParserPROCEDURE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1040)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(1041)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1043)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&151169654698547409) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1042)
|
|
p.ProcedureParameter()
|
|
}
|
|
|
|
}
|
|
p.SetState(1049)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1045)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1046)
|
|
p.ProcedureParameter()
|
|
}
|
|
|
|
p.SetState(1051)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(1052)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1056)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(1053)
|
|
p.RoutineOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(1058)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1059)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateFunctionContext is an interface to support dynamic dispatch.
|
|
type ICreateFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
RETURNS() antlr.TerminalNode
|
|
DataType() IDataTypeContext
|
|
RoutineBody() IRoutineBodyContext
|
|
ReturnStatement() IReturnStatementContext
|
|
OwnerStatement() IOwnerStatementContext
|
|
AGGREGATE() antlr.TerminalNode
|
|
IfNotExists() IIfNotExistsContext
|
|
AllFunctionParameter() []IFunctionParameterContext
|
|
FunctionParameter(i int) IFunctionParameterContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
AllRoutineOption() []IRoutineOptionContext
|
|
RoutineOption(i int) IRoutineOptionContext
|
|
|
|
// IsCreateFunctionContext differentiates from other interfaces.
|
|
IsCreateFunctionContext()
|
|
}
|
|
|
|
type CreateFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateFunctionContext() *CreateFunctionContext {
|
|
var p = new(CreateFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateFunctionContext(p *CreateFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createFunction
|
|
}
|
|
|
|
func (*CreateFunctionContext) IsCreateFunctionContext() {}
|
|
|
|
func NewCreateFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateFunctionContext {
|
|
var p = new(CreateFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateFunctionContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) RETURNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNS, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) ReturnStatement() IReturnStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReturnStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReturnStatementContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) AGGREGATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAGGREGATE, 0)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) AllFunctionParameter() []IFunctionParameterContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFunctionParameterContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFunctionParameterContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFunctionParameterContext); ok {
|
|
tst[i] = t.(IFunctionParameterContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateFunctionContext) FunctionParameter(i int) IFunctionParameterContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionParameterContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionParameterContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) AllRoutineOption() []IRoutineOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoutineOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoutineOptionContext); ok {
|
|
tst[i] = t.(IRoutineOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateFunctionContext) RoutineOption(i int) IRoutineOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineOptionContext)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateFunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateFunction() (localctx ICreateFunctionContext) {
|
|
localctx = NewCreateFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 34, MySqlParserRULE_createFunction)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1061)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1063)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(1062)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
p.SetState(1066)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAGGREGATE {
|
|
{
|
|
p.SetState(1065)
|
|
p.Match(MySqlParserAGGREGATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1068)
|
|
p.Match(MySqlParserFUNCTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1070)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1069)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1072)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(1073)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1075)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1074)
|
|
p.FunctionParameter()
|
|
}
|
|
|
|
}
|
|
p.SetState(1081)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1077)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1078)
|
|
p.FunctionParameter()
|
|
}
|
|
|
|
p.SetState(1083)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(1084)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1085)
|
|
p.Match(MySqlParserRETURNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1086)
|
|
p.DataType()
|
|
}
|
|
p.SetState(1090)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(1087)
|
|
p.RoutineOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(1092)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1095)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALTER, MySqlParserANALYZE, MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCONDITION, MySqlParserCREATE, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDIAGNOSTICS, MySqlParserDROP, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserKILL, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserLOAD, MySqlParserLOCK, MySqlParserNUMBER, MySqlParserOPTIMIZE, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserLR_BRACKET, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(1093)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
case MySqlParserRETURN:
|
|
{
|
|
p.SetState(1094)
|
|
p.ReturnStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateRoleContext is an interface to support dynamic dispatch.
|
|
type ICreateRoleContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
ROLE() antlr.TerminalNode
|
|
AllRoleName() []IRoleNameContext
|
|
RoleName(i int) IRoleNameContext
|
|
IfNotExists() IIfNotExistsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsCreateRoleContext differentiates from other interfaces.
|
|
IsCreateRoleContext()
|
|
}
|
|
|
|
type CreateRoleContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateRoleContext() *CreateRoleContext {
|
|
var p = new(CreateRoleContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createRole
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateRoleContext(p *CreateRoleContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createRole
|
|
}
|
|
|
|
func (*CreateRoleContext) IsCreateRoleContext() {}
|
|
|
|
func NewCreateRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateRoleContext {
|
|
var p = new(CreateRoleContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createRole
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateRoleContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateRoleContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateRoleContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *CreateRoleContext) AllRoleName() []IRoleNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoleNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoleNameContext); ok {
|
|
tst[i] = t.(IRoleNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateRoleContext) RoleName(i int) IRoleNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleNameContext)
|
|
}
|
|
|
|
func (s *CreateRoleContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateRoleContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateRoleContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateRoleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateRoleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateRoleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateRole(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateRole() (localctx ICreateRoleContext) {
|
|
localctx = NewCreateRoleContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 36, MySqlParserRULE_createRole)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1097)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1098)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1100)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1099)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1102)
|
|
p.RoleName()
|
|
}
|
|
p.SetState(1107)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1103)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1104)
|
|
p.RoleName()
|
|
}
|
|
|
|
p.SetState(1109)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateServerContext is an interface to support dynamic dispatch.
|
|
type ICreateServerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetWrapperName returns the wrapperName token.
|
|
GetWrapperName() antlr.Token
|
|
|
|
// SetWrapperName sets the wrapperName token.
|
|
SetWrapperName(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
SERVER() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
FOREIGN() antlr.TerminalNode
|
|
DATA() antlr.TerminalNode
|
|
WRAPPER() antlr.TerminalNode
|
|
OPTIONS() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllServerOption() []IServerOptionContext
|
|
ServerOption(i int) IServerOptionContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
MYSQL() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsCreateServerContext differentiates from other interfaces.
|
|
IsCreateServerContext()
|
|
}
|
|
|
|
type CreateServerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
wrapperName antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateServerContext() *CreateServerContext {
|
|
var p = new(CreateServerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createServer
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateServerContext(p *CreateServerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createServer
|
|
}
|
|
|
|
func (*CreateServerContext) IsCreateServerContext() {}
|
|
|
|
func NewCreateServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateServerContext {
|
|
var p = new(CreateServerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createServer
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateServerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateServerContext) GetWrapperName() antlr.Token { return s.wrapperName }
|
|
|
|
func (s *CreateServerContext) SetWrapperName(v antlr.Token) { s.wrapperName = v }
|
|
|
|
func (s *CreateServerContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) SERVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERVER, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateServerContext) FOREIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOREIGN, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) WRAPPER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWRAPPER, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) OPTIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONS, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) AllServerOption() []IServerOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IServerOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IServerOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IServerOptionContext); ok {
|
|
tst[i] = t.(IServerOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateServerContext) ServerOption(i int) IServerOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IServerOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IServerOptionContext)
|
|
}
|
|
|
|
func (s *CreateServerContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) MYSQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateServerContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateServerContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateServerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateServerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateServerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateServer(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateServer() (localctx ICreateServerContext) {
|
|
localctx = NewCreateServerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 38, MySqlParserRULE_createServer)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1110)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1111)
|
|
p.Match(MySqlParserSERVER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1112)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(1113)
|
|
p.Match(MySqlParserFOREIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1114)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1115)
|
|
p.Match(MySqlParserWRAPPER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1116)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateServerContext).wrapperName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMYSQL || _la == MySqlParserSTRING_LITERAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateServerContext).wrapperName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1117)
|
|
p.Match(MySqlParserOPTIONS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1118)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1119)
|
|
p.ServerOption()
|
|
}
|
|
p.SetState(1124)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1120)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1121)
|
|
p.ServerOption()
|
|
}
|
|
|
|
p.SetState(1126)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(1127)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateTableContext is an interface to support dynamic dispatch.
|
|
type ICreateTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsCreateTableContext differentiates from other interfaces.
|
|
IsCreateTableContext()
|
|
}
|
|
|
|
type CreateTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateTableContext() *CreateTableContext {
|
|
var p = new(CreateTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateTableContext(p *CreateTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTable
|
|
}
|
|
|
|
func (*CreateTableContext) IsCreateTableContext() {}
|
|
|
|
func NewCreateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTableContext {
|
|
var p = new(CreateTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateTableContext) CopyAll(ctx *CreateTableContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *CreateTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type CopyCreateTableContext struct {
|
|
CreateTableContext
|
|
parenthesisTable ITableNameContext
|
|
}
|
|
|
|
func NewCopyCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CopyCreateTableContext {
|
|
var p = new(CopyCreateTableContext)
|
|
|
|
InitEmptyCreateTableContext(&p.CreateTableContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateTableContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) GetParenthesisTable() ITableNameContext { return s.parenthesisTable }
|
|
|
|
func (s *CopyCreateTableContext) SetParenthesisTable(v ITableNameContext) { s.parenthesisTable = v }
|
|
|
|
func (s *CopyCreateTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) AllTableName() []ITableNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableNameContext); ok {
|
|
tst[i] = t.(ITableNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) TableName(i int) ITableNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) LIKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIKE, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCopyCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCopyCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *CopyCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCopyCreateTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ColumnCreateTableContext struct {
|
|
CreateTableContext
|
|
}
|
|
|
|
func NewColumnCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ColumnCreateTableContext {
|
|
var p = new(ColumnCreateTableContext)
|
|
|
|
InitEmptyCreateTableContext(&p.CreateTableContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateTableContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) CreateDefinitions() ICreateDefinitionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDefinitionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDefinitionsContext)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) AllTableOption() []ITableOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableOptionContext); ok {
|
|
tst[i] = t.(ITableOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) TableOption(i int) ITableOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableOptionContext)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) PartitionDefinitions() IPartitionDefinitionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionsContext)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterColumnCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitColumnCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitColumnCreateTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type QueryCreateTableContext struct {
|
|
CreateTableContext
|
|
keyViolate antlr.Token
|
|
}
|
|
|
|
func NewQueryCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryCreateTableContext {
|
|
var p = new(QueryCreateTableContext)
|
|
|
|
InitEmptyCreateTableContext(&p.CreateTableContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateTableContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) GetKeyViolate() antlr.Token { return s.keyViolate }
|
|
|
|
func (s *QueryCreateTableContext) SetKeyViolate(v antlr.Token) { s.keyViolate = v }
|
|
|
|
func (s *QueryCreateTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) CreateDefinitions() ICreateDefinitionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDefinitionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDefinitionsContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) AllTableOption() []ITableOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableOptionContext); ok {
|
|
tst[i] = t.(ITableOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) TableOption(i int) ITableOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableOptionContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) PartitionDefinitions() IPartitionDefinitionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionsContext)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterQueryCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitQueryCreateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitQueryCreateTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateTable() (localctx ICreateTableContext) {
|
|
localctx = NewCreateTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 40, MySqlParserRULE_createTable)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(1207)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 78, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewCopyCreateTableContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1129)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1131)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserTEMPORARY {
|
|
{
|
|
p.SetState(1130)
|
|
p.Match(MySqlParserTEMPORARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1133)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1135)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 61, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1134)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1137)
|
|
p.TableName()
|
|
}
|
|
p.SetState(1145)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLIKE:
|
|
{
|
|
p.SetState(1138)
|
|
p.Match(MySqlParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1139)
|
|
p.TableName()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(1140)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1141)
|
|
p.Match(MySqlParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1142)
|
|
|
|
var _x = p.TableName()
|
|
|
|
localctx.(*CopyCreateTableContext).parenthesisTable = _x
|
|
}
|
|
{
|
|
p.SetState(1143)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewQueryCreateTableContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1147)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1149)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserTEMPORARY {
|
|
{
|
|
p.SetState(1148)
|
|
p.Match(MySqlParserTEMPORARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1151)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1153)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1152)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1155)
|
|
p.TableName()
|
|
}
|
|
p.SetState(1157)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 65, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1156)
|
|
p.CreateDefinitions()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(1169)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64((_la-25)) & ^0x3f) == 0 && ((int64(1)<<(_la-25))&72057594038059013) != 0) || _la == MySqlParserUNION || _la == MySqlParserCHAR || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&4644375904747527) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&4612811918334230547) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&2366149022974977) != 0) || ((int64((_la-602)) & ^0x3f) == 0 && ((int64(1)<<(_la-602))&4609173815820289) != 0) || _la == MySqlParserCHARSET || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserSTRING_LITERAL {
|
|
{
|
|
p.SetState(1159)
|
|
p.TableOption()
|
|
}
|
|
p.SetState(1166)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ((int64((_la-25)) & ^0x3f) == 0 && ((int64(1)<<(_la-25))&72057594038059013) != 0) || _la == MySqlParserUNION || _la == MySqlParserCHAR || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&4644375904747527) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&4612811918334230547) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&2366149022974977) != 0) || ((int64((_la-602)) & ^0x3f) == 0 && ((int64(1)<<(_la-602))&4609173815820289) != 0) || _la == MySqlParserCHARSET || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserCOMMA || _la == MySqlParserSTRING_LITERAL {
|
|
p.SetState(1161)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1160)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1163)
|
|
p.TableOption()
|
|
}
|
|
|
|
p.SetState(1168)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(1172)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(1171)
|
|
p.PartitionDefinitions()
|
|
}
|
|
|
|
}
|
|
p.SetState(1175)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE {
|
|
{
|
|
p.SetState(1174)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*QueryCreateTableContext).keyViolate = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*QueryCreateTableContext).keyViolate = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1178)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(1177)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1180)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewColumnCreateTableContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1182)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1184)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserTEMPORARY {
|
|
{
|
|
p.SetState(1183)
|
|
p.Match(MySqlParserTEMPORARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1186)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1188)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1187)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1190)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(1191)
|
|
p.CreateDefinitions()
|
|
}
|
|
p.SetState(1202)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1192)
|
|
p.TableOption()
|
|
}
|
|
p.SetState(1199)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(1194)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1193)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1196)
|
|
p.TableOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(1201)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(1205)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(1204)
|
|
p.PartitionDefinitions()
|
|
}
|
|
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateTablespaceInnodbContext is an interface to support dynamic dispatch.
|
|
type ICreateTablespaceInnodbContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDatafile returns the datafile token.
|
|
GetDatafile() antlr.Token
|
|
|
|
// SetDatafile sets the datafile token.
|
|
SetDatafile(antlr.Token)
|
|
|
|
// GetFileBlockSize returns the fileBlockSize rule contexts.
|
|
GetFileBlockSize() IFileSizeLiteralContext
|
|
|
|
// SetFileBlockSize sets the fileBlockSize rule contexts.
|
|
SetFileBlockSize(IFileSizeLiteralContext)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ADD() antlr.TerminalNode
|
|
DATAFILE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
FILE_BLOCK_SIZE() antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
FileSizeLiteral() IFileSizeLiteralContext
|
|
|
|
// IsCreateTablespaceInnodbContext differentiates from other interfaces.
|
|
IsCreateTablespaceInnodbContext()
|
|
}
|
|
|
|
type CreateTablespaceInnodbContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
datafile antlr.Token
|
|
fileBlockSize IFileSizeLiteralContext
|
|
}
|
|
|
|
func NewEmptyCreateTablespaceInnodbContext() *CreateTablespaceInnodbContext {
|
|
var p = new(CreateTablespaceInnodbContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceInnodb
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateTablespaceInnodbContext(p *CreateTablespaceInnodbContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceInnodb
|
|
}
|
|
|
|
func (*CreateTablespaceInnodbContext) IsCreateTablespaceInnodbContext() {}
|
|
|
|
func NewCreateTablespaceInnodbContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTablespaceInnodbContext {
|
|
var p = new(CreateTablespaceInnodbContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceInnodb
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateTablespaceInnodbContext) GetDatafile() antlr.Token { return s.datafile }
|
|
|
|
func (s *CreateTablespaceInnodbContext) SetDatafile(v antlr.Token) { s.datafile = v }
|
|
|
|
func (s *CreateTablespaceInnodbContext) GetFileBlockSize() IFileSizeLiteralContext {
|
|
return s.fileBlockSize
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) SetFileBlockSize(v IFileSizeLiteralContext) {
|
|
s.fileBlockSize = v
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) DATAFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATAFILE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) FILE_BLOCK_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILE_BLOCK_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) FileSizeLiteral() IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateTablespaceInnodb(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateTablespaceInnodb(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTablespaceInnodbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateTablespaceInnodb(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateTablespaceInnodb() (localctx ICreateTablespaceInnodbContext) {
|
|
localctx = NewCreateTablespaceInnodbContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 42, MySqlParserRULE_createTablespaceInnodb)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1209)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1210)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1211)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(1212)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1213)
|
|
p.Match(MySqlParserDATAFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1214)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*CreateTablespaceInnodbContext).datafile = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1218)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFILE_BLOCK_SIZE {
|
|
{
|
|
p.SetState(1215)
|
|
p.Match(MySqlParserFILE_BLOCK_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1216)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1217)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateTablespaceInnodbContext).fileBlockSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1225)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENGINE {
|
|
{
|
|
p.SetState(1220)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1222)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1221)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1224)
|
|
p.EngineName()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateTablespaceNdbContext is an interface to support dynamic dispatch.
|
|
type ICreateTablespaceNdbContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDatafile returns the datafile token.
|
|
GetDatafile() antlr.Token
|
|
|
|
// GetComment returns the comment token.
|
|
GetComment() antlr.Token
|
|
|
|
// SetDatafile sets the datafile token.
|
|
SetDatafile(antlr.Token)
|
|
|
|
// SetComment sets the comment token.
|
|
SetComment(antlr.Token)
|
|
|
|
// GetExtentSize returns the extentSize rule contexts.
|
|
GetExtentSize() IFileSizeLiteralContext
|
|
|
|
// GetInitialSize returns the initialSize rule contexts.
|
|
GetInitialSize() IFileSizeLiteralContext
|
|
|
|
// GetAutoextendSize returns the autoextendSize rule contexts.
|
|
GetAutoextendSize() IFileSizeLiteralContext
|
|
|
|
// GetMaxSize returns the maxSize rule contexts.
|
|
GetMaxSize() IFileSizeLiteralContext
|
|
|
|
// SetExtentSize sets the extentSize rule contexts.
|
|
SetExtentSize(IFileSizeLiteralContext)
|
|
|
|
// SetInitialSize sets the initialSize rule contexts.
|
|
SetInitialSize(IFileSizeLiteralContext)
|
|
|
|
// SetAutoextendSize sets the autoextendSize rule contexts.
|
|
SetAutoextendSize(IFileSizeLiteralContext)
|
|
|
|
// SetMaxSize sets the maxSize rule contexts.
|
|
SetMaxSize(IFileSizeLiteralContext)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
ADD() antlr.TerminalNode
|
|
DATAFILE() antlr.TerminalNode
|
|
USE() antlr.TerminalNode
|
|
LOGFILE() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
EXTENT_SIZE() antlr.TerminalNode
|
|
INITIAL_SIZE() antlr.TerminalNode
|
|
AUTOEXTEND_SIZE() antlr.TerminalNode
|
|
MAX_SIZE() antlr.TerminalNode
|
|
NODEGROUP() antlr.TerminalNode
|
|
WAIT() antlr.TerminalNode
|
|
COMMENT() antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
AllFileSizeLiteral() []IFileSizeLiteralContext
|
|
FileSizeLiteral(i int) IFileSizeLiteralContext
|
|
|
|
// IsCreateTablespaceNdbContext differentiates from other interfaces.
|
|
IsCreateTablespaceNdbContext()
|
|
}
|
|
|
|
type CreateTablespaceNdbContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
datafile antlr.Token
|
|
extentSize IFileSizeLiteralContext
|
|
initialSize IFileSizeLiteralContext
|
|
autoextendSize IFileSizeLiteralContext
|
|
maxSize IFileSizeLiteralContext
|
|
comment antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateTablespaceNdbContext() *CreateTablespaceNdbContext {
|
|
var p = new(CreateTablespaceNdbContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceNdb
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateTablespaceNdbContext(p *CreateTablespaceNdbContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceNdb
|
|
}
|
|
|
|
func (*CreateTablespaceNdbContext) IsCreateTablespaceNdbContext() {}
|
|
|
|
func NewCreateTablespaceNdbContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTablespaceNdbContext {
|
|
var p = new(CreateTablespaceNdbContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createTablespaceNdb
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateTablespaceNdbContext) GetDatafile() antlr.Token { return s.datafile }
|
|
|
|
func (s *CreateTablespaceNdbContext) GetComment() antlr.Token { return s.comment }
|
|
|
|
func (s *CreateTablespaceNdbContext) SetDatafile(v antlr.Token) { s.datafile = v }
|
|
|
|
func (s *CreateTablespaceNdbContext) SetComment(v antlr.Token) { s.comment = v }
|
|
|
|
func (s *CreateTablespaceNdbContext) GetExtentSize() IFileSizeLiteralContext { return s.extentSize }
|
|
|
|
func (s *CreateTablespaceNdbContext) GetInitialSize() IFileSizeLiteralContext { return s.initialSize }
|
|
|
|
func (s *CreateTablespaceNdbContext) GetAutoextendSize() IFileSizeLiteralContext {
|
|
return s.autoextendSize
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) GetMaxSize() IFileSizeLiteralContext { return s.maxSize }
|
|
|
|
func (s *CreateTablespaceNdbContext) SetExtentSize(v IFileSizeLiteralContext) { s.extentSize = v }
|
|
|
|
func (s *CreateTablespaceNdbContext) SetInitialSize(v IFileSizeLiteralContext) { s.initialSize = v }
|
|
|
|
func (s *CreateTablespaceNdbContext) SetAutoextendSize(v IFileSizeLiteralContext) {
|
|
s.autoextendSize = v
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) SetMaxSize(v IFileSizeLiteralContext) { s.maxSize = v }
|
|
|
|
func (s *CreateTablespaceNdbContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) DATAFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATAFILE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) USE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) LOGFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGFILE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) EXTENT_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENT_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) INITIAL_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINITIAL_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) AUTOEXTEND_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) MAX_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_SIZE, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) NODEGROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNODEGROUP, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) AllFileSizeLiteral() []IFileSizeLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFileSizeLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
tst[i] = t.(IFileSizeLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) FileSizeLiteral(i int) IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateTablespaceNdb(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateTablespaceNdb(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTablespaceNdbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateTablespaceNdb(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateTablespaceNdb() (localctx ICreateTablespaceNdbContext) {
|
|
localctx = NewCreateTablespaceNdbContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 44, MySqlParserRULE_createTablespaceNdb)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1227)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1228)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1229)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(1230)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1231)
|
|
p.Match(MySqlParserDATAFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1232)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*CreateTablespaceNdbContext).datafile = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1233)
|
|
p.Match(MySqlParserUSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1234)
|
|
p.Match(MySqlParserLOGFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1235)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1236)
|
|
p.Uid()
|
|
}
|
|
p.SetState(1242)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEXTENT_SIZE {
|
|
{
|
|
p.SetState(1237)
|
|
p.Match(MySqlParserEXTENT_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1239)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1238)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1241)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateTablespaceNdbContext).extentSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1249)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINITIAL_SIZE {
|
|
{
|
|
p.SetState(1244)
|
|
p.Match(MySqlParserINITIAL_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1246)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1245)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1248)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateTablespaceNdbContext).initialSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1256)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAUTOEXTEND_SIZE {
|
|
{
|
|
p.SetState(1251)
|
|
p.Match(MySqlParserAUTOEXTEND_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1253)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1252)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1255)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateTablespaceNdbContext).autoextendSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1263)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserMAX_SIZE {
|
|
{
|
|
p.SetState(1258)
|
|
p.Match(MySqlParserMAX_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1260)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1259)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1262)
|
|
|
|
var _x = p.FileSizeLiteral()
|
|
|
|
localctx.(*CreateTablespaceNdbContext).maxSize = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1270)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNODEGROUP {
|
|
{
|
|
p.SetState(1265)
|
|
p.Match(MySqlParserNODEGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1267)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1266)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1269)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(1273)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(1272)
|
|
p.Match(MySqlParserWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1280)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMENT {
|
|
{
|
|
p.SetState(1275)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1277)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1276)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1279)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*CreateTablespaceNdbContext).comment = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1282)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1284)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1283)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1286)
|
|
p.EngineName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateTriggerContext is an interface to support dynamic dispatch.
|
|
type ICreateTriggerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetTriggerTime returns the triggerTime token.
|
|
GetTriggerTime() antlr.Token
|
|
|
|
// GetTriggerEvent returns the triggerEvent token.
|
|
GetTriggerEvent() antlr.Token
|
|
|
|
// GetTriggerPlace returns the triggerPlace token.
|
|
GetTriggerPlace() antlr.Token
|
|
|
|
// SetTriggerTime sets the triggerTime token.
|
|
SetTriggerTime(antlr.Token)
|
|
|
|
// SetTriggerEvent sets the triggerEvent token.
|
|
SetTriggerEvent(antlr.Token)
|
|
|
|
// SetTriggerPlace sets the triggerPlace token.
|
|
SetTriggerPlace(antlr.Token)
|
|
|
|
// GetThisTrigger returns the thisTrigger rule contexts.
|
|
GetThisTrigger() IFullIdContext
|
|
|
|
// GetOtherTrigger returns the otherTrigger rule contexts.
|
|
GetOtherTrigger() IFullIdContext
|
|
|
|
// SetThisTrigger sets the thisTrigger rule contexts.
|
|
SetThisTrigger(IFullIdContext)
|
|
|
|
// SetOtherTrigger sets the otherTrigger rule contexts.
|
|
SetOtherTrigger(IFullIdContext)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
TRIGGER() antlr.TerminalNode
|
|
ON() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
FOR() antlr.TerminalNode
|
|
EACH() antlr.TerminalNode
|
|
ROW() antlr.TerminalNode
|
|
RoutineBody() IRoutineBodyContext
|
|
AllFullId() []IFullIdContext
|
|
FullId(i int) IFullIdContext
|
|
BEFORE() antlr.TerminalNode
|
|
AFTER() antlr.TerminalNode
|
|
INSERT() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
DELETE() antlr.TerminalNode
|
|
OwnerStatement() IOwnerStatementContext
|
|
IfNotExists() IIfNotExistsContext
|
|
FOLLOWS() antlr.TerminalNode
|
|
PRECEDES() antlr.TerminalNode
|
|
|
|
// IsCreateTriggerContext differentiates from other interfaces.
|
|
IsCreateTriggerContext()
|
|
}
|
|
|
|
type CreateTriggerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
thisTrigger IFullIdContext
|
|
triggerTime antlr.Token
|
|
triggerEvent antlr.Token
|
|
triggerPlace antlr.Token
|
|
otherTrigger IFullIdContext
|
|
}
|
|
|
|
func NewEmptyCreateTriggerContext() *CreateTriggerContext {
|
|
var p = new(CreateTriggerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTrigger
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateTriggerContext(p *CreateTriggerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createTrigger
|
|
}
|
|
|
|
func (*CreateTriggerContext) IsCreateTriggerContext() {}
|
|
|
|
func NewCreateTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTriggerContext {
|
|
var p = new(CreateTriggerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createTrigger
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateTriggerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateTriggerContext) GetTriggerTime() antlr.Token { return s.triggerTime }
|
|
|
|
func (s *CreateTriggerContext) GetTriggerEvent() antlr.Token { return s.triggerEvent }
|
|
|
|
func (s *CreateTriggerContext) GetTriggerPlace() antlr.Token { return s.triggerPlace }
|
|
|
|
func (s *CreateTriggerContext) SetTriggerTime(v antlr.Token) { s.triggerTime = v }
|
|
|
|
func (s *CreateTriggerContext) SetTriggerEvent(v antlr.Token) { s.triggerEvent = v }
|
|
|
|
func (s *CreateTriggerContext) SetTriggerPlace(v antlr.Token) { s.triggerPlace = v }
|
|
|
|
func (s *CreateTriggerContext) GetThisTrigger() IFullIdContext { return s.thisTrigger }
|
|
|
|
func (s *CreateTriggerContext) GetOtherTrigger() IFullIdContext { return s.otherTrigger }
|
|
|
|
func (s *CreateTriggerContext) SetThisTrigger(v IFullIdContext) { s.thisTrigger = v }
|
|
|
|
func (s *CreateTriggerContext) SetOtherTrigger(v IFullIdContext) { s.otherTrigger = v }
|
|
|
|
func (s *CreateTriggerContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) TRIGGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGER, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) EACH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEACH, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) ROW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) AllFullId() []IFullIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullIdContext); ok {
|
|
tst[i] = t.(IFullIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateTriggerContext) FullId(i int) IFullIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) BEFORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEFORE, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) AFTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAFTER, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) DELETE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELETE, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) FOLLOWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOLLOWS, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) PRECEDES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRECEDES, 0)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateTrigger(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateTrigger() (localctx ICreateTriggerContext) {
|
|
localctx = NewCreateTriggerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 46, MySqlParserRULE_createTrigger)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1288)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1290)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(1289)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1292)
|
|
p.Match(MySqlParserTRIGGER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1294)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1293)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1296)
|
|
|
|
var _x = p.FullId()
|
|
|
|
localctx.(*CreateTriggerContext).thisTrigger = _x
|
|
}
|
|
{
|
|
p.SetState(1297)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateTriggerContext).triggerTime = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBEFORE || _la == MySqlParserAFTER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateTriggerContext).triggerTime = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1298)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateTriggerContext).triggerEvent = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDELETE || _la == MySqlParserINSERT || _la == MySqlParserUPDATE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateTriggerContext).triggerEvent = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1299)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1300)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(1301)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1302)
|
|
p.Match(MySqlParserEACH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1303)
|
|
p.Match(MySqlParserROW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1306)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1304)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateTriggerContext).triggerPlace = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFOLLOWS || _la == MySqlParserPRECEDES) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateTriggerContext).triggerPlace = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1305)
|
|
|
|
var _x = p.FullId()
|
|
|
|
localctx.(*CreateTriggerContext).otherTrigger = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1308)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWithClauseContext is an interface to support dynamic dispatch.
|
|
type IWithClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WITH() antlr.TerminalNode
|
|
CommonTableExpressions() ICommonTableExpressionsContext
|
|
RECURSIVE() antlr.TerminalNode
|
|
|
|
// IsWithClauseContext differentiates from other interfaces.
|
|
IsWithClauseContext()
|
|
}
|
|
|
|
type WithClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWithClauseContext() *WithClauseContext {
|
|
var p = new(WithClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_withClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWithClauseContext(p *WithClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_withClause
|
|
}
|
|
|
|
func (*WithClauseContext) IsWithClauseContext() {}
|
|
|
|
func NewWithClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithClauseContext {
|
|
var p = new(WithClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_withClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WithClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WithClauseContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *WithClauseContext) CommonTableExpressions() ICommonTableExpressionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICommonTableExpressionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICommonTableExpressionsContext)
|
|
}
|
|
|
|
func (s *WithClauseContext) RECURSIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRECURSIVE, 0)
|
|
}
|
|
|
|
func (s *WithClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WithClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WithClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWithClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWithClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWithClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WithClause() (localctx IWithClauseContext) {
|
|
localctx = NewWithClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 48, MySqlParserRULE_withClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1310)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1312)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1311)
|
|
p.Match(MySqlParserRECURSIVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1314)
|
|
p.CommonTableExpressions()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICommonTableExpressionsContext is an interface to support dynamic dispatch.
|
|
type ICommonTableExpressionsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CteName() ICteNameContext
|
|
AS() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
DmlStatement() IDmlStatementContext
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
AllCteColumnName() []ICteColumnNameContext
|
|
CteColumnName(i int) ICteColumnNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
CommonTableExpressions() ICommonTableExpressionsContext
|
|
|
|
// IsCommonTableExpressionsContext differentiates from other interfaces.
|
|
IsCommonTableExpressionsContext()
|
|
}
|
|
|
|
type CommonTableExpressionsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCommonTableExpressionsContext() *CommonTableExpressionsContext {
|
|
var p = new(CommonTableExpressionsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_commonTableExpressions
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCommonTableExpressionsContext(p *CommonTableExpressionsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_commonTableExpressions
|
|
}
|
|
|
|
func (*CommonTableExpressionsContext) IsCommonTableExpressionsContext() {}
|
|
|
|
func NewCommonTableExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommonTableExpressionsContext {
|
|
var p = new(CommonTableExpressionsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_commonTableExpressions
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CommonTableExpressionsContext) CteName() ICteNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICteNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICteNameContext)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) DmlStatement() IDmlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDmlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDmlStatementContext)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) AllCteColumnName() []ICteColumnNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICteColumnNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICteColumnNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICteColumnNameContext); ok {
|
|
tst[i] = t.(ICteColumnNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) CteColumnName(i int) ICteColumnNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICteColumnNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICteColumnNameContext)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) CommonTableExpressions() ICommonTableExpressionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICommonTableExpressionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICommonTableExpressionsContext)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCommonTableExpressions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCommonTableExpressions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommonTableExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCommonTableExpressions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CommonTableExpressions() (localctx ICommonTableExpressionsContext) {
|
|
localctx = NewCommonTableExpressionsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 50, MySqlParserRULE_commonTableExpressions)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1316)
|
|
p.CteName()
|
|
}
|
|
p.SetState(1328)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(1317)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1318)
|
|
p.CteColumnName()
|
|
}
|
|
p.SetState(1323)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1319)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1320)
|
|
p.CteColumnName()
|
|
}
|
|
|
|
p.SetState(1325)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(1326)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1330)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1331)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1332)
|
|
p.DmlStatement()
|
|
}
|
|
{
|
|
p.SetState(1333)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1336)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1334)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1335)
|
|
p.CommonTableExpressions()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICteNameContext is an interface to support dynamic dispatch.
|
|
type ICteNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
|
|
// IsCteNameContext differentiates from other interfaces.
|
|
IsCteNameContext()
|
|
}
|
|
|
|
type CteNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCteNameContext() *CteNameContext {
|
|
var p = new(CteNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cteName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCteNameContext(p *CteNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cteName
|
|
}
|
|
|
|
func (*CteNameContext) IsCteNameContext() {}
|
|
|
|
func NewCteNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CteNameContext {
|
|
var p = new(CteNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_cteName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CteNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CteNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CteNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CteNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CteNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCteName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CteNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCteName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CteNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCteName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CteName() (localctx ICteNameContext) {
|
|
localctx = NewCteNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 52, MySqlParserRULE_cteName)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1338)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICteColumnNameContext is an interface to support dynamic dispatch.
|
|
type ICteColumnNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
|
|
// IsCteColumnNameContext differentiates from other interfaces.
|
|
IsCteColumnNameContext()
|
|
}
|
|
|
|
type CteColumnNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCteColumnNameContext() *CteColumnNameContext {
|
|
var p = new(CteColumnNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cteColumnName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCteColumnNameContext(p *CteColumnNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cteColumnName
|
|
}
|
|
|
|
func (*CteColumnNameContext) IsCteColumnNameContext() {}
|
|
|
|
func NewCteColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CteColumnNameContext {
|
|
var p = new(CteColumnNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_cteColumnName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CteColumnNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CteColumnNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CteColumnNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CteColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CteColumnNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCteColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CteColumnNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCteColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CteColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCteColumnName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CteColumnName() (localctx ICteColumnNameContext) {
|
|
localctx = NewCteColumnNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 54, MySqlParserRULE_cteColumnName)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1340)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateViewContext is an interface to support dynamic dispatch.
|
|
type ICreateViewContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetAlgType returns the algType token.
|
|
GetAlgType() antlr.Token
|
|
|
|
// GetSecContext returns the secContext token.
|
|
GetSecContext() antlr.Token
|
|
|
|
// GetCheckOption returns the checkOption token.
|
|
GetCheckOption() antlr.Token
|
|
|
|
// SetAlgType sets the algType token.
|
|
SetAlgType(antlr.Token)
|
|
|
|
// SetSecContext sets the secContext token.
|
|
SetSecContext(antlr.Token)
|
|
|
|
// SetCheckOption sets the checkOption token.
|
|
SetCheckOption(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
VIEW() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
AS() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
SelectStatement() ISelectStatementContext
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
OrReplace() IOrReplaceContext
|
|
ALGORITHM() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
OwnerStatement() IOwnerStatementContext
|
|
SQL() antlr.TerminalNode
|
|
SECURITY() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
UNDEFINED() antlr.TerminalNode
|
|
MERGE() antlr.TerminalNode
|
|
TEMPTABLE() antlr.TerminalNode
|
|
DEFINER() antlr.TerminalNode
|
|
INVOKER() antlr.TerminalNode
|
|
WithClause() IWithClauseContext
|
|
WITH() antlr.TerminalNode
|
|
CHECK() antlr.TerminalNode
|
|
OPTION() antlr.TerminalNode
|
|
CASCADED() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
|
|
// IsCreateViewContext differentiates from other interfaces.
|
|
IsCreateViewContext()
|
|
}
|
|
|
|
type CreateViewContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
algType antlr.Token
|
|
secContext antlr.Token
|
|
checkOption antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateViewContext() *CreateViewContext {
|
|
var p = new(CreateViewContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createView
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateViewContext(p *CreateViewContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createView
|
|
}
|
|
|
|
func (*CreateViewContext) IsCreateViewContext() {}
|
|
|
|
func NewCreateViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateViewContext {
|
|
var p = new(CreateViewContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createView
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateViewContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateViewContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *CreateViewContext) GetSecContext() antlr.Token { return s.secContext }
|
|
|
|
func (s *CreateViewContext) GetCheckOption() antlr.Token { return s.checkOption }
|
|
|
|
func (s *CreateViewContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *CreateViewContext) SetSecContext(v antlr.Token) { s.secContext = v }
|
|
|
|
func (s *CreateViewContext) SetCheckOption(v antlr.Token) { s.checkOption = v }
|
|
|
|
func (s *CreateViewContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *CreateViewContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *CreateViewContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *CreateViewContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *CreateViewContext) OrReplace() IOrReplaceContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrReplaceContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrReplaceContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) SQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) SECURITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECURITY, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) UNDEFINED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDEFINED, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) MERGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMERGE, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) TEMPTABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPTABLE, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) DEFINER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFINER, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) INVOKER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKER, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) WithClause() IWithClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWithClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWithClauseContext)
|
|
}
|
|
|
|
func (s *CreateViewContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) OPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) CASCADED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADED, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *CreateViewContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateViewContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateView(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateViewContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateView(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateView(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateView() (localctx ICreateViewContext) {
|
|
localctx = NewCreateViewContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 56, MySqlParserRULE_createView)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1342)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1344)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOR {
|
|
{
|
|
p.SetState(1343)
|
|
p.OrReplace()
|
|
}
|
|
|
|
}
|
|
p.SetState(1349)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALGORITHM {
|
|
{
|
|
p.SetState(1346)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1347)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1348)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateViewContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMERGE || _la == MySqlParserTEMPTABLE || _la == MySqlParserUNDEFINED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateViewContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1352)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(1351)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
p.SetState(1357)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSQL {
|
|
{
|
|
p.SetState(1354)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1355)
|
|
p.Match(MySqlParserSECURITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1356)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateViewContext).secContext = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateViewContext).secContext = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1359)
|
|
p.Match(MySqlParserVIEW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1360)
|
|
p.FullId()
|
|
}
|
|
p.SetState(1365)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(1361)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1362)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(1363)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1367)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1387)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 112, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(1368)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1370)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWITH {
|
|
{
|
|
p.SetState(1369)
|
|
p.WithClause()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1372)
|
|
p.SelectStatement()
|
|
}
|
|
{
|
|
p.SetState(1373)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.SetState(1376)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWITH {
|
|
{
|
|
p.SetState(1375)
|
|
p.WithClause()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1378)
|
|
p.SelectStatement()
|
|
}
|
|
p.SetState(1385)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1379)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1381)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCASCADED || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(1380)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateViewContext).checkOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCASCADED || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateViewContext).checkOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1383)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1384)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateDatabaseOptionContext is an interface to support dynamic dispatch.
|
|
type ICreateDatabaseOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CharSet() ICharSetContext
|
|
CharsetName() ICharsetNameContext
|
|
AllDEFAULT() []antlr.TerminalNode
|
|
DEFAULT(i int) antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
COLLATE() antlr.TerminalNode
|
|
CollationName() ICollationNameContext
|
|
ENCRYPTION() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
READ() antlr.TerminalNode
|
|
ONLY() antlr.TerminalNode
|
|
ZERO_DECIMAL() antlr.TerminalNode
|
|
ONE_DECIMAL() antlr.TerminalNode
|
|
|
|
// IsCreateDatabaseOptionContext differentiates from other interfaces.
|
|
IsCreateDatabaseOptionContext()
|
|
}
|
|
|
|
type CreateDatabaseOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateDatabaseOptionContext() *CreateDatabaseOptionContext {
|
|
var p = new(CreateDatabaseOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDatabaseOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateDatabaseOptionContext(p *CreateDatabaseOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDatabaseOption
|
|
}
|
|
|
|
func (*CreateDatabaseOptionContext) IsCreateDatabaseOptionContext() {}
|
|
|
|
func NewCreateDatabaseOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDatabaseOptionContext {
|
|
var p = new(CreateDatabaseOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createDatabaseOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateDatabaseOptionContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) AllDEFAULT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserDEFAULT)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) DEFAULT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, i)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ENCRYPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ONLY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLY, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateDatabaseOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateDatabaseOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDatabaseOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateDatabaseOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateDatabaseOption() (localctx ICreateDatabaseOptionContext) {
|
|
localctx = NewCreateDatabaseOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 58, MySqlParserRULE_createDatabaseOption)
|
|
var _la int
|
|
|
|
p.SetState(1422)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(1390)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(1389)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1392)
|
|
p.CharSet()
|
|
}
|
|
p.SetState(1394)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1393)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1398)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(1396)
|
|
p.CharsetName()
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(1397)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(1401)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(1400)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1403)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1405)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1404)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1407)
|
|
p.CollationName()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(1409)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(1408)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1411)
|
|
p.Match(MySqlParserENCRYPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1413)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1412)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1415)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1416)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1417)
|
|
p.Match(MySqlParserONLY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1419)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1418)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1421)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICharSetContext is an interface to support dynamic dispatch.
|
|
type ICharSetContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CHARACTER() antlr.TerminalNode
|
|
SET() antlr.TerminalNode
|
|
CHARSET() antlr.TerminalNode
|
|
CHAR() antlr.TerminalNode
|
|
|
|
// IsCharSetContext differentiates from other interfaces.
|
|
IsCharSetContext()
|
|
}
|
|
|
|
type CharSetContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCharSetContext() *CharSetContext {
|
|
var p = new(CharSetContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charSet
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCharSetContext(p *CharSetContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charSet
|
|
}
|
|
|
|
func (*CharSetContext) IsCharSetContext() {}
|
|
|
|
func NewCharSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharSetContext {
|
|
var p = new(CharSetContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_charSet
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CharSetContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CharSetContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *CharSetContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *CharSetContext) CHARSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARSET, 0)
|
|
}
|
|
|
|
func (s *CharSetContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *CharSetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CharSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CharSetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCharSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharSetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCharSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCharSet(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CharSet() (localctx ICharSetContext) {
|
|
localctx = NewCharSetContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 60, MySqlParserRULE_charSet)
|
|
p.SetState(1429)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCHARACTER:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1424)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1425)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHARSET:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1426)
|
|
p.Match(MySqlParserCHARSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHAR:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1427)
|
|
p.Match(MySqlParserCHAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1428)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICurrentUserExpressionContext is an interface to support dynamic dispatch.
|
|
type ICurrentUserExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CURRENT_USER() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsCurrentUserExpressionContext differentiates from other interfaces.
|
|
IsCurrentUserExpressionContext()
|
|
}
|
|
|
|
type CurrentUserExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCurrentUserExpressionContext() *CurrentUserExpressionContext {
|
|
var p = new(CurrentUserExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_currentUserExpression
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCurrentUserExpressionContext(p *CurrentUserExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_currentUserExpression
|
|
}
|
|
|
|
func (*CurrentUserExpressionContext) IsCurrentUserExpressionContext() {}
|
|
|
|
func NewCurrentUserExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CurrentUserExpressionContext {
|
|
var p = new(CurrentUserExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_currentUserExpression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CurrentUserExpressionContext) CURRENT_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_USER, 0)
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCurrentUserExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCurrentUserExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentUserExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCurrentUserExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CurrentUserExpression() (localctx ICurrentUserExpressionContext) {
|
|
localctx = NewCurrentUserExpressionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 62, MySqlParserRULE_currentUserExpression)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1431)
|
|
p.Match(MySqlParserCURRENT_USER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1434)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1432)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1433)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOwnerStatementContext is an interface to support dynamic dispatch.
|
|
type IOwnerStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DEFINER() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
UserName() IUserNameContext
|
|
CurrentUserExpression() ICurrentUserExpressionContext
|
|
|
|
// IsOwnerStatementContext differentiates from other interfaces.
|
|
IsOwnerStatementContext()
|
|
}
|
|
|
|
type OwnerStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyOwnerStatementContext() *OwnerStatementContext {
|
|
var p = new(OwnerStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ownerStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOwnerStatementContext(p *OwnerStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ownerStatement
|
|
}
|
|
|
|
func (*OwnerStatementContext) IsOwnerStatementContext() {}
|
|
|
|
func NewOwnerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OwnerStatementContext {
|
|
var p = new(OwnerStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_ownerStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OwnerStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OwnerStatementContext) DEFINER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFINER, 0)
|
|
}
|
|
|
|
func (s *OwnerStatementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *OwnerStatementContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *OwnerStatementContext) CurrentUserExpression() ICurrentUserExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICurrentUserExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICurrentUserExpressionContext)
|
|
}
|
|
|
|
func (s *OwnerStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OwnerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OwnerStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOwnerStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *OwnerStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOwnerStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *OwnerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOwnerStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OwnerStatement() (localctx IOwnerStatementContext) {
|
|
localctx = NewOwnerStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 64, MySqlParserRULE_ownerStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1436)
|
|
p.Match(MySqlParserDEFINER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1437)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1440)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 124, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(1438)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(1439)
|
|
p.CurrentUserExpression()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IScheduleExpressionContext is an interface to support dynamic dispatch.
|
|
type IScheduleExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsScheduleExpressionContext differentiates from other interfaces.
|
|
IsScheduleExpressionContext()
|
|
}
|
|
|
|
type ScheduleExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyScheduleExpressionContext() *ScheduleExpressionContext {
|
|
var p = new(ScheduleExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_scheduleExpression
|
|
return p
|
|
}
|
|
|
|
func InitEmptyScheduleExpressionContext(p *ScheduleExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_scheduleExpression
|
|
}
|
|
|
|
func (*ScheduleExpressionContext) IsScheduleExpressionContext() {}
|
|
|
|
func NewScheduleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScheduleExpressionContext {
|
|
var p = new(ScheduleExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_scheduleExpression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ScheduleExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ScheduleExpressionContext) CopyAll(ctx *ScheduleExpressionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ScheduleExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ScheduleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PreciseScheduleContext struct {
|
|
ScheduleExpressionContext
|
|
}
|
|
|
|
func NewPreciseScheduleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreciseScheduleContext {
|
|
var p = new(PreciseScheduleContext)
|
|
|
|
InitEmptyScheduleExpressionContext(&p.ScheduleExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ScheduleExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) AT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAT, 0)
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) TimestampValue() ITimestampValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITimestampValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITimestampValueContext)
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) AllIntervalExpr() []IIntervalExprContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIntervalExprContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIntervalExprContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIntervalExprContext); ok {
|
|
tst[i] = t.(IIntervalExprContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) IntervalExpr(i int) IIntervalExprContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalExprContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalExprContext)
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPreciseSchedule(s)
|
|
}
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPreciseSchedule(s)
|
|
}
|
|
}
|
|
|
|
func (s *PreciseScheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPreciseSchedule(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IntervalScheduleContext struct {
|
|
ScheduleExpressionContext
|
|
startTimestamp ITimestampValueContext
|
|
_intervalExpr IIntervalExprContext
|
|
startIntervals []IIntervalExprContext
|
|
endTimestamp ITimestampValueContext
|
|
endIntervals []IIntervalExprContext
|
|
}
|
|
|
|
func NewIntervalScheduleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntervalScheduleContext {
|
|
var p = new(IntervalScheduleContext)
|
|
|
|
InitEmptyScheduleExpressionContext(&p.ScheduleExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ScheduleExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) GetStartTimestamp() ITimestampValueContext { return s.startTimestamp }
|
|
|
|
func (s *IntervalScheduleContext) Get_intervalExpr() IIntervalExprContext { return s._intervalExpr }
|
|
|
|
func (s *IntervalScheduleContext) GetEndTimestamp() ITimestampValueContext { return s.endTimestamp }
|
|
|
|
func (s *IntervalScheduleContext) SetStartTimestamp(v ITimestampValueContext) { s.startTimestamp = v }
|
|
|
|
func (s *IntervalScheduleContext) Set_intervalExpr(v IIntervalExprContext) { s._intervalExpr = v }
|
|
|
|
func (s *IntervalScheduleContext) SetEndTimestamp(v ITimestampValueContext) { s.endTimestamp = v }
|
|
|
|
func (s *IntervalScheduleContext) GetStartIntervals() []IIntervalExprContext { return s.startIntervals }
|
|
|
|
func (s *IntervalScheduleContext) GetEndIntervals() []IIntervalExprContext { return s.endIntervals }
|
|
|
|
func (s *IntervalScheduleContext) SetStartIntervals(v []IIntervalExprContext) { s.startIntervals = v }
|
|
|
|
func (s *IntervalScheduleContext) SetEndIntervals(v []IIntervalExprContext) { s.endIntervals = v }
|
|
|
|
func (s *IntervalScheduleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) EVERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVERY, 0)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) IntervalType() IIntervalTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeContext)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) STARTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTARTS, 0)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) ENDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENDS, 0)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) AllTimestampValue() []ITimestampValueContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITimestampValueContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITimestampValueContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITimestampValueContext); ok {
|
|
tst[i] = t.(ITimestampValueContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) TimestampValue(i int) ITimestampValueContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITimestampValueContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITimestampValueContext)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) AllIntervalExpr() []IIntervalExprContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIntervalExprContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIntervalExprContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIntervalExprContext); ok {
|
|
tst[i] = t.(IIntervalExprContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) IntervalExpr(i int) IIntervalExprContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalExprContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalExprContext)
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIntervalSchedule(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIntervalSchedule(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalScheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIntervalSchedule(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ScheduleExpression() (localctx IScheduleExpressionContext) {
|
|
localctx = NewScheduleExpressionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 66, MySqlParserRULE_scheduleExpression)
|
|
var _la int
|
|
|
|
p.SetState(1476)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserAT:
|
|
localctx = NewPreciseScheduleContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1442)
|
|
p.Match(MySqlParserAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1443)
|
|
p.TimestampValue()
|
|
}
|
|
p.SetState(1447)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserPLUS {
|
|
{
|
|
p.SetState(1444)
|
|
p.IntervalExpr()
|
|
}
|
|
|
|
p.SetState(1449)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case MySqlParserEVERY:
|
|
localctx = NewIntervalScheduleContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1450)
|
|
p.Match(MySqlParserEVERY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1453)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(1451)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(1452)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1455)
|
|
p.IntervalType()
|
|
}
|
|
p.SetState(1464)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTARTS {
|
|
{
|
|
p.SetState(1456)
|
|
p.Match(MySqlParserSTARTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1457)
|
|
|
|
var _x = p.TimestampValue()
|
|
|
|
localctx.(*IntervalScheduleContext).startTimestamp = _x
|
|
}
|
|
p.SetState(1461)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserPLUS {
|
|
{
|
|
p.SetState(1458)
|
|
|
|
var _x = p.IntervalExpr()
|
|
|
|
localctx.(*IntervalScheduleContext)._intervalExpr = _x
|
|
}
|
|
localctx.(*IntervalScheduleContext).startIntervals = append(localctx.(*IntervalScheduleContext).startIntervals, localctx.(*IntervalScheduleContext)._intervalExpr)
|
|
|
|
p.SetState(1463)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(1474)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENDS {
|
|
{
|
|
p.SetState(1466)
|
|
p.Match(MySqlParserENDS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1467)
|
|
|
|
var _x = p.TimestampValue()
|
|
|
|
localctx.(*IntervalScheduleContext).endTimestamp = _x
|
|
}
|
|
p.SetState(1471)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserPLUS {
|
|
{
|
|
p.SetState(1468)
|
|
|
|
var _x = p.IntervalExpr()
|
|
|
|
localctx.(*IntervalScheduleContext)._intervalExpr = _x
|
|
}
|
|
localctx.(*IntervalScheduleContext).endIntervals = append(localctx.(*IntervalScheduleContext).endIntervals, localctx.(*IntervalScheduleContext)._intervalExpr)
|
|
|
|
p.SetState(1473)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITimestampValueContext is an interface to support dynamic dispatch.
|
|
type ITimestampValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CURRENT_TIMESTAMP() antlr.TerminalNode
|
|
StringLiteral() IStringLiteralContext
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
Expression() IExpressionContext
|
|
|
|
// IsTimestampValueContext differentiates from other interfaces.
|
|
IsTimestampValueContext()
|
|
}
|
|
|
|
type TimestampValueContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTimestampValueContext() *TimestampValueContext {
|
|
var p = new(TimestampValueContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_timestampValue
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTimestampValueContext(p *TimestampValueContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_timestampValue
|
|
}
|
|
|
|
func (*TimestampValueContext) IsTimestampValueContext() {}
|
|
|
|
func NewTimestampValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimestampValueContext {
|
|
var p = new(TimestampValueContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_timestampValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TimestampValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TimestampValueContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *TimestampValueContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *TimestampValueContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TimestampValueContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *TimestampValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TimestampValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TimestampValueContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTimestampValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *TimestampValueContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTimestampValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *TimestampValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTimestampValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TimestampValue() (localctx ITimestampValueContext) {
|
|
localctx = NewTimestampValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 68, MySqlParserRULE_timestampValue)
|
|
p.SetState(1482)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 132, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1478)
|
|
p.Match(MySqlParserCURRENT_TIMESTAMP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1479)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1480)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1481)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIntervalExprContext is an interface to support dynamic dispatch.
|
|
type IIntervalExprContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
PLUS() antlr.TerminalNode
|
|
INTERVAL() antlr.TerminalNode
|
|
IntervalType() IIntervalTypeContext
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
Expression() IExpressionContext
|
|
|
|
// IsIntervalExprContext differentiates from other interfaces.
|
|
IsIntervalExprContext()
|
|
}
|
|
|
|
type IntervalExprContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIntervalExprContext() *IntervalExprContext {
|
|
var p = new(IntervalExprContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalExpr
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIntervalExprContext(p *IntervalExprContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalExpr
|
|
}
|
|
|
|
func (*IntervalExprContext) IsIntervalExprContext() {}
|
|
|
|
func NewIntervalExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalExprContext {
|
|
var p = new(IntervalExprContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_intervalExpr
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IntervalExprContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IntervalExprContext) PLUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUS, 0)
|
|
}
|
|
|
|
func (s *IntervalExprContext) INTERVAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERVAL, 0)
|
|
}
|
|
|
|
func (s *IntervalExprContext) IntervalType() IIntervalTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeContext)
|
|
}
|
|
|
|
func (s *IntervalExprContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *IntervalExprContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *IntervalExprContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IntervalExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IntervalExprContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIntervalExpr(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalExprContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIntervalExpr(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIntervalExpr(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IntervalExpr() (localctx IIntervalExprContext) {
|
|
localctx = NewIntervalExprContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 70, MySqlParserRULE_intervalExpr)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1484)
|
|
p.Match(MySqlParserPLUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1485)
|
|
p.Match(MySqlParserINTERVAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1488)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(1486)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(1487)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(1490)
|
|
p.IntervalType()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIntervalTypeContext is an interface to support dynamic dispatch.
|
|
type IIntervalTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
IntervalTypeBase() IIntervalTypeBaseContext
|
|
YEAR() antlr.TerminalNode
|
|
YEAR_MONTH() antlr.TerminalNode
|
|
DAY_HOUR() antlr.TerminalNode
|
|
DAY_MINUTE() antlr.TerminalNode
|
|
DAY_SECOND() antlr.TerminalNode
|
|
HOUR_MINUTE() antlr.TerminalNode
|
|
HOUR_SECOND() antlr.TerminalNode
|
|
MINUTE_SECOND() antlr.TerminalNode
|
|
SECOND_MICROSECOND() antlr.TerminalNode
|
|
MINUTE_MICROSECOND() antlr.TerminalNode
|
|
HOUR_MICROSECOND() antlr.TerminalNode
|
|
DAY_MICROSECOND() antlr.TerminalNode
|
|
|
|
// IsIntervalTypeContext differentiates from other interfaces.
|
|
IsIntervalTypeContext()
|
|
}
|
|
|
|
type IntervalTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIntervalTypeContext() *IntervalTypeContext {
|
|
var p = new(IntervalTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIntervalTypeContext(p *IntervalTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalType
|
|
}
|
|
|
|
func (*IntervalTypeContext) IsIntervalTypeContext() {}
|
|
|
|
func NewIntervalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeContext {
|
|
var p = new(IntervalTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_intervalType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IntervalTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IntervalTypeContext) IntervalTypeBase() IIntervalTypeBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeBaseContext)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) YEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) YEAR_MONTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR_MONTH, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) DAY_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY_HOUR, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) DAY_MINUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY_MINUTE, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) DAY_SECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY_SECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) HOUR_MINUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOUR_MINUTE, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) HOUR_SECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOUR_SECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) MINUTE_SECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUTE_SECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) SECOND_MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECOND_MICROSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) MINUTE_MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUTE_MICROSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) HOUR_MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOUR_MICROSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) DAY_MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY_MICROSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IntervalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IntervalTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIntervalType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIntervalType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIntervalType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IntervalType() (localctx IIntervalTypeContext) {
|
|
localctx = NewIntervalTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 72, MySqlParserRULE_intervalType)
|
|
p.SetState(1505)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1492)
|
|
p.IntervalTypeBase()
|
|
}
|
|
|
|
case MySqlParserYEAR:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1493)
|
|
p.Match(MySqlParserYEAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserYEAR_MONTH:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1494)
|
|
p.Match(MySqlParserYEAR_MONTH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDAY_HOUR:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1495)
|
|
p.Match(MySqlParserDAY_HOUR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDAY_MINUTE:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1496)
|
|
p.Match(MySqlParserDAY_MINUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDAY_SECOND:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(1497)
|
|
p.Match(MySqlParserDAY_SECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserHOUR_MINUTE:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(1498)
|
|
p.Match(MySqlParserHOUR_MINUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserHOUR_SECOND:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(1499)
|
|
p.Match(MySqlParserHOUR_SECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMINUTE_SECOND:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(1500)
|
|
p.Match(MySqlParserMINUTE_SECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSECOND_MICROSECOND:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(1501)
|
|
p.Match(MySqlParserSECOND_MICROSECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMINUTE_MICROSECOND:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(1502)
|
|
p.Match(MySqlParserMINUTE_MICROSECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserHOUR_MICROSECOND:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(1503)
|
|
p.Match(MySqlParserHOUR_MICROSECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDAY_MICROSECOND:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(1504)
|
|
p.Match(MySqlParserDAY_MICROSECOND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IEnableTypeContext is an interface to support dynamic dispatch.
|
|
type IEnableTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ENABLE() antlr.TerminalNode
|
|
DISABLE() antlr.TerminalNode
|
|
ON() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
|
|
// IsEnableTypeContext differentiates from other interfaces.
|
|
IsEnableTypeContext()
|
|
}
|
|
|
|
type EnableTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyEnableTypeContext() *EnableTypeContext {
|
|
var p = new(EnableTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_enableType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyEnableTypeContext(p *EnableTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_enableType
|
|
}
|
|
|
|
func (*EnableTypeContext) IsEnableTypeContext() {}
|
|
|
|
func NewEnableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnableTypeContext {
|
|
var p = new(EnableTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_enableType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *EnableTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *EnableTypeContext) ENABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENABLE, 0)
|
|
}
|
|
|
|
func (s *EnableTypeContext) DISABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISABLE, 0)
|
|
}
|
|
|
|
func (s *EnableTypeContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *EnableTypeContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *EnableTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *EnableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *EnableTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterEnableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *EnableTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitEnableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *EnableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitEnableType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) EnableType() (localctx IEnableTypeContext) {
|
|
localctx = NewEnableTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 74, MySqlParserRULE_enableType)
|
|
p.SetState(1512)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 135, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1507)
|
|
p.Match(MySqlParserENABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1508)
|
|
p.Match(MySqlParserDISABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1509)
|
|
p.Match(MySqlParserDISABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1510)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1511)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexTypeContext is an interface to support dynamic dispatch.
|
|
type IIndexTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
USING() antlr.TerminalNode
|
|
BTREE() antlr.TerminalNode
|
|
HASH() antlr.TerminalNode
|
|
|
|
// IsIndexTypeContext differentiates from other interfaces.
|
|
IsIndexTypeContext()
|
|
}
|
|
|
|
type IndexTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIndexTypeContext() *IndexTypeContext {
|
|
var p = new(IndexTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexTypeContext(p *IndexTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexType
|
|
}
|
|
|
|
func (*IndexTypeContext) IsIndexTypeContext() {}
|
|
|
|
func NewIndexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexTypeContext {
|
|
var p = new(IndexTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexTypeContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *IndexTypeContext) BTREE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBTREE, 0)
|
|
}
|
|
|
|
func (s *IndexTypeContext) HASH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHASH, 0)
|
|
}
|
|
|
|
func (s *IndexTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexType() (localctx IIndexTypeContext) {
|
|
localctx = NewIndexTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 76, MySqlParserRULE_indexType)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1514)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1515)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBTREE || _la == MySqlParserHASH) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexOptionContext is an interface to support dynamic dispatch.
|
|
type IIndexOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
KEY_BLOCK_SIZE() antlr.TerminalNode
|
|
FileSizeLiteral() IFileSizeLiteralContext
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
IndexType() IIndexTypeContext
|
|
WITH() antlr.TerminalNode
|
|
PARSER() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
COMMENT() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
VISIBLE() antlr.TerminalNode
|
|
INVISIBLE() antlr.TerminalNode
|
|
ENGINE_ATTRIBUTE() antlr.TerminalNode
|
|
SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode
|
|
|
|
// IsIndexOptionContext differentiates from other interfaces.
|
|
IsIndexOptionContext()
|
|
}
|
|
|
|
type IndexOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIndexOptionContext() *IndexOptionContext {
|
|
var p = new(IndexOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexOptionContext(p *IndexOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexOption
|
|
}
|
|
|
|
func (*IndexOptionContext) IsIndexOptionContext() {}
|
|
|
|
func NewIndexOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexOptionContext {
|
|
var p = new(IndexOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexOptionContext) KEY_BLOCK_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) FileSizeLiteral() IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *IndexOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *IndexOptionContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) PARSER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARSER, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *IndexOptionContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) VISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVISIBLE, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) INVISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVISIBLE, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *IndexOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexOption() (localctx IIndexOptionContext) {
|
|
localctx = NewIndexOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 78, MySqlParserRULE_indexOption)
|
|
var _la int
|
|
|
|
p.SetState(1539)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserKEY_BLOCK_SIZE:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1517)
|
|
p.Match(MySqlParserKEY_BLOCK_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1519)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1518)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1521)
|
|
p.FileSizeLiteral()
|
|
}
|
|
|
|
case MySqlParserUSING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1522)
|
|
p.IndexType()
|
|
}
|
|
|
|
case MySqlParserWITH:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1523)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1524)
|
|
p.Match(MySqlParserPARSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1525)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserCOMMENT:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1526)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1527)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserINVISIBLE, MySqlParserVISIBLE:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1528)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserENGINE_ATTRIBUTE:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(1529)
|
|
p.Match(MySqlParserENGINE_ATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1531)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1530)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1533)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSECONDARY_ENGINE_ATTRIBUTE:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(1534)
|
|
p.Match(MySqlParserSECONDARY_ENGINE_ATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1536)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1535)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1538)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IProcedureParameterContext is an interface to support dynamic dispatch.
|
|
type IProcedureParameterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDirection returns the direction token.
|
|
GetDirection() antlr.Token
|
|
|
|
// SetDirection sets the direction token.
|
|
SetDirection(antlr.Token)
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
DataType() IDataTypeContext
|
|
IN() antlr.TerminalNode
|
|
OUT() antlr.TerminalNode
|
|
INOUT() antlr.TerminalNode
|
|
|
|
// IsProcedureParameterContext differentiates from other interfaces.
|
|
IsProcedureParameterContext()
|
|
}
|
|
|
|
type ProcedureParameterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
direction antlr.Token
|
|
}
|
|
|
|
func NewEmptyProcedureParameterContext() *ProcedureParameterContext {
|
|
var p = new(ProcedureParameterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_procedureParameter
|
|
return p
|
|
}
|
|
|
|
func InitEmptyProcedureParameterContext(p *ProcedureParameterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_procedureParameter
|
|
}
|
|
|
|
func (*ProcedureParameterContext) IsProcedureParameterContext() {}
|
|
|
|
func NewProcedureParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProcedureParameterContext {
|
|
var p = new(ProcedureParameterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_procedureParameter
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ProcedureParameterContext) GetDirection() antlr.Token { return s.direction }
|
|
|
|
func (s *ProcedureParameterContext) SetDirection(v antlr.Token) { s.direction = v }
|
|
|
|
func (s *ProcedureParameterContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) OUT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOUT, 0)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) INOUT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINOUT, 0)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterProcedureParameter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitProcedureParameter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ProcedureParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitProcedureParameter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ProcedureParameter() (localctx IProcedureParameterContext) {
|
|
localctx = NewProcedureParameterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 80, MySqlParserRULE_procedureParameter)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(1542)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if (int64((_la-80)) & ^0x3f) == 0 && ((int64(1)<<(_la-80))&35184372088849) != 0 {
|
|
{
|
|
p.SetState(1541)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ProcedureParameterContext).direction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-80)) & ^0x3f) == 0 && ((int64(1)<<(_la-80))&35184372088849) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ProcedureParameterContext).direction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1544)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(1545)
|
|
p.DataType()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFunctionParameterContext is an interface to support dynamic dispatch.
|
|
type IFunctionParameterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
DataType() IDataTypeContext
|
|
|
|
// IsFunctionParameterContext differentiates from other interfaces.
|
|
IsFunctionParameterContext()
|
|
}
|
|
|
|
type FunctionParameterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFunctionParameterContext() *FunctionParameterContext {
|
|
var p = new(FunctionParameterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionParameter
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFunctionParameterContext(p *FunctionParameterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionParameter
|
|
}
|
|
|
|
func (*FunctionParameterContext) IsFunctionParameterContext() {}
|
|
|
|
func NewFunctionParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionParameterContext {
|
|
var p = new(FunctionParameterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_functionParameter
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionParameterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FunctionParameterContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *FunctionParameterContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *FunctionParameterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FunctionParameterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFunctionParameter(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionParameterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFunctionParameter(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFunctionParameter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FunctionParameter() (localctx IFunctionParameterContext) {
|
|
localctx = NewFunctionParameterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 82, MySqlParserRULE_functionParameter)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1547)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(1548)
|
|
p.DataType()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRoutineOptionContext is an interface to support dynamic dispatch.
|
|
type IRoutineOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsRoutineOptionContext differentiates from other interfaces.
|
|
IsRoutineOptionContext()
|
|
}
|
|
|
|
type RoutineOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRoutineOptionContext() *RoutineOptionContext {
|
|
var p = new(RoutineOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_routineOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRoutineOptionContext(p *RoutineOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_routineOption
|
|
}
|
|
|
|
func (*RoutineOptionContext) IsRoutineOptionContext() {}
|
|
|
|
func NewRoutineOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineOptionContext {
|
|
var p = new(RoutineOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_routineOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RoutineOptionContext) CopyAll(ctx *RoutineOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *RoutineOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type RoutineBehaviorContext struct {
|
|
RoutineOptionContext
|
|
}
|
|
|
|
func NewRoutineBehaviorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineBehaviorContext {
|
|
var p = new(RoutineBehaviorContext)
|
|
|
|
InitEmptyRoutineOptionContext(&p.RoutineOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RoutineOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) DETERMINISTIC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDETERMINISTIC, 0)
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineBehavior(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineBehavior(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineBehaviorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineBehavior(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RoutineLanguageContext struct {
|
|
RoutineOptionContext
|
|
}
|
|
|
|
func NewRoutineLanguageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineLanguageContext {
|
|
var p = new(RoutineLanguageContext)
|
|
|
|
InitEmptyRoutineOptionContext(&p.RoutineOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RoutineOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) LANGUAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLANGUAGE, 0)
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) SQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL, 0)
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineLanguage(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineLanguage(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineLanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineLanguage(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RoutineCommentContext struct {
|
|
RoutineOptionContext
|
|
}
|
|
|
|
func NewRoutineCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineCommentContext {
|
|
var p = new(RoutineCommentContext)
|
|
|
|
InitEmptyRoutineOptionContext(&p.RoutineOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RoutineOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineCommentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineCommentContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *RoutineCommentContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *RoutineCommentContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineCommentContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineComment(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RoutineSecurityContext struct {
|
|
RoutineOptionContext
|
|
context antlr.Token
|
|
}
|
|
|
|
func NewRoutineSecurityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineSecurityContext {
|
|
var p = new(RoutineSecurityContext)
|
|
|
|
InitEmptyRoutineOptionContext(&p.RoutineOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RoutineOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) GetContext() antlr.Token { return s.context }
|
|
|
|
func (s *RoutineSecurityContext) SetContext(v antlr.Token) { s.context = v }
|
|
|
|
func (s *RoutineSecurityContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) SQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL, 0)
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) SECURITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECURITY, 0)
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) DEFINER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFINER, 0)
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) INVOKER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKER, 0)
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineSecurity(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineSecurity(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineSecurityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineSecurity(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RoutineDataContext struct {
|
|
RoutineOptionContext
|
|
}
|
|
|
|
func NewRoutineDataContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineDataContext {
|
|
var p = new(RoutineDataContext)
|
|
|
|
InitEmptyRoutineOptionContext(&p.RoutineOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RoutineOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineDataContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineDataContext) CONTAINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTAINS, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) SQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) NO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) READS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREADS, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) MODIFIES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODIFIES, 0)
|
|
}
|
|
|
|
func (s *RoutineDataContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineData(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineDataContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineData(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineDataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineData(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RoutineOption() (localctx IRoutineOptionContext) {
|
|
localctx = NewRoutineOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 84, MySqlParserRULE_routineOption)
|
|
var _la int
|
|
|
|
p.SetState(1573)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCOMMENT:
|
|
localctx = NewRoutineCommentContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1550)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1551)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLANGUAGE:
|
|
localctx = NewRoutineLanguageContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1552)
|
|
p.Match(MySqlParserLANGUAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1553)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDETERMINISTIC, MySqlParserNOT:
|
|
localctx = NewRoutineBehaviorContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(1555)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(1554)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1557)
|
|
p.Match(MySqlParserDETERMINISTIC)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMODIFIES, MySqlParserREADS, MySqlParserCONTAINS, MySqlParserNO:
|
|
localctx = NewRoutineDataContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
p.SetState(1568)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCONTAINS:
|
|
{
|
|
p.SetState(1558)
|
|
p.Match(MySqlParserCONTAINS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1559)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserNO:
|
|
{
|
|
p.SetState(1560)
|
|
p.Match(MySqlParserNO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1561)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREADS:
|
|
{
|
|
p.SetState(1562)
|
|
p.Match(MySqlParserREADS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1563)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1564)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMODIFIES:
|
|
{
|
|
p.SetState(1565)
|
|
p.Match(MySqlParserMODIFIES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1566)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1567)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserSQL:
|
|
localctx = NewRoutineSecurityContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1570)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1571)
|
|
p.Match(MySqlParserSECURITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1572)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*RoutineSecurityContext).context = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*RoutineSecurityContext).context = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IServerOptionContext is an interface to support dynamic dispatch.
|
|
type IServerOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HOST() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
DATABASE() antlr.TerminalNode
|
|
USER() antlr.TerminalNode
|
|
PASSWORD() antlr.TerminalNode
|
|
SOCKET() antlr.TerminalNode
|
|
OWNER() antlr.TerminalNode
|
|
PORT() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
|
|
// IsServerOptionContext differentiates from other interfaces.
|
|
IsServerOptionContext()
|
|
}
|
|
|
|
type ServerOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyServerOptionContext() *ServerOptionContext {
|
|
var p = new(ServerOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_serverOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyServerOptionContext(p *ServerOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_serverOption
|
|
}
|
|
|
|
func (*ServerOptionContext) IsServerOptionContext() {}
|
|
|
|
func NewServerOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServerOptionContext {
|
|
var p = new(ServerOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_serverOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ServerOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ServerOptionContext) HOST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOST, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) SOCKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOCKET, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) OWNER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOWNER, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) PORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPORT, 0)
|
|
}
|
|
|
|
func (s *ServerOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ServerOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ServerOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ServerOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterServerOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ServerOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitServerOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ServerOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitServerOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ServerOption() (localctx IServerOptionContext) {
|
|
localctx = NewServerOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 86, MySqlParserRULE_serverOption)
|
|
p.SetState(1589)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserHOST:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1575)
|
|
p.Match(MySqlParserHOST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1576)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDATABASE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1577)
|
|
p.Match(MySqlParserDATABASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1578)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUSER:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1579)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1580)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPASSWORD:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1581)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1582)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSOCKET:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1583)
|
|
p.Match(MySqlParserSOCKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1584)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserOWNER:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(1585)
|
|
p.Match(MySqlParserOWNER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1586)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPORT:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(1587)
|
|
p.Match(MySqlParserPORT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1588)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateDefinitionsContext is an interface to support dynamic dispatch.
|
|
type ICreateDefinitionsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllCreateDefinition() []ICreateDefinitionContext
|
|
CreateDefinition(i int) ICreateDefinitionContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsCreateDefinitionsContext differentiates from other interfaces.
|
|
IsCreateDefinitionsContext()
|
|
}
|
|
|
|
type CreateDefinitionsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateDefinitionsContext() *CreateDefinitionsContext {
|
|
var p = new(CreateDefinitionsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDefinitions
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateDefinitionsContext(p *CreateDefinitionsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDefinitions
|
|
}
|
|
|
|
func (*CreateDefinitionsContext) IsCreateDefinitionsContext() {}
|
|
|
|
func NewCreateDefinitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDefinitionsContext {
|
|
var p = new(CreateDefinitionsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createDefinitions
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateDefinitionsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) AllCreateDefinition() []ICreateDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICreateDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICreateDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICreateDefinitionContext); ok {
|
|
tst[i] = t.(ICreateDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) CreateDefinition(i int) ICreateDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDefinitionContext)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateDefinitions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateDefinitions() (localctx ICreateDefinitionsContext) {
|
|
localctx = NewCreateDefinitionsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 88, MySqlParserRULE_createDefinitions)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1591)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1592)
|
|
p.CreateDefinition()
|
|
}
|
|
p.SetState(1597)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(1593)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1594)
|
|
p.CreateDefinition()
|
|
}
|
|
|
|
p.SetState(1599)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(1600)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateDefinitionContext is an interface to support dynamic dispatch.
|
|
type ICreateDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsCreateDefinitionContext differentiates from other interfaces.
|
|
IsCreateDefinitionContext()
|
|
}
|
|
|
|
type CreateDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateDefinitionContext() *CreateDefinitionContext {
|
|
var p = new(CreateDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateDefinitionContext(p *CreateDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createDefinition
|
|
}
|
|
|
|
func (*CreateDefinitionContext) IsCreateDefinitionContext() {}
|
|
|
|
func NewCreateDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDefinitionContext {
|
|
var p = new(CreateDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateDefinitionContext) CopyAll(ctx *CreateDefinitionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *CreateDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type ColumnDeclarationContext struct {
|
|
CreateDefinitionContext
|
|
}
|
|
|
|
func NewColumnDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ColumnDeclarationContext {
|
|
var p = new(ColumnDeclarationContext)
|
|
|
|
InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) ColumnDefinition() IColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterColumnDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitColumnDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitColumnDeclaration(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ConstraintDeclarationContext struct {
|
|
CreateDefinitionContext
|
|
}
|
|
|
|
func NewConstraintDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstraintDeclarationContext {
|
|
var p = new(ConstraintDeclarationContext)
|
|
|
|
InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) TableConstraint() ITableConstraintContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableConstraintContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableConstraintContext)
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) ENFORCED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENFORCED, 0)
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterConstraintDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitConstraintDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstraintDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitConstraintDeclaration(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IndexDeclarationContext struct {
|
|
CreateDefinitionContext
|
|
}
|
|
|
|
func NewIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexDeclarationContext {
|
|
var p = new(IndexDeclarationContext)
|
|
|
|
InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexDeclarationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexDeclarationContext) IndexColumnDefinition() IIndexColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *IndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexDeclaration(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateDefinition() (localctx ICreateDefinitionContext) {
|
|
localctx = NewCreateDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 90, MySqlParserRULE_createDefinition)
|
|
var _la int
|
|
|
|
p.SetState(1613)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 148, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewColumnDeclarationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1602)
|
|
p.FullColumnName()
|
|
}
|
|
{
|
|
p.SetState(1603)
|
|
p.ColumnDefinition()
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewConstraintDeclarationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1605)
|
|
p.TableConstraint()
|
|
}
|
|
p.SetState(1607)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(1606)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1610)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENFORCED {
|
|
{
|
|
p.SetState(1609)
|
|
p.Match(MySqlParserENFORCED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewIndexDeclarationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1612)
|
|
p.IndexColumnDefinition()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IColumnDefinitionContext is an interface to support dynamic dispatch.
|
|
type IColumnDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DataType() IDataTypeContext
|
|
AllColumnConstraint() []IColumnConstraintContext
|
|
ColumnConstraint(i int) IColumnConstraintContext
|
|
NOT() antlr.TerminalNode
|
|
ENFORCED() antlr.TerminalNode
|
|
|
|
// IsColumnDefinitionContext differentiates from other interfaces.
|
|
IsColumnDefinitionContext()
|
|
}
|
|
|
|
type ColumnDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyColumnDefinitionContext() *ColumnDefinitionContext {
|
|
var p = new(ColumnDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_columnDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyColumnDefinitionContext(p *ColumnDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_columnDefinition
|
|
}
|
|
|
|
func (*ColumnDefinitionContext) IsColumnDefinitionContext() {}
|
|
|
|
func NewColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionContext {
|
|
var p = new(ColumnDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_columnDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ColumnDefinitionContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) AllColumnConstraint() []IColumnConstraintContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IColumnConstraintContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IColumnConstraintContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IColumnConstraintContext); ok {
|
|
tst[i] = t.(IColumnConstraintContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) ColumnConstraint(i int) IColumnConstraintContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnConstraintContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnConstraintContext)
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) ENFORCED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENFORCED, 0)
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterColumnDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitColumnDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *ColumnDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitColumnDefinition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) {
|
|
localctx = NewColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 92, MySqlParserRULE_columnDefinition)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1615)
|
|
p.DataType()
|
|
}
|
|
p.SetState(1619)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(1616)
|
|
p.ColumnConstraint()
|
|
}
|
|
|
|
}
|
|
p.SetState(1621)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1623)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(1622)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1626)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENFORCED {
|
|
{
|
|
p.SetState(1625)
|
|
p.Match(MySqlParserENFORCED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IColumnConstraintContext is an interface to support dynamic dispatch.
|
|
type IColumnConstraintContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsColumnConstraintContext differentiates from other interfaces.
|
|
IsColumnConstraintContext()
|
|
}
|
|
|
|
type ColumnConstraintContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyColumnConstraintContext() *ColumnConstraintContext {
|
|
var p = new(ColumnConstraintContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_columnConstraint
|
|
return p
|
|
}
|
|
|
|
func InitEmptyColumnConstraintContext(p *ColumnConstraintContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_columnConstraint
|
|
}
|
|
|
|
func (*ColumnConstraintContext) IsColumnConstraintContext() {}
|
|
|
|
func NewColumnConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnConstraintContext {
|
|
var p = new(ColumnConstraintContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_columnConstraint
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ColumnConstraintContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ColumnConstraintContext) CopyAll(ctx *ColumnConstraintContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ColumnConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type StorageColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
storageval antlr.Token
|
|
}
|
|
|
|
func NewStorageColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StorageColumnConstraintContext {
|
|
var p = new(StorageColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) GetStorageval() antlr.Token { return s.storageval }
|
|
|
|
func (s *StorageColumnConstraintContext) SetStorageval(v antlr.Token) { s.storageval = v }
|
|
|
|
func (s *StorageColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) STORAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORAGE, 0)
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) DISK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISK, 0)
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) MEMORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMORY, 0)
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStorageColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStorageColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *StorageColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStorageColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type VisibilityColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewVisibilityColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VisibilityColumnConstraintContext {
|
|
var p = new(VisibilityColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *VisibilityColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *VisibilityColumnConstraintContext) VISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVISIBLE, 0)
|
|
}
|
|
|
|
func (s *VisibilityColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterVisibilityColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *VisibilityColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitVisibilityColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *VisibilityColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitVisibilityColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AutoIncrementColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewAutoIncrementColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AutoIncrementColumnConstraintContext {
|
|
var p = new(AutoIncrementColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) AUTO_INCREMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTO_INCREMENT, 0)
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) CurrentTimestamp() ICurrentTimestampContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICurrentTimestampContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICurrentTimestampContext)
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAutoIncrementColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAutoIncrementColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AutoIncrementColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAutoIncrementColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CommentColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewCommentColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CommentColumnConstraintContext {
|
|
var p = new(CommentColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCommentColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCommentColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommentColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCommentColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type UniqueKeyColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewUniqueKeyColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UniqueKeyColumnConstraintContext {
|
|
var p = new(UniqueKeyColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) UNIQUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNIQUE, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUniqueKeyColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUniqueKeyColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *UniqueKeyColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUniqueKeyColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SerialDefaultColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewSerialDefaultColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SerialDefaultColumnConstraintContext {
|
|
var p = new(SerialDefaultColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) SERIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERIAL, 0)
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSerialDefaultColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSerialDefaultColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *SerialDefaultColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSerialDefaultColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type GeneratedColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewGeneratedColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GeneratedColumnConstraintContext {
|
|
var p = new(GeneratedColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) GENERATED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGENERATED, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) ALWAYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALWAYS, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) VIRTUAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIRTUAL, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) STORED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORED, 0)
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGeneratedColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGeneratedColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *GeneratedColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGeneratedColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type FormatColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
colformat antlr.Token
|
|
}
|
|
|
|
func NewFormatColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FormatColumnConstraintContext {
|
|
var p = new(FormatColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) GetColformat() antlr.Token { return s.colformat }
|
|
|
|
func (s *FormatColumnConstraintContext) SetColformat(v antlr.Token) { s.colformat = v }
|
|
|
|
func (s *FormatColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) COLUMN_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN_FORMAT, 0)
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) FIXED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIXED, 0)
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) DYNAMIC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDYNAMIC, 0)
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFormatColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFormatColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *FormatColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFormatColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CollateColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewCollateColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollateColumnConstraintContext {
|
|
var p = new(CollateColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCollateColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCollateColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollateColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCollateColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PrimaryKeyColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewPrimaryKeyColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryKeyColumnConstraintContext {
|
|
var p = new(PrimaryKeyColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) PRIMARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIMARY, 0)
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrimaryKeyColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrimaryKeyColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrimaryKeyColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrimaryKeyColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CheckColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
name IUidContext
|
|
}
|
|
|
|
func NewCheckColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CheckColumnConstraintContext {
|
|
var p = new(CheckColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *CheckColumnConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *CheckColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCheckColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCheckColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCheckColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NullColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewNullColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullColumnConstraintContext {
|
|
var p = new(NullColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NullColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NullColumnConstraintContext) NullNotnull() INullNotnullContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(INullNotnullContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(INullNotnullContext)
|
|
}
|
|
|
|
func (s *NullColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNullColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *NullColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNullColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *NullColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNullColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DefaultColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewDefaultColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefaultColumnConstraintContext {
|
|
var p = new(DefaultColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) DefaultValue() IDefaultValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDefaultValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDefaultValueContext)
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefaultColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefaultColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefaultColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ReferenceColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewReferenceColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReferenceColumnConstraintContext {
|
|
var p = new(ReferenceColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReferenceColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReferenceColumnConstraintContext) ReferenceDefinition() IReferenceDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReferenceDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReferenceDefinitionContext)
|
|
}
|
|
|
|
func (s *ReferenceColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReferenceColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReferenceColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReferenceColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type InvisibilityColumnConstraintContext struct {
|
|
ColumnConstraintContext
|
|
}
|
|
|
|
func NewInvisibilityColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InvisibilityColumnConstraintContext {
|
|
var p = new(InvisibilityColumnConstraintContext)
|
|
|
|
InitEmptyColumnConstraintContext(&p.ColumnConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ColumnConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InvisibilityColumnConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InvisibilityColumnConstraintContext) INVISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVISIBLE, 0)
|
|
}
|
|
|
|
func (s *InvisibilityColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInvisibilityColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *InvisibilityColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInvisibilityColumnConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *InvisibilityColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInvisibilityColumnConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ColumnConstraint() (localctx IColumnConstraintContext) {
|
|
localctx = NewColumnConstraintContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 94, MySqlParserRULE_columnConstraint)
|
|
var _la int
|
|
|
|
p.SetState(1681)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNOT, MySqlParserNULL_LITERAL, MySqlParserNULL_SPEC_LITERAL:
|
|
localctx = NewNullColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1628)
|
|
p.NullNotnull()
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
localctx = NewDefaultColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1629)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1630)
|
|
p.DefaultValue()
|
|
}
|
|
|
|
case MySqlParserVISIBLE:
|
|
localctx = NewVisibilityColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1631)
|
|
p.Match(MySqlParserVISIBLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserINVISIBLE:
|
|
localctx = NewInvisibilityColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1632)
|
|
p.Match(MySqlParserINVISIBLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserON, MySqlParserAUTO_INCREMENT:
|
|
localctx = NewAutoIncrementColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
p.SetState(1637)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserAUTO_INCREMENT:
|
|
{
|
|
p.SetState(1633)
|
|
p.Match(MySqlParserAUTO_INCREMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserON:
|
|
{
|
|
p.SetState(1634)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1635)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1636)
|
|
p.CurrentTimestamp()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserKEY, MySqlParserPRIMARY:
|
|
localctx = NewPrimaryKeyColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
p.SetState(1640)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPRIMARY {
|
|
{
|
|
p.SetState(1639)
|
|
p.Match(MySqlParserPRIMARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1642)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUNIQUE:
|
|
localctx = NewUniqueKeyColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(1643)
|
|
p.Match(MySqlParserUNIQUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1645)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1644)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserCOMMENT:
|
|
localctx = NewCommentColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(1647)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1648)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCOLUMN_FORMAT:
|
|
localctx = NewFormatColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(1649)
|
|
p.Match(MySqlParserCOLUMN_FORMAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1650)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*FormatColumnConstraintContext).colformat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserDYNAMIC || _la == MySqlParserFIXED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*FormatColumnConstraintContext).colformat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTORAGE:
|
|
localctx = NewStorageColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(1651)
|
|
p.Match(MySqlParserSTORAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1652)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*StorageColumnConstraintContext).storageval = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserDISK || _la == MySqlParserMEMORY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*StorageColumnConstraintContext).storageval = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserREFERENCES:
|
|
localctx = NewReferenceColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(1653)
|
|
p.ReferenceDefinition()
|
|
}
|
|
|
|
case MySqlParserCOLLATE:
|
|
localctx = NewCollateColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(1654)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1655)
|
|
p.CollationName()
|
|
}
|
|
|
|
case MySqlParserAS, MySqlParserGENERATED:
|
|
localctx = NewGeneratedColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
p.SetState(1658)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserGENERATED {
|
|
{
|
|
p.SetState(1656)
|
|
p.Match(MySqlParserGENERATED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1657)
|
|
p.Match(MySqlParserALWAYS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1660)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1661)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1662)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(1663)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1665)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTORED || _la == MySqlParserVIRTUAL {
|
|
{
|
|
p.SetState(1664)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSTORED || _la == MySqlParserVIRTUAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserSERIAL:
|
|
localctx = NewSerialDefaultColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(1667)
|
|
p.Match(MySqlParserSERIAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1668)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1669)
|
|
p.Match(MySqlParserVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHECK, MySqlParserCONSTRAINT:
|
|
localctx = NewCheckColumnConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
p.SetState(1674)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(1670)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1672)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1671)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*CheckColumnConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1676)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1677)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1678)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(1679)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableConstraintContext is an interface to support dynamic dispatch.
|
|
type ITableConstraintContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsTableConstraintContext differentiates from other interfaces.
|
|
IsTableConstraintContext()
|
|
}
|
|
|
|
type TableConstraintContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableConstraintContext() *TableConstraintContext {
|
|
var p = new(TableConstraintContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableConstraint
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableConstraintContext(p *TableConstraintContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableConstraint
|
|
}
|
|
|
|
func (*TableConstraintContext) IsTableConstraintContext() {}
|
|
|
|
func NewTableConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableConstraintContext {
|
|
var p = new(TableConstraintContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableConstraint
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableConstraintContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableConstraintContext) CopyAll(ctx *TableConstraintContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *TableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type UniqueKeyTableConstraintContext struct {
|
|
TableConstraintContext
|
|
name IUidContext
|
|
indexFormat antlr.Token
|
|
index IUidContext
|
|
}
|
|
|
|
func NewUniqueKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UniqueKeyTableConstraintContext {
|
|
var p = new(UniqueKeyTableConstraintContext)
|
|
|
|
InitEmptyTableConstraintContext(&p.TableConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) GetIndex() IUidContext { return s.index }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v }
|
|
|
|
func (s *UniqueKeyTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) UNIQUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNIQUE, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUniqueKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUniqueKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *UniqueKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUniqueKeyTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CheckTableConstraintContext struct {
|
|
TableConstraintContext
|
|
name IUidContext
|
|
}
|
|
|
|
func NewCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CheckTableConstraintContext {
|
|
var p = new(CheckTableConstraintContext)
|
|
|
|
InitEmptyTableConstraintContext(&p.TableConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *CheckTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *CheckTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCheckTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PrimaryKeyTableConstraintContext struct {
|
|
TableConstraintContext
|
|
name IUidContext
|
|
index IUidContext
|
|
}
|
|
|
|
func NewPrimaryKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryKeyTableConstraintContext {
|
|
var p = new(PrimaryKeyTableConstraintContext)
|
|
|
|
InitEmptyTableConstraintContext(&p.TableConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) GetIndex() IUidContext { return s.index }
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v }
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) PRIMARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIMARY, 0)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrimaryKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrimaryKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrimaryKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrimaryKeyTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ForeignKeyTableConstraintContext struct {
|
|
TableConstraintContext
|
|
name IUidContext
|
|
index IUidContext
|
|
}
|
|
|
|
func NewForeignKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForeignKeyTableConstraintContext {
|
|
var p = new(ForeignKeyTableConstraintContext)
|
|
|
|
InitEmptyTableConstraintContext(&p.TableConstraintContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableConstraintContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *ForeignKeyTableConstraintContext) GetIndex() IUidContext { return s.index }
|
|
|
|
func (s *ForeignKeyTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *ForeignKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v }
|
|
|
|
func (s *ForeignKeyTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) FOREIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOREIGN, 0)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) ReferenceDefinition() IReferenceDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReferenceDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReferenceDefinitionContext)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterForeignKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitForeignKeyTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *ForeignKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitForeignKeyTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableConstraint() (localctx ITableConstraintContext) {
|
|
localctx = NewTableConstraintContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 96, MySqlParserRULE_tableConstraint)
|
|
var _la int
|
|
|
|
p.SetState(1752)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 176, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewPrimaryKeyTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(1687)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(1683)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1685)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1684)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*PrimaryKeyTableConstraintContext).name = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1689)
|
|
p.Match(MySqlParserPRIMARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1690)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1692)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1691)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*PrimaryKeyTableConstraintContext).index = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1695)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(1694)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1697)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(1701)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE {
|
|
{
|
|
p.SetState(1698)
|
|
p.IndexOption()
|
|
}
|
|
|
|
p.SetState(1703)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewUniqueKeyTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(1708)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(1704)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1706)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1705)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*UniqueKeyTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1710)
|
|
p.Match(MySqlParserUNIQUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1712)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(1711)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UniqueKeyTableConstraintContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UniqueKeyTableConstraintContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1715)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1714)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*UniqueKeyTableConstraintContext).index = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(1718)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(1717)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1720)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(1724)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE {
|
|
{
|
|
p.SetState(1721)
|
|
p.IndexOption()
|
|
}
|
|
|
|
p.SetState(1726)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewForeignKeyTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(1731)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(1727)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1729)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1728)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*ForeignKeyTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1733)
|
|
p.Match(MySqlParserFOREIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1734)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1736)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1735)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*ForeignKeyTableConstraintContext).index = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1738)
|
|
p.IndexColumnNames()
|
|
}
|
|
{
|
|
p.SetState(1739)
|
|
p.ReferenceDefinition()
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewCheckTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
p.SetState(1745)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(1741)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1743)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1742)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*CheckTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1747)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1748)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1749)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(1750)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReferenceDefinitionContext is an interface to support dynamic dispatch.
|
|
type IReferenceDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetMatchType returns the matchType token.
|
|
GetMatchType() antlr.Token
|
|
|
|
// SetMatchType sets the matchType token.
|
|
SetMatchType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
REFERENCES() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
IndexColumnNames() IIndexColumnNamesContext
|
|
MATCH() antlr.TerminalNode
|
|
ReferenceAction() IReferenceActionContext
|
|
FULL() antlr.TerminalNode
|
|
PARTIAL() antlr.TerminalNode
|
|
SIMPLE() antlr.TerminalNode
|
|
|
|
// IsReferenceDefinitionContext differentiates from other interfaces.
|
|
IsReferenceDefinitionContext()
|
|
}
|
|
|
|
type ReferenceDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
matchType antlr.Token
|
|
}
|
|
|
|
func NewEmptyReferenceDefinitionContext() *ReferenceDefinitionContext {
|
|
var p = new(ReferenceDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReferenceDefinitionContext(p *ReferenceDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceDefinition
|
|
}
|
|
|
|
func (*ReferenceDefinitionContext) IsReferenceDefinitionContext() {}
|
|
|
|
func NewReferenceDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceDefinitionContext {
|
|
var p = new(ReferenceDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_referenceDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReferenceDefinitionContext) GetMatchType() antlr.Token { return s.matchType }
|
|
|
|
func (s *ReferenceDefinitionContext) SetMatchType(v antlr.Token) { s.matchType = v }
|
|
|
|
func (s *ReferenceDefinitionContext) REFERENCES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREFERENCES, 0)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) MATCH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMATCH, 0)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) ReferenceAction() IReferenceActionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReferenceActionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReferenceActionContext)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) FULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULL, 0)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) PARTIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTIAL, 0)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) SIMPLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIMPLE, 0)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReferenceDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReferenceDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReferenceDefinition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReferenceDefinition() (localctx IReferenceDefinitionContext) {
|
|
localctx = NewReferenceDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 98, MySqlParserRULE_referenceDefinition)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1754)
|
|
p.Match(MySqlParserREFERENCES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1755)
|
|
p.TableName()
|
|
}
|
|
p.SetState(1757)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 177, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1756)
|
|
p.IndexColumnNames()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(1761)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserMATCH {
|
|
{
|
|
p.SetState(1759)
|
|
p.Match(MySqlParserMATCH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1760)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ReferenceDefinitionContext).matchType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFULL || _la == MySqlParserPARTIAL || _la == MySqlParserSIMPLE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ReferenceDefinitionContext).matchType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1764)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1763)
|
|
p.ReferenceAction()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReferenceActionContext is an interface to support dynamic dispatch.
|
|
type IReferenceActionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOnDelete returns the onDelete rule contexts.
|
|
GetOnDelete() IReferenceControlTypeContext
|
|
|
|
// GetOnUpdate returns the onUpdate rule contexts.
|
|
GetOnUpdate() IReferenceControlTypeContext
|
|
|
|
// SetOnDelete sets the onDelete rule contexts.
|
|
SetOnDelete(IReferenceControlTypeContext)
|
|
|
|
// SetOnUpdate sets the onUpdate rule contexts.
|
|
SetOnUpdate(IReferenceControlTypeContext)
|
|
|
|
// Getter signatures
|
|
AllON() []antlr.TerminalNode
|
|
ON(i int) antlr.TerminalNode
|
|
DELETE() antlr.TerminalNode
|
|
AllReferenceControlType() []IReferenceControlTypeContext
|
|
ReferenceControlType(i int) IReferenceControlTypeContext
|
|
UPDATE() antlr.TerminalNode
|
|
|
|
// IsReferenceActionContext differentiates from other interfaces.
|
|
IsReferenceActionContext()
|
|
}
|
|
|
|
type ReferenceActionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
onDelete IReferenceControlTypeContext
|
|
onUpdate IReferenceControlTypeContext
|
|
}
|
|
|
|
func NewEmptyReferenceActionContext() *ReferenceActionContext {
|
|
var p = new(ReferenceActionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceAction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReferenceActionContext(p *ReferenceActionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceAction
|
|
}
|
|
|
|
func (*ReferenceActionContext) IsReferenceActionContext() {}
|
|
|
|
func NewReferenceActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceActionContext {
|
|
var p = new(ReferenceActionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_referenceAction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReferenceActionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReferenceActionContext) GetOnDelete() IReferenceControlTypeContext { return s.onDelete }
|
|
|
|
func (s *ReferenceActionContext) GetOnUpdate() IReferenceControlTypeContext { return s.onUpdate }
|
|
|
|
func (s *ReferenceActionContext) SetOnDelete(v IReferenceControlTypeContext) { s.onDelete = v }
|
|
|
|
func (s *ReferenceActionContext) SetOnUpdate(v IReferenceControlTypeContext) { s.onUpdate = v }
|
|
|
|
func (s *ReferenceActionContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) DELETE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELETE, 0)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) AllReferenceControlType() []IReferenceControlTypeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IReferenceControlTypeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IReferenceControlTypeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IReferenceControlTypeContext); ok {
|
|
tst[i] = t.(IReferenceControlTypeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ReferenceActionContext) ReferenceControlType(i int) IReferenceControlTypeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReferenceControlTypeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReferenceControlTypeContext)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReferenceActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReferenceActionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReferenceAction(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceActionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReferenceAction(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReferenceAction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReferenceAction() (localctx IReferenceActionContext) {
|
|
localctx = NewReferenceActionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 100, MySqlParserRULE_referenceAction)
|
|
p.SetState(1782)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1766)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1767)
|
|
p.Match(MySqlParserDELETE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1768)
|
|
|
|
var _x = p.ReferenceControlType()
|
|
|
|
localctx.(*ReferenceActionContext).onDelete = _x
|
|
}
|
|
p.SetState(1772)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 180, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1769)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1770)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1771)
|
|
|
|
var _x = p.ReferenceControlType()
|
|
|
|
localctx.(*ReferenceActionContext).onUpdate = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1774)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1775)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1776)
|
|
|
|
var _x = p.ReferenceControlType()
|
|
|
|
localctx.(*ReferenceActionContext).onUpdate = _x
|
|
}
|
|
p.SetState(1780)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1777)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1778)
|
|
p.Match(MySqlParserDELETE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1779)
|
|
|
|
var _x = p.ReferenceControlType()
|
|
|
|
localctx.(*ReferenceActionContext).onDelete = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReferenceControlTypeContext is an interface to support dynamic dispatch.
|
|
type IReferenceControlTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RESTRICT() antlr.TerminalNode
|
|
CASCADE() antlr.TerminalNode
|
|
SET() antlr.TerminalNode
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
NO() antlr.TerminalNode
|
|
ACTION() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
|
|
// IsReferenceControlTypeContext differentiates from other interfaces.
|
|
IsReferenceControlTypeContext()
|
|
}
|
|
|
|
type ReferenceControlTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyReferenceControlTypeContext() *ReferenceControlTypeContext {
|
|
var p = new(ReferenceControlTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceControlType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReferenceControlTypeContext(p *ReferenceControlTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_referenceControlType
|
|
}
|
|
|
|
func (*ReferenceControlTypeContext) IsReferenceControlTypeContext() {}
|
|
|
|
func NewReferenceControlTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceControlTypeContext {
|
|
var p = new(ReferenceControlTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_referenceControlType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReferenceControlTypeContext) RESTRICT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESTRICT, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) CASCADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADE, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) NO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) ACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserACTION, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReferenceControlType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReferenceControlType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReferenceControlTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReferenceControlType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReferenceControlType() (localctx IReferenceControlTypeContext) {
|
|
localctx = NewReferenceControlTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 102, MySqlParserRULE_referenceControlType)
|
|
p.SetState(1792)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 183, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1784)
|
|
p.Match(MySqlParserRESTRICT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1785)
|
|
p.Match(MySqlParserCASCADE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1786)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1787)
|
|
p.Match(MySqlParserNULL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1788)
|
|
p.Match(MySqlParserNO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1789)
|
|
p.Match(MySqlParserACTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1790)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1791)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexColumnDefinitionContext is an interface to support dynamic dispatch.
|
|
type IIndexColumnDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsIndexColumnDefinitionContext differentiates from other interfaces.
|
|
IsIndexColumnDefinitionContext()
|
|
}
|
|
|
|
type IndexColumnDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIndexColumnDefinitionContext() *IndexColumnDefinitionContext {
|
|
var p = new(IndexColumnDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexColumnDefinitionContext(p *IndexColumnDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnDefinition
|
|
}
|
|
|
|
func (*IndexColumnDefinitionContext) IsIndexColumnDefinitionContext() {}
|
|
|
|
func NewIndexColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnDefinitionContext {
|
|
var p = new(IndexColumnDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexColumnDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexColumnDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexColumnDefinitionContext) CopyAll(ctx *IndexColumnDefinitionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *IndexColumnDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SpecialIndexDeclarationContext struct {
|
|
IndexColumnDefinitionContext
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewSpecialIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpecialIndexDeclarationContext {
|
|
var p = new(SpecialIndexDeclarationContext)
|
|
|
|
InitEmptyIndexColumnDefinitionContext(&p.IndexColumnDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*IndexColumnDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *SpecialIndexDeclarationContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *SpecialIndexDeclarationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) FULLTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULLTEXT, 0)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) SPATIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSPATIAL, 0)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSpecialIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSpecialIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpecialIndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSpecialIndexDeclaration(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SimpleIndexDeclarationContext struct {
|
|
IndexColumnDefinitionContext
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewSimpleIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleIndexDeclarationContext {
|
|
var p = new(SimpleIndexDeclarationContext)
|
|
|
|
InitEmptyIndexColumnDefinitionContext(&p.IndexColumnDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*IndexColumnDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *SimpleIndexDeclarationContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *SimpleIndexDeclarationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleIndexDeclaration(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleIndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleIndexDeclaration(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexColumnDefinition() (localctx IIndexColumnDefinitionContext) {
|
|
localctx = NewIndexColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 104, MySqlParserRULE_indexColumnDefinition)
|
|
var _la int
|
|
|
|
p.SetState(1822)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserINDEX, MySqlParserKEY:
|
|
localctx = NewSimpleIndexDeclarationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1794)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SimpleIndexDeclarationContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SimpleIndexDeclarationContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(1796)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1795)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(1799)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(1798)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1801)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(1805)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE {
|
|
{
|
|
p.SetState(1802)
|
|
p.IndexOption()
|
|
}
|
|
|
|
p.SetState(1807)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case MySqlParserFULLTEXT, MySqlParserSPATIAL:
|
|
localctx = NewSpecialIndexDeclarationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1808)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(1810)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(1809)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SpecialIndexDeclarationContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SpecialIndexDeclarationContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1813)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(1812)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1815)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(1819)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE {
|
|
{
|
|
p.SetState(1816)
|
|
p.IndexOption()
|
|
}
|
|
|
|
p.SetState(1821)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableOptionContext is an interface to support dynamic dispatch.
|
|
type ITableOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsTableOptionContext differentiates from other interfaces.
|
|
IsTableOptionContext()
|
|
}
|
|
|
|
type TableOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableOptionContext() *TableOptionContext {
|
|
var p = new(TableOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableOptionContext(p *TableOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableOption
|
|
}
|
|
|
|
func (*TableOptionContext) IsTableOptionContext() {}
|
|
|
|
func NewTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionContext {
|
|
var p = new(TableOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableOptionContext) CopyAll(ctx *TableOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *TableOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type TableOptionEngineContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEngineContext {
|
|
var p = new(TableOptionEngineContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionEngine(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionMaxRowsContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionMaxRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionMaxRowsContext {
|
|
var p = new(TableOptionMaxRowsContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) MAX_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_ROWS, 0)
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionMaxRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionMaxRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionMaxRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionMaxRows(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionCollateContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionCollateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCollateContext {
|
|
var p = new(TableOptionCollateContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionCollate(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionCollate(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionCollate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionPersistentContext struct {
|
|
TableOptionContext
|
|
extBoolValue antlr.Token
|
|
}
|
|
|
|
func NewTableOptionPersistentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPersistentContext {
|
|
var p = new(TableOptionPersistentContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) GetExtBoolValue() antlr.Token { return s.extBoolValue }
|
|
|
|
func (s *TableOptionPersistentContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v }
|
|
|
|
func (s *TableOptionPersistentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) STATS_PERSISTENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_PERSISTENT, 0)
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionPersistent(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionPersistent(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPersistentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionPersistent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionTablespaceContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTablespaceContext {
|
|
var p = new(TableOptionTablespaceContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) TablespaceStorage() ITablespaceStorageContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablespaceStorageContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablespaceStorageContext)
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionAutoextendSizeContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionAutoextendSizeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAutoextendSizeContext {
|
|
var p = new(TableOptionAutoextendSizeContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) AUTOEXTEND_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0)
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionAutoextendSize(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionAutoextendSize(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAutoextendSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionAutoextendSize(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionPageCompressedContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionPageCompressedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPageCompressedContext {
|
|
var p = new(TableOptionPageCompressedContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) PAGE_COMPRESSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE_COMPRESSED, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionPageCompressed(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionPageCompressed(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPageCompressedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionPageCompressed(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionStartTransactionContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionStartTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionStartTransactionContext {
|
|
var p = new(TableOptionStartTransactionContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) TRANSACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTION, 0)
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionStartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionStartTransaction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionPackKeysContext struct {
|
|
TableOptionContext
|
|
extBoolValue antlr.Token
|
|
}
|
|
|
|
func NewTableOptionPackKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPackKeysContext {
|
|
var p = new(TableOptionPackKeysContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) GetExtBoolValue() antlr.Token { return s.extBoolValue }
|
|
|
|
func (s *TableOptionPackKeysContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v }
|
|
|
|
func (s *TableOptionPackKeysContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) PACK_KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPACK_KEYS, 0)
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionPackKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionPackKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPackKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionPackKeys(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionPasswordContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPasswordContext {
|
|
var p = new(TableOptionPasswordContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionPassword(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionPassword(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionPassword(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionUnionContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionUnionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionUnionContext {
|
|
var p = new(TableOptionUnionContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNION, 0)
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionUnion(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionUnion(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionUnionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionUnion(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionSamplePageContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionSamplePageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionSamplePageContext {
|
|
var p = new(TableOptionSamplePageContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) STATS_SAMPLE_PAGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_SAMPLE_PAGES, 0)
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionSamplePage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionSamplePage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionSamplePageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionSamplePage(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionCharsetContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCharsetContext {
|
|
var p = new(TableOptionCharsetContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) AllDEFAULT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserDEFAULT)
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) DEFAULT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, i)
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionCharset(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionIndexDirectoryContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionIndexDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionIndexDirectoryContext {
|
|
var p = new(TableOptionIndexDirectoryContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionIndexDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionIndexDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionIndexDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionIndexDirectory(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionTableTypeContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionTableTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTableTypeContext {
|
|
var p = new(TableOptionTableTypeContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) TABLE_TYPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_TYPE, 0)
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) TableType() ITableTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableTypeContext)
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionTableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionTableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionTableType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionKeyBlockSizeContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionKeyBlockSizeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionKeyBlockSizeContext {
|
|
var p = new(TableOptionKeyBlockSizeContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) KEY_BLOCK_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0)
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) FileSizeLiteral() IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionKeyBlockSize(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionKeyBlockSize(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionKeyBlockSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionKeyBlockSize(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionEncryptionContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionEncryptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEncryptionContext {
|
|
var p = new(TableOptionEncryptionContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) ENCRYPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION, 0)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionEncryption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionEncryption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEncryptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionEncryption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionDataDirectoryContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionDataDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionDataDirectoryContext {
|
|
var p = new(TableOptionDataDirectoryContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionDataDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionDataDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionDataDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionDataDirectory(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionRecalculationContext struct {
|
|
TableOptionContext
|
|
extBoolValue antlr.Token
|
|
}
|
|
|
|
func NewTableOptionRecalculationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionRecalculationContext {
|
|
var p = new(TableOptionRecalculationContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) GetExtBoolValue() antlr.Token { return s.extBoolValue }
|
|
|
|
func (s *TableOptionRecalculationContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v }
|
|
|
|
func (s *TableOptionRecalculationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) STATS_AUTO_RECALC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_AUTO_RECALC, 0)
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionRecalculation(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionRecalculation(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionRecalculationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionRecalculation(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionAutoIncrementContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionAutoIncrementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAutoIncrementContext {
|
|
var p = new(TableOptionAutoIncrementContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) AUTO_INCREMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTO_INCREMENT, 0)
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionAutoIncrement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionAutoIncrement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAutoIncrementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionAutoIncrement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionEncryptionKeyIdContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionEncryptionKeyIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEncryptionKeyIdContext {
|
|
var p = new(TableOptionEncryptionKeyIdContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) ENCRYPTION_KEY_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION_KEY_ID, 0)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionEncryptionKeyId(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionEncryptionKeyId(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEncryptionKeyIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionEncryptionKeyId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionChecksumContext struct {
|
|
TableOptionContext
|
|
boolValue antlr.Token
|
|
}
|
|
|
|
func NewTableOptionChecksumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionChecksumContext {
|
|
var p = new(TableOptionChecksumContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) GetBoolValue() antlr.Token { return s.boolValue }
|
|
|
|
func (s *TableOptionChecksumContext) SetBoolValue(v antlr.Token) { s.boolValue = v }
|
|
|
|
func (s *TableOptionChecksumContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) CHECKSUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECKSUM, 0)
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) PAGE_CHECKSUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE_CHECKSUM, 0)
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionChecksum(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionChecksum(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionChecksumContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionChecksum(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionDelayContext struct {
|
|
TableOptionContext
|
|
boolValue antlr.Token
|
|
}
|
|
|
|
func NewTableOptionDelayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionDelayContext {
|
|
var p = new(TableOptionDelayContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) GetBoolValue() antlr.Token { return s.boolValue }
|
|
|
|
func (s *TableOptionDelayContext) SetBoolValue(v antlr.Token) { s.boolValue = v }
|
|
|
|
func (s *TableOptionDelayContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) DELAY_KEY_WRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELAY_KEY_WRITE, 0)
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionDelay(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionDelay(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionDelayContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionDelay(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionConnectionContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionConnectionContext {
|
|
var p = new(TableOptionConnectionContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) CONNECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION, 0)
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionConnection(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionConnection(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionConnection(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionTransactionalContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionTransactionalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTransactionalContext {
|
|
var p = new(TableOptionTransactionalContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) TRANSACTIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTIONAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionTransactional(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionTransactional(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionTransactionalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionTransactional(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionPageCompressionLevelContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionPageCompressionLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPageCompressionLevelContext {
|
|
var p = new(TableOptionPageCompressionLevelContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) PAGE_COMPRESSION_LEVEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE_COMPRESSION_LEVEL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionPageCompressionLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionPageCompressionLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionPageCompressionLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionPageCompressionLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionSecondaryEngineAttributeContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionSecondaryEngineAttributeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionSecondaryEngineAttributeContext {
|
|
var p = new(TableOptionSecondaryEngineAttributeContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionSecondaryEngineAttribute(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionSecondaryEngineAttribute(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionSecondaryEngineAttributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionSecondaryEngineAttribute(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionCommentContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCommentContext {
|
|
var p = new(TableOptionCommentContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionComment(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionAverageContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionAverageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAverageContext {
|
|
var p = new(TableOptionAverageContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) AVG_ROW_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAVG_ROW_LENGTH, 0)
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionAverage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionAverage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionAverageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionAverage(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionRowFormatContext struct {
|
|
TableOptionContext
|
|
rowFormat antlr.Token
|
|
}
|
|
|
|
func NewTableOptionRowFormatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionRowFormatContext {
|
|
var p = new(TableOptionRowFormatContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) GetRowFormat() antlr.Token { return s.rowFormat }
|
|
|
|
func (s *TableOptionRowFormatContext) SetRowFormat(v antlr.Token) { s.rowFormat = v }
|
|
|
|
func (s *TableOptionRowFormatContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) ROW_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_FORMAT, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) DYNAMIC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDYNAMIC, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) FIXED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIXED, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) COMPRESSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPRESSED, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) REDUNDANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREDUNDANT, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) COMPACT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPACT, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionRowFormat(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionRowFormat(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionRowFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionRowFormat(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionCompressionContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionCompressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCompressionContext {
|
|
var p = new(TableOptionCompressionContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) COMPRESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPRESSION, 0)
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionCompression(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionCompression(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionCompressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionCompression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionInsertMethodContext struct {
|
|
TableOptionContext
|
|
insertMethod antlr.Token
|
|
}
|
|
|
|
func NewTableOptionInsertMethodContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionInsertMethodContext {
|
|
var p = new(TableOptionInsertMethodContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) GetInsertMethod() antlr.Token { return s.insertMethod }
|
|
|
|
func (s *TableOptionInsertMethodContext) SetInsertMethod(v antlr.Token) { s.insertMethod = v }
|
|
|
|
func (s *TableOptionInsertMethodContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) INSERT_METHOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT_METHOD, 0)
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) NO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, 0)
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) LAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST, 0)
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionInsertMethod(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionInsertMethod(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionInsertMethodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionInsertMethod(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionEngineAttributeContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionEngineAttributeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEngineAttributeContext {
|
|
var p = new(TableOptionEngineAttributeContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionEngineAttribute(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionEngineAttribute(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionEngineAttributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionEngineAttribute(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableOptionMinRowsContext struct {
|
|
TableOptionContext
|
|
}
|
|
|
|
func NewTableOptionMinRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionMinRowsContext {
|
|
var p = new(TableOptionMinRowsContext)
|
|
|
|
InitEmptyTableOptionContext(&p.TableOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) MIN_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIN_ROWS, 0)
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableOptionMinRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableOptionMinRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableOptionMinRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableOptionMinRows(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableOption() (localctx ITableOptionContext) {
|
|
localctx = NewTableOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 106, MySqlParserRULE_tableOption)
|
|
var _la int
|
|
|
|
p.SetState(2009)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 228, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewTableOptionEngineContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(1824)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1826)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1825)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1829)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1828)
|
|
p.EngineName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewTableOptionEngineAttributeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(1831)
|
|
p.Match(MySqlParserENGINE_ATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1833)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1832)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1835)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewTableOptionAutoextendSizeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(1836)
|
|
p.Match(MySqlParserAUTOEXTEND_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1838)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1837)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1840)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewTableOptionAutoIncrementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(1841)
|
|
p.Match(MySqlParserAUTO_INCREMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1843)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1842)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1845)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewTableOptionAverageContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(1846)
|
|
p.Match(MySqlParserAVG_ROW_LENGTH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1848)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1847)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1850)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewTableOptionCharsetContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
p.SetState(1852)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(1851)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1854)
|
|
p.CharSet()
|
|
}
|
|
p.SetState(1856)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1855)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1860)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(1858)
|
|
p.CharsetName()
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(1859)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewTableOptionChecksumContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(1862)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHECKSUM || _la == MySqlParserPAGE_CHECKSUM) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(1864)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1863)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1866)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionChecksumContext).boolValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionChecksumContext).boolValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewTableOptionCollateContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
p.SetState(1868)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(1867)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1870)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1872)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1871)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1874)
|
|
p.CollationName()
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewTableOptionCommentContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(1875)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1877)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1876)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1879)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewTableOptionCompressionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(1880)
|
|
p.Match(MySqlParserCOMPRESSION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1882)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1881)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1884)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSTRING_LITERAL || _la == MySqlParserID) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewTableOptionConnectionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(1885)
|
|
p.Match(MySqlParserCONNECTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1887)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1886)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1889)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewTableOptionDataDirectoryContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(1890)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserDATA) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1891)
|
|
p.Match(MySqlParserDIRECTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1893)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1892)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1895)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewTableOptionDelayContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(1896)
|
|
p.Match(MySqlParserDELAY_KEY_WRITE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1898)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1897)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1900)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionDelayContext).boolValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionDelayContext).boolValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewTableOptionEncryptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(1901)
|
|
p.Match(MySqlParserENCRYPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1903)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1902)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1905)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewTableOptionPageCompressedContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(1906)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPAGE_COMPRESSED || _la == MySqlParserSTRING_LITERAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(1908)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1907)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1910)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 16:
|
|
localctx = NewTableOptionPageCompressionLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(1911)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPAGE_COMPRESSION_LEVEL || _la == MySqlParserSTRING_LITERAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(1913)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1912)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1915)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 17:
|
|
localctx = NewTableOptionEncryptionKeyIdContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(1916)
|
|
p.Match(MySqlParserENCRYPTION_KEY_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1918)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1917)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1920)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 18:
|
|
localctx = NewTableOptionIndexDirectoryContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(1921)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1922)
|
|
p.Match(MySqlParserDIRECTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1924)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1923)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1926)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 19:
|
|
localctx = NewTableOptionInsertMethodContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(1927)
|
|
p.Match(MySqlParserINSERT_METHOD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1929)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1928)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1931)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionInsertMethodContext).insertMethod = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFIRST || _la == MySqlParserLAST || _la == MySqlParserNO) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionInsertMethodContext).insertMethod = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 20:
|
|
localctx = NewTableOptionKeyBlockSizeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(1932)
|
|
p.Match(MySqlParserKEY_BLOCK_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1934)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1933)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1936)
|
|
p.FileSizeLiteral()
|
|
}
|
|
|
|
case 21:
|
|
localctx = NewTableOptionMaxRowsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(1937)
|
|
p.Match(MySqlParserMAX_ROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1939)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1938)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1941)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 22:
|
|
localctx = NewTableOptionMinRowsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(1942)
|
|
p.Match(MySqlParserMIN_ROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1944)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1943)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1946)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 23:
|
|
localctx = NewTableOptionPackKeysContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(1947)
|
|
p.Match(MySqlParserPACK_KEYS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1949)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1948)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1951)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionPackKeysContext).extBoolValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionPackKeysContext).extBoolValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 24:
|
|
localctx = NewTableOptionPasswordContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(1952)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1954)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1953)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1956)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 25:
|
|
localctx = NewTableOptionRowFormatContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 25)
|
|
{
|
|
p.SetState(1957)
|
|
p.Match(MySqlParserROW_FORMAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1959)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1958)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1961)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionRowFormatContext).rowFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || ((int64((_la-370)) & ^0x3f) == 0 && ((int64(1)<<(_la-370))&2305843013508661253) != 0) || _la == MySqlParserREDUNDANT || _la == MySqlParserID) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionRowFormatContext).rowFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 26:
|
|
localctx = NewTableOptionStartTransactionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 26)
|
|
{
|
|
p.SetState(1962)
|
|
p.Match(MySqlParserSTART)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1963)
|
|
p.Match(MySqlParserTRANSACTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 27:
|
|
localctx = NewTableOptionSecondaryEngineAttributeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 27)
|
|
{
|
|
p.SetState(1964)
|
|
p.Match(MySqlParserSECONDARY_ENGINE_ATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1966)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1965)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1968)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 28:
|
|
localctx = NewTableOptionRecalculationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 28)
|
|
{
|
|
p.SetState(1969)
|
|
p.Match(MySqlParserSTATS_AUTO_RECALC)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1971)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1970)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1973)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionRecalculationContext).extBoolValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionRecalculationContext).extBoolValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 29:
|
|
localctx = NewTableOptionPersistentContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 29)
|
|
{
|
|
p.SetState(1974)
|
|
p.Match(MySqlParserSTATS_PERSISTENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1976)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1975)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(1978)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableOptionPersistentContext).extBoolValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableOptionPersistentContext).extBoolValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 30:
|
|
localctx = NewTableOptionSamplePageContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 30)
|
|
{
|
|
p.SetState(1979)
|
|
p.Match(MySqlParserSTATS_SAMPLE_PAGES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1981)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1980)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(1985)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(1983)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(1984)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 31:
|
|
localctx = NewTableOptionTablespaceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 31)
|
|
{
|
|
p.SetState(1987)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1988)
|
|
p.Uid()
|
|
}
|
|
p.SetState(1990)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(1989)
|
|
p.TablespaceStorage()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 32:
|
|
localctx = NewTableOptionTableTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 32)
|
|
{
|
|
p.SetState(1992)
|
|
p.Match(MySqlParserTABLE_TYPE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1993)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(1994)
|
|
p.TableType()
|
|
}
|
|
|
|
case 33:
|
|
localctx = NewTableOptionTablespaceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 33)
|
|
{
|
|
p.SetState(1995)
|
|
p.TablespaceStorage()
|
|
}
|
|
|
|
case 34:
|
|
localctx = NewTableOptionTransactionalContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 34)
|
|
{
|
|
p.SetState(1996)
|
|
p.Match(MySqlParserTRANSACTIONAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(1998)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(1997)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2000)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 35:
|
|
localctx = NewTableOptionUnionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 35)
|
|
{
|
|
p.SetState(2001)
|
|
p.Match(MySqlParserUNION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2003)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2002)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2005)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2006)
|
|
p.Tables()
|
|
}
|
|
{
|
|
p.SetState(2007)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableTypeContext is an interface to support dynamic dispatch.
|
|
type ITableTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MYSQL() antlr.TerminalNode
|
|
ODBC() antlr.TerminalNode
|
|
|
|
// IsTableTypeContext differentiates from other interfaces.
|
|
IsTableTypeContext()
|
|
}
|
|
|
|
type TableTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableTypeContext() *TableTypeContext {
|
|
var p = new(TableTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableTypeContext(p *TableTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableType
|
|
}
|
|
|
|
func (*TableTypeContext) IsTableTypeContext() {}
|
|
|
|
func NewTableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableTypeContext {
|
|
var p = new(TableTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableTypeContext) MYSQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL, 0)
|
|
}
|
|
|
|
func (s *TableTypeContext) ODBC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserODBC, 0)
|
|
}
|
|
|
|
func (s *TableTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TableTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableType(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableType() (localctx ITableTypeContext) {
|
|
localctx = NewTableTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 108, MySqlParserRULE_tableType)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2011)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMYSQL || _la == MySqlParserODBC) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITablespaceStorageContext is an interface to support dynamic dispatch.
|
|
type ITablespaceStorageContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STORAGE() antlr.TerminalNode
|
|
DISK() antlr.TerminalNode
|
|
MEMORY() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
|
|
// IsTablespaceStorageContext differentiates from other interfaces.
|
|
IsTablespaceStorageContext()
|
|
}
|
|
|
|
type TablespaceStorageContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTablespaceStorageContext() *TablespaceStorageContext {
|
|
var p = new(TablespaceStorageContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tablespaceStorage
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTablespaceStorageContext(p *TablespaceStorageContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tablespaceStorage
|
|
}
|
|
|
|
func (*TablespaceStorageContext) IsTablespaceStorageContext() {}
|
|
|
|
func NewTablespaceStorageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablespaceStorageContext {
|
|
var p = new(TablespaceStorageContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tablespaceStorage
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TablespaceStorageContext) STORAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORAGE, 0)
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) DISK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISK, 0)
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) MEMORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMORY, 0)
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTablespaceStorage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTablespaceStorage(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablespaceStorageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTablespaceStorage(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TablespaceStorage() (localctx ITablespaceStorageContext) {
|
|
localctx = NewTablespaceStorageContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 110, MySqlParserRULE_tablespaceStorage)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2013)
|
|
p.Match(MySqlParserSTORAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2014)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserDISK || _la == MySqlParserMEMORY) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionDefinitionsContext is an interface to support dynamic dispatch.
|
|
type IPartitionDefinitionsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCount returns the count rule contexts.
|
|
GetCount() IDecimalLiteralContext
|
|
|
|
// GetSubCount returns the subCount rule contexts.
|
|
GetSubCount() IDecimalLiteralContext
|
|
|
|
// SetCount sets the count rule contexts.
|
|
SetCount(IDecimalLiteralContext)
|
|
|
|
// SetSubCount sets the subCount rule contexts.
|
|
SetSubCount(IDecimalLiteralContext)
|
|
|
|
// Getter signatures
|
|
PARTITION() antlr.TerminalNode
|
|
AllBY() []antlr.TerminalNode
|
|
BY(i int) antlr.TerminalNode
|
|
PartitionFunctionDefinition() IPartitionFunctionDefinitionContext
|
|
PARTITIONS() antlr.TerminalNode
|
|
SUBPARTITION() antlr.TerminalNode
|
|
SubpartitionFunctionDefinition() ISubpartitionFunctionDefinitionContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllPartitionDefinition() []IPartitionDefinitionContext
|
|
PartitionDefinition(i int) IPartitionDefinitionContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllDecimalLiteral() []IDecimalLiteralContext
|
|
DecimalLiteral(i int) IDecimalLiteralContext
|
|
SUBPARTITIONS() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsPartitionDefinitionsContext differentiates from other interfaces.
|
|
IsPartitionDefinitionsContext()
|
|
}
|
|
|
|
type PartitionDefinitionsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
count IDecimalLiteralContext
|
|
subCount IDecimalLiteralContext
|
|
}
|
|
|
|
func NewEmptyPartitionDefinitionsContext() *PartitionDefinitionsContext {
|
|
var p = new(PartitionDefinitionsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinitions
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionDefinitionsContext(p *PartitionDefinitionsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinitions
|
|
}
|
|
|
|
func (*PartitionDefinitionsContext) IsPartitionDefinitionsContext() {}
|
|
|
|
func NewPartitionDefinitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinitionsContext {
|
|
var p = new(PartitionDefinitionsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinitions
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionDefinitionsContext) GetCount() IDecimalLiteralContext { return s.count }
|
|
|
|
func (s *PartitionDefinitionsContext) GetSubCount() IDecimalLiteralContext { return s.subCount }
|
|
|
|
func (s *PartitionDefinitionsContext) SetCount(v IDecimalLiteralContext) { s.count = v }
|
|
|
|
func (s *PartitionDefinitionsContext) SetSubCount(v IDecimalLiteralContext) { s.subCount = v }
|
|
|
|
func (s *PartitionDefinitionsContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) AllBY() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserBY)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) BY(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, i)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) PartitionFunctionDefinition() IPartitionFunctionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionFunctionDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionFunctionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) PARTITIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONS, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) SUBPARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) SubpartitionFunctionDefinition() ISubpartitionFunctionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISubpartitionFunctionDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISubpartitionFunctionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) AllPartitionDefinition() []IPartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
tst[i] = t.(IPartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) PartitionDefinition(i int) IPartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) SUBPARTITIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBPARTITIONS, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionDefinitions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionDefinitions() (localctx IPartitionDefinitionsContext) {
|
|
localctx = NewPartitionDefinitionsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 112, MySqlParserRULE_partitionDefinitions)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2016)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2017)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2018)
|
|
p.PartitionFunctionDefinition()
|
|
}
|
|
p.SetState(2021)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITIONS {
|
|
{
|
|
p.SetState(2019)
|
|
p.Match(MySqlParserPARTITIONS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2020)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*PartitionDefinitionsContext).count = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(2030)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSUBPARTITION {
|
|
{
|
|
p.SetState(2023)
|
|
p.Match(MySqlParserSUBPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2024)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2025)
|
|
p.SubpartitionFunctionDefinition()
|
|
}
|
|
p.SetState(2028)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSUBPARTITIONS {
|
|
{
|
|
p.SetState(2026)
|
|
p.Match(MySqlParserSUBPARTITIONS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2027)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*PartitionDefinitionsContext).subCount = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
p.SetState(2043)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 233, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2032)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2033)
|
|
p.PartitionDefinition()
|
|
}
|
|
p.SetState(2038)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2034)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2035)
|
|
p.PartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2040)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2041)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionFunctionDefinitionContext is an interface to support dynamic dispatch.
|
|
type IPartitionFunctionDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsPartitionFunctionDefinitionContext differentiates from other interfaces.
|
|
IsPartitionFunctionDefinitionContext()
|
|
}
|
|
|
|
type PartitionFunctionDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionFunctionDefinitionContext() *PartitionFunctionDefinitionContext {
|
|
var p = new(PartitionFunctionDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionFunctionDefinitionContext(p *PartitionFunctionDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition
|
|
}
|
|
|
|
func (*PartitionFunctionDefinitionContext) IsPartitionFunctionDefinitionContext() {}
|
|
|
|
func NewPartitionFunctionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionFunctionDefinitionContext {
|
|
var p = new(PartitionFunctionDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionFunctionDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionFunctionDefinitionContext) CopyAll(ctx *PartitionFunctionDefinitionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionFunctionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PartitionFunctionKeyContext struct {
|
|
PartitionFunctionDefinitionContext
|
|
algType antlr.Token
|
|
}
|
|
|
|
func NewPartitionFunctionKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionKeyContext {
|
|
var p = new(PartitionFunctionKeyContext)
|
|
|
|
InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *PartitionFunctionKeyContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *PartitionFunctionKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) LINEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEAR, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) TWO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTWO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionFunctionKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionFunctionKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionFunctionKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionFunctionHashContext struct {
|
|
PartitionFunctionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionFunctionHashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionHashContext {
|
|
var p = new(PartitionFunctionHashContext)
|
|
|
|
InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) HASH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHASH, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) LINEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEAR, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionFunctionHash(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionFunctionHash(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionFunctionHash(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionFunctionListContext struct {
|
|
PartitionFunctionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionFunctionListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionListContext {
|
|
var p = new(PartitionFunctionListContext)
|
|
|
|
InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) LIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIST, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionFunctionList(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionFunctionList(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionFunctionList(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionFunctionRangeContext struct {
|
|
PartitionFunctionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionFunctionRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionRangeContext {
|
|
var p = new(PartitionFunctionRangeContext)
|
|
|
|
InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) RANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANGE, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionFunctionRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionFunctionRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionFunctionRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionFunctionRange(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionFunctionDefinition() (localctx IPartitionFunctionDefinitionContext) {
|
|
localctx = NewPartitionFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 114, MySqlParserRULE_partitionFunctionDefinition)
|
|
var _la int
|
|
|
|
p.SetState(2091)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 240, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewPartitionFunctionHashContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(2046)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINEAR {
|
|
{
|
|
p.SetState(2045)
|
|
p.Match(MySqlParserLINEAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2048)
|
|
p.Match(MySqlParserHASH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2049)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2050)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2051)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewPartitionFunctionKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(2054)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINEAR {
|
|
{
|
|
p.SetState(2053)
|
|
p.Match(MySqlParserLINEAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2056)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2060)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALGORITHM {
|
|
{
|
|
p.SetState(2057)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2058)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2059)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*PartitionFunctionKeyContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserONE_DECIMAL || _la == MySqlParserTWO_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*PartitionFunctionKeyContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2062)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2064)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2063)
|
|
p.UidList()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2066)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewPartitionFunctionRangeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2067)
|
|
p.Match(MySqlParserRANGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2077)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(2068)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2069)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2070)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCOLUMNS:
|
|
{
|
|
p.SetState(2072)
|
|
p.Match(MySqlParserCOLUMNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2073)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2074)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(2075)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewPartitionFunctionListContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(2079)
|
|
p.Match(MySqlParserLIST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2089)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(2080)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2081)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2082)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCOLUMNS:
|
|
{
|
|
p.SetState(2084)
|
|
p.Match(MySqlParserCOLUMNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2085)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2086)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(2087)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISubpartitionFunctionDefinitionContext is an interface to support dynamic dispatch.
|
|
type ISubpartitionFunctionDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSubpartitionFunctionDefinitionContext differentiates from other interfaces.
|
|
IsSubpartitionFunctionDefinitionContext()
|
|
}
|
|
|
|
type SubpartitionFunctionDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySubpartitionFunctionDefinitionContext() *SubpartitionFunctionDefinitionContext {
|
|
var p = new(SubpartitionFunctionDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptySubpartitionFunctionDefinitionContext(p *SubpartitionFunctionDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition
|
|
}
|
|
|
|
func (*SubpartitionFunctionDefinitionContext) IsSubpartitionFunctionDefinitionContext() {}
|
|
|
|
func NewSubpartitionFunctionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubpartitionFunctionDefinitionContext {
|
|
var p = new(SubpartitionFunctionDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubpartitionFunctionDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SubpartitionFunctionDefinitionContext) CopyAll(ctx *SubpartitionFunctionDefinitionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SubpartitionFunctionDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubpartitionFunctionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SubPartitionFunctionHashContext struct {
|
|
SubpartitionFunctionDefinitionContext
|
|
}
|
|
|
|
func NewSubPartitionFunctionHashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubPartitionFunctionHashContext {
|
|
var p = new(SubPartitionFunctionHashContext)
|
|
|
|
InitEmptySubpartitionFunctionDefinitionContext(&p.SubpartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SubpartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) HASH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHASH, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) LINEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEAR, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubPartitionFunctionHash(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubPartitionFunctionHash(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubPartitionFunctionHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubPartitionFunctionHash(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SubPartitionFunctionKeyContext struct {
|
|
SubpartitionFunctionDefinitionContext
|
|
algType antlr.Token
|
|
}
|
|
|
|
func NewSubPartitionFunctionKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubPartitionFunctionKeyContext {
|
|
var p = new(SubPartitionFunctionKeyContext)
|
|
|
|
InitEmptySubpartitionFunctionDefinitionContext(&p.SubpartitionFunctionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SubpartitionFunctionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *SubPartitionFunctionKeyContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *SubPartitionFunctionKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) LINEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEAR, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) TWO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTWO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubPartitionFunctionKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubPartitionFunctionKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubPartitionFunctionKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubPartitionFunctionKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SubpartitionFunctionDefinition() (localctx ISubpartitionFunctionDefinitionContext) {
|
|
localctx = NewSubpartitionFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 116, MySqlParserRULE_subpartitionFunctionDefinition)
|
|
var _la int
|
|
|
|
p.SetState(2114)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 244, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSubPartitionFunctionHashContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(2094)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINEAR {
|
|
{
|
|
p.SetState(2093)
|
|
p.Match(MySqlParserLINEAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2096)
|
|
p.Match(MySqlParserHASH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2097)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2098)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2099)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewSubPartitionFunctionKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(2102)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINEAR {
|
|
{
|
|
p.SetState(2101)
|
|
p.Match(MySqlParserLINEAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2104)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2108)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALGORITHM {
|
|
{
|
|
p.SetState(2105)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2106)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2107)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SubPartitionFunctionKeyContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserONE_DECIMAL || _la == MySqlParserTWO_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SubPartitionFunctionKeyContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2110)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2111)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(2112)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionDefinitionContext is an interface to support dynamic dispatch.
|
|
type IPartitionDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsPartitionDefinitionContext differentiates from other interfaces.
|
|
IsPartitionDefinitionContext()
|
|
}
|
|
|
|
type PartitionDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionDefinitionContext() *PartitionDefinitionContext {
|
|
var p = new(PartitionDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionDefinitionContext(p *PartitionDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinition
|
|
}
|
|
|
|
func (*PartitionDefinitionContext) IsPartitionDefinitionContext() {}
|
|
|
|
func NewPartitionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinitionContext {
|
|
var p = new(PartitionDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionDefinitionContext) CopyAll(ctx *PartitionDefinitionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *PartitionDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PartitionComparisonContext struct {
|
|
PartitionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionComparisonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionComparisonContext {
|
|
var p = new(PartitionComparisonContext)
|
|
|
|
InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) LESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLESS, 0)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) THAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHAN, 0)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinerAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
tst[i] = t.(IPartitionDefinerAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinerAtomContext)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllPartitionOption() []IPartitionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionOptionContext); ok {
|
|
tst[i] = t.(IPartitionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) PartitionOption(i int) IPartitionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionOptionContext)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISubpartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
tst[i] = t.(ISubpartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISubpartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionComparison(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionComparison(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionComparisonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionComparison(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionListAtomContext struct {
|
|
PartitionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionListAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionListAtomContext {
|
|
var p = new(PartitionListAtomContext)
|
|
|
|
InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinerAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
tst[i] = t.(IPartitionDefinerAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinerAtomContext)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllPartitionOption() []IPartitionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionOptionContext); ok {
|
|
tst[i] = t.(IPartitionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) PartitionOption(i int) IPartitionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionOptionContext)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISubpartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
tst[i] = t.(ISubpartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISubpartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionListAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionListAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionListAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionListAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionListVectorContext struct {
|
|
PartitionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionListVectorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionListVectorContext {
|
|
var p = new(PartitionListVectorContext)
|
|
|
|
InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllPartitionDefinerVector() []IPartitionDefinerVectorContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinerVectorContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinerVectorContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinerVectorContext); ok {
|
|
tst[i] = t.(IPartitionDefinerVectorContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) PartitionDefinerVector(i int) IPartitionDefinerVectorContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinerVectorContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinerVectorContext)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllPartitionOption() []IPartitionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionOptionContext); ok {
|
|
tst[i] = t.(IPartitionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) PartitionOption(i int) IPartitionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionOptionContext)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISubpartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
tst[i] = t.(ISubpartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISubpartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionListVector(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionListVector(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionListVectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionListVector(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionSimpleContext struct {
|
|
PartitionDefinitionContext
|
|
}
|
|
|
|
func NewPartitionSimpleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionSimpleContext {
|
|
var p = new(PartitionSimpleContext)
|
|
|
|
InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionDefinitionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) AllPartitionOption() []IPartitionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionOptionContext); ok {
|
|
tst[i] = t.(IPartitionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) PartitionOption(i int) IPartitionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionOptionContext)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISubpartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
tst[i] = t.(ISubpartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISubpartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISubpartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionSimple(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionSimple(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionSimpleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionSimple(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionDefinition() (localctx IPartitionDefinitionContext) {
|
|
localctx = NewPartitionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 118, MySqlParserRULE_partitionDefinition)
|
|
var _la int
|
|
|
|
p.SetState(2262)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewPartitionComparisonContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2116)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2117)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2118)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2119)
|
|
p.Match(MySqlParserLESS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2120)
|
|
p.Match(MySqlParserTHAN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2121)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2122)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
p.SetState(2127)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2123)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2124)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
|
|
p.SetState(2129)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2130)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2134)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2131)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2136)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(2148)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2137)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2138)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
p.SetState(2143)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2139)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2140)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2145)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2146)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewPartitionComparisonContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2150)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2151)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2152)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2153)
|
|
p.Match(MySqlParserLESS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2154)
|
|
p.Match(MySqlParserTHAN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2155)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
p.SetState(2159)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2156)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2161)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(2173)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2162)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2163)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
p.SetState(2168)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2164)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2165)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2170)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2171)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewPartitionListAtomContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2175)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2176)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2177)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2178)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2179)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2180)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
p.SetState(2185)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2181)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2182)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
|
|
p.SetState(2187)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2188)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2192)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2189)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2194)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(2206)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2195)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2196)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
p.SetState(2201)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2197)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2198)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2203)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2204)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewPartitionListVectorContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(2208)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2209)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2210)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2211)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2212)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2213)
|
|
p.PartitionDefinerVector()
|
|
}
|
|
p.SetState(2218)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2214)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2215)
|
|
p.PartitionDefinerVector()
|
|
}
|
|
|
|
p.SetState(2220)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2221)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2225)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2222)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2227)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(2239)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2228)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2229)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
p.SetState(2234)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2230)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2231)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2236)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2237)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewPartitionSimpleContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(2241)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2242)
|
|
p.Uid()
|
|
}
|
|
p.SetState(2246)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2243)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2248)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(2260)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2249)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2250)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
p.SetState(2255)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2251)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2252)
|
|
p.SubpartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2257)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2258)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionDefinerAtomContext is an interface to support dynamic dispatch.
|
|
type IPartitionDefinerAtomContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Constant() IConstantContext
|
|
Expression() IExpressionContext
|
|
MAXVALUE() antlr.TerminalNode
|
|
|
|
// IsPartitionDefinerAtomContext differentiates from other interfaces.
|
|
IsPartitionDefinerAtomContext()
|
|
}
|
|
|
|
type PartitionDefinerAtomContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionDefinerAtomContext() *PartitionDefinerAtomContext {
|
|
var p = new(PartitionDefinerAtomContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerAtom
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionDefinerAtomContext(p *PartitionDefinerAtomContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerAtom
|
|
}
|
|
|
|
func (*PartitionDefinerAtomContext) IsPartitionDefinerAtomContext() {}
|
|
|
|
func NewPartitionDefinerAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinerAtomContext {
|
|
var p = new(PartitionDefinerAtomContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerAtom
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionDefinerAtomContext) Constant() IConstantContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) MAXVALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAXVALUE, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionDefinerAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionDefinerAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinerAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionDefinerAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionDefinerAtom() (localctx IPartitionDefinerAtomContext) {
|
|
localctx = NewPartitionDefinerAtomContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 120, MySqlParserRULE_partitionDefinerAtom)
|
|
p.SetState(2267)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2264)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2265)
|
|
p.expression(0)
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2266)
|
|
p.Match(MySqlParserMAXVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionDefinerVectorContext is an interface to support dynamic dispatch.
|
|
type IPartitionDefinerVectorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllPartitionDefinerAtom() []IPartitionDefinerAtomContext
|
|
PartitionDefinerAtom(i int) IPartitionDefinerAtomContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsPartitionDefinerVectorContext differentiates from other interfaces.
|
|
IsPartitionDefinerVectorContext()
|
|
}
|
|
|
|
type PartitionDefinerVectorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionDefinerVectorContext() *PartitionDefinerVectorContext {
|
|
var p = new(PartitionDefinerVectorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerVector
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionDefinerVectorContext(p *PartitionDefinerVectorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerVector
|
|
}
|
|
|
|
func (*PartitionDefinerVectorContext) IsPartitionDefinerVectorContext() {}
|
|
|
|
func NewPartitionDefinerVectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinerVectorContext {
|
|
var p = new(PartitionDefinerVectorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionDefinerVector
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionDefinerVectorContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinerAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
tst[i] = t.(IPartitionDefinerAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinerAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinerAtomContext)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionDefinerVector(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionDefinerVector(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionDefinerVectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionDefinerVector(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionDefinerVector() (localctx IPartitionDefinerVectorContext) {
|
|
localctx = NewPartitionDefinerVectorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 122, MySqlParserRULE_partitionDefinerVector)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2269)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2270)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
p.SetState(2273)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2271)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2272)
|
|
p.PartitionDefinerAtom()
|
|
}
|
|
|
|
p.SetState(2275)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2277)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISubpartitionDefinitionContext is an interface to support dynamic dispatch.
|
|
type ISubpartitionDefinitionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SUBPARTITION() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AllPartitionOption() []IPartitionOptionContext
|
|
PartitionOption(i int) IPartitionOptionContext
|
|
|
|
// IsSubpartitionDefinitionContext differentiates from other interfaces.
|
|
IsSubpartitionDefinitionContext()
|
|
}
|
|
|
|
type SubpartitionDefinitionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySubpartitionDefinitionContext() *SubpartitionDefinitionContext {
|
|
var p = new(SubpartitionDefinitionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_subpartitionDefinition
|
|
return p
|
|
}
|
|
|
|
func InitEmptySubpartitionDefinitionContext(p *SubpartitionDefinitionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_subpartitionDefinition
|
|
}
|
|
|
|
func (*SubpartitionDefinitionContext) IsSubpartitionDefinitionContext() {}
|
|
|
|
func NewSubpartitionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubpartitionDefinitionContext {
|
|
var p = new(SubpartitionDefinitionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_subpartitionDefinition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SubpartitionDefinitionContext) SUBPARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBPARTITION, 0)
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) AllPartitionOption() []IPartitionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionOptionContext); ok {
|
|
tst[i] = t.(IPartitionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) PartitionOption(i int) IPartitionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionOptionContext)
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubpartitionDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubpartitionDefinition(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubpartitionDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubpartitionDefinition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SubpartitionDefinition() (localctx ISubpartitionDefinitionContext) {
|
|
localctx = NewSubpartitionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 124, MySqlParserRULE_subpartitionDefinition)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2279)
|
|
p.Match(MySqlParserSUBPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2280)
|
|
p.Uid()
|
|
}
|
|
p.SetState(2284)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE {
|
|
{
|
|
p.SetState(2281)
|
|
p.PartitionOption()
|
|
}
|
|
|
|
p.SetState(2286)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionOptionContext is an interface to support dynamic dispatch.
|
|
type IPartitionOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsPartitionOptionContext differentiates from other interfaces.
|
|
IsPartitionOptionContext()
|
|
}
|
|
|
|
type PartitionOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionOptionContext() *PartitionOptionContext {
|
|
var p = new(PartitionOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionOptionContext(p *PartitionOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionOption
|
|
}
|
|
|
|
func (*PartitionOptionContext) IsPartitionOptionContext() {}
|
|
|
|
func NewPartitionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionOptionContext {
|
|
var p = new(PartitionOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionOptionContext) CopyAll(ctx *PartitionOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *PartitionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PartitionOptionCommentContext struct {
|
|
PartitionOptionContext
|
|
comment antlr.Token
|
|
}
|
|
|
|
func NewPartitionOptionCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionCommentContext {
|
|
var p = new(PartitionOptionCommentContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) GetComment() antlr.Token { return s.comment }
|
|
|
|
func (s *PartitionOptionCommentContext) SetComment(v antlr.Token) { s.comment = v }
|
|
|
|
func (s *PartitionOptionCommentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionComment(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionComment(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionNodeGroupContext struct {
|
|
PartitionOptionContext
|
|
nodegroup IUidContext
|
|
}
|
|
|
|
func NewPartitionOptionNodeGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionNodeGroupContext {
|
|
var p = new(PartitionOptionNodeGroupContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) GetNodegroup() IUidContext { return s.nodegroup }
|
|
|
|
func (s *PartitionOptionNodeGroupContext) SetNodegroup(v IUidContext) { s.nodegroup = v }
|
|
|
|
func (s *PartitionOptionNodeGroupContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) NODEGROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNODEGROUP, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionNodeGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionNodeGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionNodeGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionNodeGroup(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionIndexDirectoryContext struct {
|
|
PartitionOptionContext
|
|
indexDirectory antlr.Token
|
|
}
|
|
|
|
func NewPartitionOptionIndexDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionIndexDirectoryContext {
|
|
var p = new(PartitionOptionIndexDirectoryContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) GetIndexDirectory() antlr.Token {
|
|
return s.indexDirectory
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) SetIndexDirectory(v antlr.Token) { s.indexDirectory = v }
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionIndexDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionIndexDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionIndexDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionIndexDirectory(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionMaxRowsContext struct {
|
|
PartitionOptionContext
|
|
maxRows IDecimalLiteralContext
|
|
}
|
|
|
|
func NewPartitionOptionMaxRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionMaxRowsContext {
|
|
var p = new(PartitionOptionMaxRowsContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) GetMaxRows() IDecimalLiteralContext { return s.maxRows }
|
|
|
|
func (s *PartitionOptionMaxRowsContext) SetMaxRows(v IDecimalLiteralContext) { s.maxRows = v }
|
|
|
|
func (s *PartitionOptionMaxRowsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) MAX_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_ROWS, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionMaxRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionMaxRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionMaxRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionMaxRows(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionTablespaceContext struct {
|
|
PartitionOptionContext
|
|
tablespace IUidContext
|
|
}
|
|
|
|
func NewPartitionOptionTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionTablespaceContext {
|
|
var p = new(PartitionOptionTablespaceContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) GetTablespace() IUidContext { return s.tablespace }
|
|
|
|
func (s *PartitionOptionTablespaceContext) SetTablespace(v IUidContext) { s.tablespace = v }
|
|
|
|
func (s *PartitionOptionTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionEngineContext struct {
|
|
PartitionOptionContext
|
|
}
|
|
|
|
func NewPartitionOptionEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionEngineContext {
|
|
var p = new(PartitionOptionEngineContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) STORAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORAGE, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionEngine(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionMinRowsContext struct {
|
|
PartitionOptionContext
|
|
minRows IDecimalLiteralContext
|
|
}
|
|
|
|
func NewPartitionOptionMinRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionMinRowsContext {
|
|
var p = new(PartitionOptionMinRowsContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) GetMinRows() IDecimalLiteralContext { return s.minRows }
|
|
|
|
func (s *PartitionOptionMinRowsContext) SetMinRows(v IDecimalLiteralContext) { s.minRows = v }
|
|
|
|
func (s *PartitionOptionMinRowsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) MIN_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIN_ROWS, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionMinRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionMinRows(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionMinRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionMinRows(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PartitionOptionDataDirectoryContext struct {
|
|
PartitionOptionContext
|
|
dataDirectory antlr.Token
|
|
}
|
|
|
|
func NewPartitionOptionDataDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionDataDirectoryContext {
|
|
var p = new(PartitionOptionDataDirectoryContext)
|
|
|
|
InitEmptyPartitionOptionContext(&p.PartitionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PartitionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) GetDataDirectory() antlr.Token { return s.dataDirectory }
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) SetDataDirectory(v antlr.Token) { s.dataDirectory = v }
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionOptionDataDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionOptionDataDirectory(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionOptionDataDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionOptionDataDirectory(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionOption() (localctx IPartitionOptionContext) {
|
|
localctx = NewPartitionOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 126, MySqlParserRULE_partitionOption)
|
|
var _la int
|
|
|
|
p.SetState(2335)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDEFAULT, MySqlParserENGINE, MySqlParserSTORAGE:
|
|
localctx = NewPartitionOptionEngineContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(2288)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(2287)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2291)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTORAGE {
|
|
{
|
|
p.SetState(2290)
|
|
p.Match(MySqlParserSTORAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2293)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2295)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2294)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2297)
|
|
p.EngineName()
|
|
}
|
|
|
|
case MySqlParserCOMMENT:
|
|
localctx = NewPartitionOptionCommentContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2298)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2300)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2299)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2302)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PartitionOptionCommentContext).comment = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDATA:
|
|
localctx = NewPartitionOptionDataDirectoryContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2303)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2304)
|
|
p.Match(MySqlParserDIRECTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2306)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2305)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2308)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PartitionOptionDataDirectoryContext).dataDirectory = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserINDEX:
|
|
localctx = NewPartitionOptionIndexDirectoryContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(2309)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2310)
|
|
p.Match(MySqlParserDIRECTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2312)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2311)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2314)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PartitionOptionIndexDirectoryContext).indexDirectory = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMAX_ROWS:
|
|
localctx = NewPartitionOptionMaxRowsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(2315)
|
|
p.Match(MySqlParserMAX_ROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2317)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2316)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2319)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*PartitionOptionMaxRowsContext).maxRows = _x
|
|
}
|
|
|
|
case MySqlParserMIN_ROWS:
|
|
localctx = NewPartitionOptionMinRowsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(2320)
|
|
p.Match(MySqlParserMIN_ROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2322)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2321)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2324)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*PartitionOptionMinRowsContext).minRows = _x
|
|
}
|
|
|
|
case MySqlParserTABLESPACE:
|
|
localctx = NewPartitionOptionTablespaceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(2325)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2327)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2326)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2329)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*PartitionOptionTablespaceContext).tablespace = _x
|
|
}
|
|
|
|
case MySqlParserNODEGROUP:
|
|
localctx = NewPartitionOptionNodeGroupContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(2330)
|
|
p.Match(MySqlParserNODEGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2332)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2331)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2334)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*PartitionOptionNodeGroupContext).nodegroup = _x
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterDatabaseContext is an interface to support dynamic dispatch.
|
|
type IAlterDatabaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsAlterDatabaseContext differentiates from other interfaces.
|
|
IsAlterDatabaseContext()
|
|
}
|
|
|
|
type AlterDatabaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterDatabaseContext() *AlterDatabaseContext {
|
|
var p = new(AlterDatabaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterDatabase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterDatabaseContext(p *AlterDatabaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterDatabase
|
|
}
|
|
|
|
func (*AlterDatabaseContext) IsAlterDatabaseContext() {}
|
|
|
|
func NewAlterDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterDatabaseContext {
|
|
var p = new(AlterDatabaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterDatabase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterDatabaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterDatabaseContext) CopyAll(ctx *AlterDatabaseContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *AlterDatabaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type AlterUpgradeNameContext struct {
|
|
AlterDatabaseContext
|
|
dbFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterUpgradeNameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUpgradeNameContext {
|
|
var p = new(AlterUpgradeNameContext)
|
|
|
|
InitEmptyAlterDatabaseContext(&p.AlterDatabaseContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterDatabaseContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) GetDbFormat() antlr.Token { return s.dbFormat }
|
|
|
|
func (s *AlterUpgradeNameContext) SetDbFormat(v antlr.Token) { s.dbFormat = v }
|
|
|
|
func (s *AlterUpgradeNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) UPGRADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPGRADE, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNAME, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterUpgradeName(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterUpgradeName(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUpgradeNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterUpgradeName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterSimpleDatabaseContext struct {
|
|
AlterDatabaseContext
|
|
dbFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterSimpleDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterSimpleDatabaseContext {
|
|
var p = new(AlterSimpleDatabaseContext)
|
|
|
|
InitEmptyAlterDatabaseContext(&p.AlterDatabaseContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterDatabaseContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat }
|
|
|
|
func (s *AlterSimpleDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v }
|
|
|
|
func (s *AlterSimpleDatabaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) AllCreateDatabaseOption() []ICreateDatabaseOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICreateDatabaseOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
tst[i] = t.(ICreateDatabaseOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) CreateDatabaseOption(i int) ICreateDatabaseOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDatabaseOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDatabaseOptionContext)
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterSimpleDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterSimpleDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterSimpleDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterSimpleDatabase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterDatabase() (localctx IAlterDatabaseContext) {
|
|
localctx = NewAlterDatabaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 128, MySqlParserRULE_alterDatabase)
|
|
var _la int
|
|
|
|
p.SetState(2355)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewAlterSimpleDatabaseContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2337)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2338)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterSimpleDatabaseContext).dbFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterSimpleDatabaseContext).dbFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(2340)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2339)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(2343)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4398214283264) != 0) || _la == MySqlParserREAD || _la == MySqlParserCHAR || _la == MySqlParserENCRYPTION || _la == MySqlParserCHARSET {
|
|
{
|
|
p.SetState(2342)
|
|
p.CreateDatabaseOption()
|
|
}
|
|
|
|
p.SetState(2345)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewAlterUpgradeNameContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2347)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2348)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterUpgradeNameContext).dbFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterUpgradeNameContext).dbFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2349)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2350)
|
|
p.Match(MySqlParserUPGRADE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2351)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2352)
|
|
p.Match(MySqlParserDIRECTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2353)
|
|
p.Match(MySqlParserNAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterEventContext is an interface to support dynamic dispatch.
|
|
type IAlterEventContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
EVENT() antlr.TerminalNode
|
|
AllFullId() []IFullIdContext
|
|
FullId(i int) IFullIdContext
|
|
OwnerStatement() IOwnerStatementContext
|
|
AllON() []antlr.TerminalNode
|
|
ON(i int) antlr.TerminalNode
|
|
SCHEDULE() antlr.TerminalNode
|
|
ScheduleExpression() IScheduleExpressionContext
|
|
COMPLETION() antlr.TerminalNode
|
|
PRESERVE() antlr.TerminalNode
|
|
RENAME() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
EnableType() IEnableTypeContext
|
|
COMMENT() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
DO() antlr.TerminalNode
|
|
RoutineBody() IRoutineBodyContext
|
|
NOT() antlr.TerminalNode
|
|
|
|
// IsAlterEventContext differentiates from other interfaces.
|
|
IsAlterEventContext()
|
|
}
|
|
|
|
type AlterEventContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterEventContext() *AlterEventContext {
|
|
var p = new(AlterEventContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterEvent
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterEventContext(p *AlterEventContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterEvent
|
|
}
|
|
|
|
func (*AlterEventContext) IsAlterEventContext() {}
|
|
|
|
func NewAlterEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterEventContext {
|
|
var p = new(AlterEventContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterEvent
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterEventContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterEventContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) AllFullId() []IFullIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullIdContext); ok {
|
|
tst[i] = t.(IFullIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterEventContext) FullId(i int) IFullIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *AlterEventContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *AlterEventContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *AlterEventContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *AlterEventContext) SCHEDULE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEDULE, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) ScheduleExpression() IScheduleExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IScheduleExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IScheduleExpressionContext)
|
|
}
|
|
|
|
func (s *AlterEventContext) COMPLETION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPLETION, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) PRESERVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRESERVE, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) EnableType() IEnableTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEnableTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEnableTypeContext)
|
|
}
|
|
|
|
func (s *AlterEventContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) DO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDO, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *AlterEventContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *AlterEventContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterEventContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterEventContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterEvent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterEvent() (localctx IAlterEventContext) {
|
|
localctx = NewAlterEventContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 130, MySqlParserRULE_alterEvent)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2357)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2359)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(2358)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2361)
|
|
p.Match(MySqlParserEVENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2362)
|
|
p.FullId()
|
|
}
|
|
p.SetState(2366)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 282, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2363)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2364)
|
|
p.Match(MySqlParserSCHEDULE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2365)
|
|
p.ScheduleExpression()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(2374)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserON {
|
|
{
|
|
p.SetState(2368)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2369)
|
|
p.Match(MySqlParserCOMPLETION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2371)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(2370)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2373)
|
|
p.Match(MySqlParserPRESERVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2379)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 285, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2376)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2377)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2378)
|
|
p.FullId()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(2382)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDISABLE || _la == MySqlParserENABLE {
|
|
{
|
|
p.SetState(2381)
|
|
p.EnableType()
|
|
}
|
|
|
|
}
|
|
p.SetState(2386)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMENT {
|
|
{
|
|
p.SetState(2384)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2385)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2390)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 288, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2388)
|
|
p.Match(MySqlParserDO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2389)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterFunctionContext is an interface to support dynamic dispatch.
|
|
type IAlterFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
AllRoutineOption() []IRoutineOptionContext
|
|
RoutineOption(i int) IRoutineOptionContext
|
|
|
|
// IsAlterFunctionContext differentiates from other interfaces.
|
|
IsAlterFunctionContext()
|
|
}
|
|
|
|
type AlterFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterFunctionContext() *AlterFunctionContext {
|
|
var p = new(AlterFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterFunctionContext(p *AlterFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterFunction
|
|
}
|
|
|
|
func (*AlterFunctionContext) IsAlterFunctionContext() {}
|
|
|
|
func NewAlterFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterFunctionContext {
|
|
var p = new(AlterFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterFunctionContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterFunctionContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *AlterFunctionContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *AlterFunctionContext) AllRoutineOption() []IRoutineOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoutineOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoutineOptionContext); ok {
|
|
tst[i] = t.(IRoutineOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterFunctionContext) RoutineOption(i int) IRoutineOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineOptionContext)
|
|
}
|
|
|
|
func (s *AlterFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterFunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterFunction() (localctx IAlterFunctionContext) {
|
|
localctx = NewAlterFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 132, MySqlParserRULE_alterFunction)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2392)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2393)
|
|
p.Match(MySqlParserFUNCTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2394)
|
|
p.FullId()
|
|
}
|
|
p.SetState(2398)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDETERMINISTIC || ((int64((_la-112)) & ^0x3f) == 0 && ((int64(1)<<(_la-112))&281474985099269) != 0) || _la == MySqlParserCOMMENT || _la == MySqlParserCONTAINS || _la == MySqlParserLANGUAGE || _la == MySqlParserNO {
|
|
{
|
|
p.SetState(2395)
|
|
p.RoutineOption()
|
|
}
|
|
|
|
p.SetState(2400)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterInstanceContext is an interface to support dynamic dispatch.
|
|
type IAlterInstanceContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
INSTANCE() antlr.TerminalNode
|
|
ROTATE() antlr.TerminalNode
|
|
INNODB() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
KEY() antlr.TerminalNode
|
|
|
|
// IsAlterInstanceContext differentiates from other interfaces.
|
|
IsAlterInstanceContext()
|
|
}
|
|
|
|
type AlterInstanceContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterInstanceContext() *AlterInstanceContext {
|
|
var p = new(AlterInstanceContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterInstance
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterInstanceContext(p *AlterInstanceContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterInstance
|
|
}
|
|
|
|
func (*AlterInstanceContext) IsAlterInstanceContext() {}
|
|
|
|
func NewAlterInstanceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterInstanceContext {
|
|
var p = new(AlterInstanceContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterInstance
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterInstanceContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterInstanceContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) INSTANCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTANCE, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) ROTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROTATE, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) INNODB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNODB, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterInstanceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterInstanceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterInstance(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterInstanceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterInstance(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterInstanceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterInstance(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterInstance() (localctx IAlterInstanceContext) {
|
|
localctx = NewAlterInstanceContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 134, MySqlParserRULE_alterInstance)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2401)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2402)
|
|
p.Match(MySqlParserINSTANCE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2403)
|
|
p.Match(MySqlParserROTATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2404)
|
|
p.Match(MySqlParserINNODB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2405)
|
|
p.Match(MySqlParserMASTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2406)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterLogfileGroupContext is an interface to support dynamic dispatch.
|
|
type IAlterLogfileGroupContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
LOGFILE() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ADD() antlr.TerminalNode
|
|
UNDOFILE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
INITIAL_SIZE() antlr.TerminalNode
|
|
FileSizeLiteral() IFileSizeLiteralContext
|
|
WAIT() antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
|
|
// IsAlterLogfileGroupContext differentiates from other interfaces.
|
|
IsAlterLogfileGroupContext()
|
|
}
|
|
|
|
type AlterLogfileGroupContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterLogfileGroupContext() *AlterLogfileGroupContext {
|
|
var p = new(AlterLogfileGroupContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterLogfileGroup
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterLogfileGroupContext(p *AlterLogfileGroupContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterLogfileGroup
|
|
}
|
|
|
|
func (*AlterLogfileGroupContext) IsAlterLogfileGroupContext() {}
|
|
|
|
func NewAlterLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterLogfileGroupContext {
|
|
var p = new(AlterLogfileGroupContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterLogfileGroup
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterLogfileGroupContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) LOGFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGFILE, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) UNDOFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDOFILE, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) INITIAL_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINITIAL_SIZE, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) FileSizeLiteral() IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterLogfileGroup(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterLogfileGroup() (localctx IAlterLogfileGroupContext) {
|
|
localctx = NewAlterLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 136, MySqlParserRULE_alterLogfileGroup)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2408)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2409)
|
|
p.Match(MySqlParserLOGFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2410)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2411)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2412)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2413)
|
|
p.Match(MySqlParserUNDOFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2414)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2420)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINITIAL_SIZE {
|
|
{
|
|
p.SetState(2415)
|
|
p.Match(MySqlParserINITIAL_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2417)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2416)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2419)
|
|
p.FileSizeLiteral()
|
|
}
|
|
|
|
}
|
|
p.SetState(2423)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(2422)
|
|
p.Match(MySqlParserWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2425)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2427)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2426)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2429)
|
|
p.EngineName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterProcedureContext is an interface to support dynamic dispatch.
|
|
type IAlterProcedureContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
PROCEDURE() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
AllRoutineOption() []IRoutineOptionContext
|
|
RoutineOption(i int) IRoutineOptionContext
|
|
|
|
// IsAlterProcedureContext differentiates from other interfaces.
|
|
IsAlterProcedureContext()
|
|
}
|
|
|
|
type AlterProcedureContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterProcedureContext() *AlterProcedureContext {
|
|
var p = new(AlterProcedureContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterProcedure
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterProcedureContext(p *AlterProcedureContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterProcedure
|
|
}
|
|
|
|
func (*AlterProcedureContext) IsAlterProcedureContext() {}
|
|
|
|
func NewAlterProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterProcedureContext {
|
|
var p = new(AlterProcedureContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterProcedure
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterProcedureContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterProcedureContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterProcedureContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *AlterProcedureContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *AlterProcedureContext) AllRoutineOption() []IRoutineOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoutineOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoutineOptionContext); ok {
|
|
tst[i] = t.(IRoutineOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterProcedureContext) RoutineOption(i int) IRoutineOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineOptionContext)
|
|
}
|
|
|
|
func (s *AlterProcedureContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterProcedureContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterProcedureContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterProcedure(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterProcedure() (localctx IAlterProcedureContext) {
|
|
localctx = NewAlterProcedureContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 138, MySqlParserRULE_alterProcedure)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2431)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2432)
|
|
p.Match(MySqlParserPROCEDURE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2433)
|
|
p.FullId()
|
|
}
|
|
p.SetState(2437)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDETERMINISTIC || ((int64((_la-112)) & ^0x3f) == 0 && ((int64(1)<<(_la-112))&281474985099269) != 0) || _la == MySqlParserCOMMENT || _la == MySqlParserCONTAINS || _la == MySqlParserLANGUAGE || _la == MySqlParserNO {
|
|
{
|
|
p.SetState(2434)
|
|
p.RoutineOption()
|
|
}
|
|
|
|
p.SetState(2439)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterServerContext is an interface to support dynamic dispatch.
|
|
type IAlterServerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
SERVER() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
OPTIONS() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllServerOption() []IServerOptionContext
|
|
ServerOption(i int) IServerOptionContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsAlterServerContext differentiates from other interfaces.
|
|
IsAlterServerContext()
|
|
}
|
|
|
|
type AlterServerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterServerContext() *AlterServerContext {
|
|
var p = new(AlterServerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterServer
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterServerContext(p *AlterServerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterServer
|
|
}
|
|
|
|
func (*AlterServerContext) IsAlterServerContext() {}
|
|
|
|
func NewAlterServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterServerContext {
|
|
var p = new(AlterServerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterServer
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterServerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterServerContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterServerContext) SERVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERVER, 0)
|
|
}
|
|
|
|
func (s *AlterServerContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterServerContext) OPTIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONS, 0)
|
|
}
|
|
|
|
func (s *AlterServerContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterServerContext) AllServerOption() []IServerOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IServerOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IServerOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IServerOptionContext); ok {
|
|
tst[i] = t.(IServerOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterServerContext) ServerOption(i int) IServerOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IServerOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IServerOptionContext)
|
|
}
|
|
|
|
func (s *AlterServerContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterServerContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterServerContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterServerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterServerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterServerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterServer(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterServer() (localctx IAlterServerContext) {
|
|
localctx = NewAlterServerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 140, MySqlParserRULE_alterServer)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2440)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2441)
|
|
p.Match(MySqlParserSERVER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2442)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2443)
|
|
p.Match(MySqlParserOPTIONS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2444)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2445)
|
|
p.ServerOption()
|
|
}
|
|
p.SetState(2450)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2446)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2447)
|
|
p.ServerOption()
|
|
}
|
|
|
|
p.SetState(2452)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2453)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterTableContext is an interface to support dynamic dispatch.
|
|
type IAlterTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIntimeAction returns the intimeAction token.
|
|
GetIntimeAction() antlr.Token
|
|
|
|
// SetIntimeAction sets the intimeAction token.
|
|
SetIntimeAction(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
IGNORE() antlr.TerminalNode
|
|
WaitNowaitClause() IWaitNowaitClauseContext
|
|
AllAlterSpecification() []IAlterSpecificationContext
|
|
AlterSpecification(i int) IAlterSpecificationContext
|
|
PartitionDefinitions() IPartitionDefinitionsContext
|
|
ONLINE() antlr.TerminalNode
|
|
OFFLINE() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsAlterTableContext differentiates from other interfaces.
|
|
IsAlterTableContext()
|
|
}
|
|
|
|
type AlterTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
intimeAction antlr.Token
|
|
}
|
|
|
|
func NewEmptyAlterTableContext() *AlterTableContext {
|
|
var p = new(AlterTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterTableContext(p *AlterTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterTable
|
|
}
|
|
|
|
func (*AlterTableContext) IsAlterTableContext() {}
|
|
|
|
func NewAlterTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableContext {
|
|
var p = new(AlterTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterTableContext) GetIntimeAction() antlr.Token { return s.intimeAction }
|
|
|
|
func (s *AlterTableContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v }
|
|
|
|
func (s *AlterTableContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *AlterTableContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *AlterTableContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *AlterTableContext) WaitNowaitClause() IWaitNowaitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWaitNowaitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWaitNowaitClauseContext)
|
|
}
|
|
|
|
func (s *AlterTableContext) AllAlterSpecification() []IAlterSpecificationContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IAlterSpecificationContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IAlterSpecificationContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IAlterSpecificationContext); ok {
|
|
tst[i] = t.(IAlterSpecificationContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterTableContext) AlterSpecification(i int) IAlterSpecificationContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterSpecificationContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterSpecificationContext)
|
|
}
|
|
|
|
func (s *AlterTableContext) PartitionDefinitions() IPartitionDefinitionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionsContext)
|
|
}
|
|
|
|
func (s *AlterTableContext) ONLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLINE, 0)
|
|
}
|
|
|
|
func (s *AlterTableContext) OFFLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFLINE, 0)
|
|
}
|
|
|
|
func (s *AlterTableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterTableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterTable() (localctx IAlterTableContext) {
|
|
localctx = NewAlterTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 142, MySqlParserRULE_alterTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2455)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2457)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOFFLINE || _la == MySqlParserONLINE {
|
|
{
|
|
p.SetState(2456)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterTableContext).intimeAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterTableContext).intimeAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2460)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(2459)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2462)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2463)
|
|
p.TableName()
|
|
}
|
|
p.SetState(2465)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOWAIT || _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(2464)
|
|
p.WaitNowaitClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(2475)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 300, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2467)
|
|
p.AlterSpecification()
|
|
}
|
|
p.SetState(2472)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2468)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2469)
|
|
p.AlterSpecification()
|
|
}
|
|
|
|
p.SetState(2474)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(2478)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(2477)
|
|
p.PartitionDefinitions()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterTablespaceContext is an interface to support dynamic dispatch.
|
|
type IAlterTablespaceContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetObjectAction returns the objectAction token.
|
|
GetObjectAction() antlr.Token
|
|
|
|
// SetObjectAction sets the objectAction token.
|
|
SetObjectAction(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
DATAFILE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
ADD() antlr.TerminalNode
|
|
DROP() antlr.TerminalNode
|
|
INITIAL_SIZE() antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
FileSizeLiteral() IFileSizeLiteralContext
|
|
WAIT() antlr.TerminalNode
|
|
|
|
// IsAlterTablespaceContext differentiates from other interfaces.
|
|
IsAlterTablespaceContext()
|
|
}
|
|
|
|
type AlterTablespaceContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
objectAction antlr.Token
|
|
}
|
|
|
|
func NewEmptyAlterTablespaceContext() *AlterTablespaceContext {
|
|
var p = new(AlterTablespaceContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterTablespace
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterTablespaceContext(p *AlterTablespaceContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterTablespace
|
|
}
|
|
|
|
func (*AlterTablespaceContext) IsAlterTablespaceContext() {}
|
|
|
|
func NewAlterTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTablespaceContext {
|
|
var p = new(AlterTablespaceContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterTablespace
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterTablespaceContext) GetObjectAction() antlr.Token { return s.objectAction }
|
|
|
|
func (s *AlterTablespaceContext) SetObjectAction(v antlr.Token) { s.objectAction = v }
|
|
|
|
func (s *AlterTablespaceContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) DATAFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATAFILE, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) INITIAL_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINITIAL_SIZE, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) FileSizeLiteral() IFileSizeLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFileSizeLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFileSizeLiteralContext)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterTablespace() (localctx IAlterTablespaceContext) {
|
|
localctx = NewAlterTablespaceContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 144, MySqlParserRULE_alterTablespace)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2480)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2481)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2482)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2483)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterTablespaceContext).objectAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserADD || _la == MySqlParserDROP) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterTablespaceContext).objectAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2484)
|
|
p.Match(MySqlParserDATAFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2485)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2489)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINITIAL_SIZE {
|
|
{
|
|
p.SetState(2486)
|
|
p.Match(MySqlParserINITIAL_SIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2487)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2488)
|
|
p.FileSizeLiteral()
|
|
}
|
|
|
|
}
|
|
p.SetState(2492)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(2491)
|
|
p.Match(MySqlParserWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2494)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2496)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2495)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2498)
|
|
p.EngineName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterViewContext is an interface to support dynamic dispatch.
|
|
type IAlterViewContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetAlgType returns the algType token.
|
|
GetAlgType() antlr.Token
|
|
|
|
// GetSecContext returns the secContext token.
|
|
GetSecContext() antlr.Token
|
|
|
|
// GetCheckOpt returns the checkOpt token.
|
|
GetCheckOpt() antlr.Token
|
|
|
|
// SetAlgType sets the algType token.
|
|
SetAlgType(antlr.Token)
|
|
|
|
// SetSecContext sets the secContext token.
|
|
SetSecContext(antlr.Token)
|
|
|
|
// SetCheckOpt sets the checkOpt token.
|
|
SetCheckOpt(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ALTER() antlr.TerminalNode
|
|
VIEW() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
AS() antlr.TerminalNode
|
|
SelectStatement() ISelectStatementContext
|
|
ALGORITHM() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
OwnerStatement() IOwnerStatementContext
|
|
SQL() antlr.TerminalNode
|
|
SECURITY() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
WITH() antlr.TerminalNode
|
|
CHECK() antlr.TerminalNode
|
|
OPTION() antlr.TerminalNode
|
|
UNDEFINED() antlr.TerminalNode
|
|
MERGE() antlr.TerminalNode
|
|
TEMPTABLE() antlr.TerminalNode
|
|
DEFINER() antlr.TerminalNode
|
|
INVOKER() antlr.TerminalNode
|
|
CASCADED() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
|
|
// IsAlterViewContext differentiates from other interfaces.
|
|
IsAlterViewContext()
|
|
}
|
|
|
|
type AlterViewContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
algType antlr.Token
|
|
secContext antlr.Token
|
|
checkOpt antlr.Token
|
|
}
|
|
|
|
func NewEmptyAlterViewContext() *AlterViewContext {
|
|
var p = new(AlterViewContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterView
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterViewContext(p *AlterViewContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterView
|
|
}
|
|
|
|
func (*AlterViewContext) IsAlterViewContext() {}
|
|
|
|
func NewAlterViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterViewContext {
|
|
var p = new(AlterViewContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterView
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterViewContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterViewContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *AlterViewContext) GetSecContext() antlr.Token { return s.secContext }
|
|
|
|
func (s *AlterViewContext) GetCheckOpt() antlr.Token { return s.checkOpt }
|
|
|
|
func (s *AlterViewContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *AlterViewContext) SetSecContext(v antlr.Token) { s.secContext = v }
|
|
|
|
func (s *AlterViewContext) SetCheckOpt(v antlr.Token) { s.checkOpt = v }
|
|
|
|
func (s *AlterViewContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *AlterViewContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *AlterViewContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) OwnerStatement() IOwnerStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOwnerStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOwnerStatementContext)
|
|
}
|
|
|
|
func (s *AlterViewContext) SQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) SECURITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECURITY, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterViewContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) OPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) UNDEFINED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDEFINED, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) MERGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMERGE, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) TEMPTABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPTABLE, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) DEFINER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFINER, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) INVOKER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKER, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) CASCADED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADED, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *AlterViewContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AlterViewContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterView(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterViewContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterView(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterView(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterView() (localctx IAlterViewContext) {
|
|
localctx = NewAlterViewContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 146, MySqlParserRULE_alterView)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2500)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2504)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALGORITHM {
|
|
{
|
|
p.SetState(2501)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2502)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2503)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterViewContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMERGE || _la == MySqlParserTEMPTABLE || _la == MySqlParserUNDEFINED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterViewContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2507)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFINER {
|
|
{
|
|
p.SetState(2506)
|
|
p.OwnerStatement()
|
|
}
|
|
|
|
}
|
|
p.SetState(2512)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSQL {
|
|
{
|
|
p.SetState(2509)
|
|
p.Match(MySqlParserSQL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2510)
|
|
p.Match(MySqlParserSECURITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2511)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterViewContext).secContext = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterViewContext).secContext = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2514)
|
|
p.Match(MySqlParserVIEW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2515)
|
|
p.FullId()
|
|
}
|
|
p.SetState(2520)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(2516)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2517)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(2518)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2522)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2523)
|
|
p.SelectStatement()
|
|
}
|
|
p.SetState(2530)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2524)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2526)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCASCADED || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(2525)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterViewContext).checkOpt = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCASCADED || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterViewContext).checkOpt = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2528)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2529)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterSpecificationContext is an interface to support dynamic dispatch.
|
|
type IAlterSpecificationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsAlterSpecificationContext differentiates from other interfaces.
|
|
IsAlterSpecificationContext()
|
|
}
|
|
|
|
type AlterSpecificationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterSpecificationContext() *AlterSpecificationContext {
|
|
var p = new(AlterSpecificationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterSpecification
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterSpecificationContext(p *AlterSpecificationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterSpecification
|
|
}
|
|
|
|
func (*AlterSpecificationContext) IsAlterSpecificationContext() {}
|
|
|
|
func NewAlterSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterSpecificationContext {
|
|
var p = new(AlterSpecificationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterSpecification
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterSpecificationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterSpecificationContext) CopyAll(ctx *AlterSpecificationContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *AlterSpecificationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type AlterByAlterColumnDefaultContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAlterColumnDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterColumnDefaultContext {
|
|
var p = new(AlterByAlterColumnDefaultContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) VISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVISIBLE, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) INVISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVISIBLE, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAlterColumnDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAlterColumnDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterColumnDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAlterColumnDefault(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDisableKeysContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDisableKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDisableKeysContext {
|
|
var p = new(AlterByDisableKeysContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) DISABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISABLE, 0)
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEYS, 0)
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDisableKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDisableKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDisableKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDisableKeys(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDefaultCharsetContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDefaultCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDefaultCharsetContext {
|
|
var p = new(AlterByDefaultCharsetContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDefaultCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDefaultCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDefaultCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDefaultCharset(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRenameColumnContext struct {
|
|
AlterSpecificationContext
|
|
oldColumn IUidContext
|
|
newColumn IUidContext
|
|
}
|
|
|
|
func NewAlterByRenameColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameColumnContext {
|
|
var p = new(AlterByRenameColumnContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) GetOldColumn() IUidContext { return s.oldColumn }
|
|
|
|
func (s *AlterByRenameColumnContext) GetNewColumn() IUidContext { return s.newColumn }
|
|
|
|
func (s *AlterByRenameColumnContext) SetOldColumn(v IUidContext) { s.oldColumn = v }
|
|
|
|
func (s *AlterByRenameColumnContext) SetNewColumn(v IUidContext) { s.newColumn = v }
|
|
|
|
func (s *AlterByRenameColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRenameColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRenameColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRenameColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByConvertCharsetContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByConvertCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByConvertCharsetContext {
|
|
var p = new(AlterByConvertCharsetContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) CONVERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONVERT, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) CHARSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARSET, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByConvertCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByConvertCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByConvertCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByConvertCharset(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddForeignKeyContext struct {
|
|
AlterSpecificationContext
|
|
name IUidContext
|
|
indexName IUidContext
|
|
}
|
|
|
|
func NewAlterByAddForeignKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddForeignKeyContext {
|
|
var p = new(AlterByAddForeignKeyContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *AlterByAddForeignKeyContext) GetIndexName() IUidContext { return s.indexName }
|
|
|
|
func (s *AlterByAddForeignKeyContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *AlterByAddForeignKeyContext) SetIndexName(v IUidContext) { s.indexName = v }
|
|
|
|
func (s *AlterByAddForeignKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) FOREIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOREIGN, 0)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) ReferenceDefinition() IReferenceDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReferenceDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReferenceDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddForeignKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddForeignKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddForeignKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddForeignKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRenameIndexContext struct {
|
|
AlterSpecificationContext
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByRenameIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameIndexContext {
|
|
var p = new(AlterByRenameIndexContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *AlterByRenameIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *AlterByRenameIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRenameIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRenameIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRenameIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRenameContext struct {
|
|
AlterSpecificationContext
|
|
renameFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByRenameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameContext {
|
|
var p = new(AlterByRenameContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRenameContext) GetRenameFormat() antlr.Token { return s.renameFormat }
|
|
|
|
func (s *AlterByRenameContext) SetRenameFormat(v antlr.Token) { s.renameFormat = v }
|
|
|
|
func (s *AlterByRenameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRenameContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByRenameContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *AlterByRenameContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *AlterByRenameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRename(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRename(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRename(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByImportTablespaceContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByImportTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByImportTablespaceContext {
|
|
var p = new(AlterByImportTablespaceContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) IMPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIMPORT, 0)
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByImportTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByImportTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByImportTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByImportTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddDefinitionsContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAddDefinitionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddDefinitionsContext {
|
|
var p = new(AlterByAddDefinitionsContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) AllCreateDefinition() []ICreateDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICreateDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICreateDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICreateDefinitionContext); ok {
|
|
tst[i] = t.(ICreateDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) CreateDefinition(i int) ICreateDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICreateDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICreateDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddDefinitions(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddDefinitions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAlterCheckTableConstraintContext struct {
|
|
AlterSpecificationContext
|
|
name IUidContext
|
|
}
|
|
|
|
func NewAlterByAlterCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterCheckTableConstraintContext {
|
|
var p = new(AlterByAlterCheckTableConstraintContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) ENFORCED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENFORCED, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAlterCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAlterCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterCheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAlterCheckTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropConstraintCheckContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDropConstraintCheckContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropConstraintCheckContext {
|
|
var p = new(AlterByDropConstraintCheckContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropConstraintCheck(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropConstraintCheck(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropConstraintCheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropConstraintCheck(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddColumnsContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAddColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddColumnsContext {
|
|
var p = new(AlterByAddColumnsContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) AllColumnDefinition() []IColumnDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IColumnDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IColumnDefinitionContext); ok {
|
|
tst[i] = t.(IColumnDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) ColumnDefinition(i int) IColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddColumns(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddColumns(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddColumns(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAlterIndexVisibilityContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAlterIndexVisibilityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterIndexVisibilityContext {
|
|
var p = new(AlterByAlterIndexVisibilityContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) VISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVISIBLE, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) INVISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVISIBLE, 0)
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAlterIndexVisibility(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAlterIndexVisibility(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAlterIndexVisibilityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAlterIndexVisibility(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropForeignKeyContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDropForeignKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropForeignKeyContext {
|
|
var p = new(AlterByDropForeignKeyContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) FOREIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOREIGN, 0)
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropForeignKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropForeignKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropForeignKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropForeignKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddCheckTableConstraintContext struct {
|
|
AlterSpecificationContext
|
|
name IUidContext
|
|
}
|
|
|
|
func NewAlterByAddCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddCheckTableConstraintContext {
|
|
var p = new(AlterByAddCheckTableConstraintContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) ENFORCED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENFORCED, 0)
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddCheckTableConstraint(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddCheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddCheckTableConstraint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterPartitionContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterPartitionContext {
|
|
var p = new(AlterPartitionContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterPartitionContext) AlterPartitionSpecification() IAlterPartitionSpecificationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAlterPartitionSpecificationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAlterPartitionSpecificationContext)
|
|
}
|
|
|
|
func (s *AlterPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddIndexContext struct {
|
|
AlterSpecificationContext
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByAddIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddIndexContext {
|
|
var p = new(AlterByAddIndexContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *AlterByAddIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *AlterByAddIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropColumnContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDropColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropColumnContext {
|
|
var p = new(AlterByDropColumnContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) RESTRICT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESTRICT, 0)
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByChangeDefaultContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByChangeDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByChangeDefaultContext {
|
|
var p = new(AlterByChangeDefaultContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) DefaultValue() IDefaultValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDefaultValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDefaultValueContext)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByChangeDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByChangeDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByChangeDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByChangeDefault(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByForceContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByForceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByForceContext {
|
|
var p = new(AlterByForceContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByForceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByForceContext) FORCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFORCE, 0)
|
|
}
|
|
|
|
func (s *AlterByForceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByForce(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByForceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByForce(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByForceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByForce(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddSpecialIndexContext struct {
|
|
AlterSpecificationContext
|
|
keyType antlr.Token
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByAddSpecialIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddSpecialIndexContext {
|
|
var p = new(AlterByAddSpecialIndexContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) GetKeyType() antlr.Token { return s.keyType }
|
|
|
|
func (s *AlterByAddSpecialIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *AlterByAddSpecialIndexContext) SetKeyType(v antlr.Token) { s.keyType = v }
|
|
|
|
func (s *AlterByAddSpecialIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *AlterByAddSpecialIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) FULLTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULLTEXT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) SPATIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSPATIAL, 0)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddSpecialIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddSpecialIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddSpecialIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddSpecialIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByModifyColumnContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByModifyColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByModifyColumnContext {
|
|
var p = new(AlterByModifyColumnContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) MODIFY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODIFY, 0)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) ColumnDefinition() IColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) AFTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAFTER, 0)
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByModifyColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByModifyColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByModifyColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByModifyColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByTableOptionContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByTableOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByTableOptionContext {
|
|
var p = new(AlterByTableOptionContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) AllTableOption() []ITableOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableOptionContext); ok {
|
|
tst[i] = t.(ITableOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) TableOption(i int) ITableOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableOptionContext)
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByTableOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropPrimaryKeyContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDropPrimaryKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropPrimaryKeyContext {
|
|
var p = new(AlterByDropPrimaryKeyContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) PRIMARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIMARY, 0)
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropPrimaryKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropPrimaryKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropPrimaryKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropPrimaryKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByLockContext struct {
|
|
AlterSpecificationContext
|
|
lockType antlr.Token
|
|
}
|
|
|
|
func NewAlterByLockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByLockContext {
|
|
var p = new(AlterByLockContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByLockContext) GetLockType() antlr.Token { return s.lockType }
|
|
|
|
func (s *AlterByLockContext) SetLockType(v antlr.Token) { s.lockType = v }
|
|
|
|
func (s *AlterByLockContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByLockContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) SHARED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARED, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) EXCLUSIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLUSIVE, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *AlterByLockContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByLock(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByLockContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByLock(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByLockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByLock(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDiscardTablespaceContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDiscardTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDiscardTablespaceContext {
|
|
var p = new(AlterByDiscardTablespaceContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) DISCARD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISCARD, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDiscardTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDiscardTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDiscardTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDiscardTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByValidateContext struct {
|
|
AlterSpecificationContext
|
|
validationFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByValidateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByValidateContext {
|
|
var p = new(AlterByValidateContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByValidateContext) GetValidationFormat() antlr.Token { return s.validationFormat }
|
|
|
|
func (s *AlterByValidateContext) SetValidationFormat(v antlr.Token) { s.validationFormat = v }
|
|
|
|
func (s *AlterByValidateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByValidateContext) VALIDATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALIDATION, 0)
|
|
}
|
|
|
|
func (s *AlterByValidateContext) WITHOUT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITHOUT, 0)
|
|
}
|
|
|
|
func (s *AlterByValidateContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *AlterByValidateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByValidate(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByValidateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByValidate(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByValidateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByValidate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddPrimaryKeyContext struct {
|
|
AlterSpecificationContext
|
|
name IUidContext
|
|
index IUidContext
|
|
}
|
|
|
|
func NewAlterByAddPrimaryKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddPrimaryKeyContext {
|
|
var p = new(AlterByAddPrimaryKeyContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) GetIndex() IUidContext { return s.index }
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) SetIndex(v IUidContext) { s.index = v }
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) PRIMARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIMARY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddPrimaryKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddPrimaryKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddPrimaryKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddPrimaryKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByEnableKeysContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByEnableKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByEnableKeysContext {
|
|
var p = new(AlterByEnableKeysContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) ENABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENABLE, 0)
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEYS, 0)
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByEnableKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByEnableKeys(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByEnableKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByEnableKeys(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterBySetAlgorithmContext struct {
|
|
AlterSpecificationContext
|
|
algType antlr.Token
|
|
}
|
|
|
|
func NewAlterBySetAlgorithmContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterBySetAlgorithmContext {
|
|
var p = new(AlterBySetAlgorithmContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *AlterBySetAlgorithmContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *AlterBySetAlgorithmContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) INSTANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTANT, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) INPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINPLACE, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) COPY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOPY, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterBySetAlgorithm(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterBySetAlgorithm(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterBySetAlgorithmContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterBySetAlgorithm(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByChangeColumnContext struct {
|
|
AlterSpecificationContext
|
|
oldColumn IUidContext
|
|
newColumn IUidContext
|
|
afterColumn IUidContext
|
|
}
|
|
|
|
func NewAlterByChangeColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByChangeColumnContext {
|
|
var p = new(AlterByChangeColumnContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) GetOldColumn() IUidContext { return s.oldColumn }
|
|
|
|
func (s *AlterByChangeColumnContext) GetNewColumn() IUidContext { return s.newColumn }
|
|
|
|
func (s *AlterByChangeColumnContext) GetAfterColumn() IUidContext { return s.afterColumn }
|
|
|
|
func (s *AlterByChangeColumnContext) SetOldColumn(v IUidContext) { s.oldColumn = v }
|
|
|
|
func (s *AlterByChangeColumnContext) SetNewColumn(v IUidContext) { s.newColumn = v }
|
|
|
|
func (s *AlterByChangeColumnContext) SetAfterColumn(v IUidContext) { s.afterColumn = v }
|
|
|
|
func (s *AlterByChangeColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) CHANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANGE, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) ColumnDefinition() IColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) AFTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAFTER, 0)
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByChangeColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByChangeColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByChangeColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByChangeColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddUniqueKeyContext struct {
|
|
AlterSpecificationContext
|
|
name IUidContext
|
|
indexFormat antlr.Token
|
|
indexName IUidContext
|
|
}
|
|
|
|
func NewAlterByAddUniqueKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddUniqueKeyContext {
|
|
var p = new(AlterByAddUniqueKeyContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) GetName() IUidContext { return s.name }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) GetIndexName() IUidContext { return s.indexName }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) SetName(v IUidContext) { s.name = v }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) SetIndexName(v IUidContext) { s.indexName = v }
|
|
|
|
func (s *AlterByAddUniqueKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) UNIQUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNIQUE, 0)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) IndexColumnNames() IIndexColumnNamesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNamesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNamesContext)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) CONSTRAINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT, 0)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) IndexType() IIndexTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexTypeContext)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) AllIndexOption() []IIndexOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexOptionContext); ok {
|
|
tst[i] = t.(IIndexOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) IndexOption(i int) IIndexOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexOptionContext)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddUniqueKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddUniqueKey(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddUniqueKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddUniqueKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropIndexContext struct {
|
|
AlterSpecificationContext
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByDropIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropIndexContext {
|
|
var p = new(AlterByDropIndexContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *AlterByDropIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *AlterByDropIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddColumnContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAddColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddColumnContext {
|
|
var p = new(AlterByAddColumnContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) ColumnDefinition() IColumnDefinitionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IColumnDefinitionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IColumnDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) COLUMN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) AFTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAFTER, 0)
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByOrderContext struct {
|
|
AlterSpecificationContext
|
|
}
|
|
|
|
func NewAlterByOrderContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByOrderContext {
|
|
var p = new(AlterByOrderContext)
|
|
|
|
InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByOrderContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByOrderContext) ORDER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDER, 0)
|
|
}
|
|
|
|
func (s *AlterByOrderContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *AlterByOrderContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByOrderContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByOrder(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByOrderContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByOrder(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByOrderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByOrder(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterSpecification() (localctx IAlterSpecificationContext) {
|
|
localctx = NewAlterSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 148, MySqlParserRULE_alterSpecification)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(2883)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 370, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewAlterByTableOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2532)
|
|
p.TableOption()
|
|
}
|
|
p.SetState(2539)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(2534)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2533)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2536)
|
|
p.TableOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(2541)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewAlterByAddColumnContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2542)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2544)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2543)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2546)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2547)
|
|
p.ColumnDefinition()
|
|
}
|
|
p.SetState(2551)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFIRST:
|
|
{
|
|
p.SetState(2548)
|
|
p.Match(MySqlParserFIRST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserAFTER:
|
|
{
|
|
p.SetState(2549)
|
|
p.Match(MySqlParserAFTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2550)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewAlterByAddColumnsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2553)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2555)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2554)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2557)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2558)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2559)
|
|
p.ColumnDefinition()
|
|
}
|
|
p.SetState(2566)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2560)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2561)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2562)
|
|
p.ColumnDefinition()
|
|
}
|
|
|
|
p.SetState(2568)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2569)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewAlterByAddIndexContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(2571)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2572)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByAddIndexContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByAddIndexContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(2574)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2573)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(2577)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(2576)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2579)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(2583)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(2580)
|
|
p.IndexOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(2585)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewAlterByAddPrimaryKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(2586)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2591)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2587)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2589)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 320, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2588)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddPrimaryKeyContext).name = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2593)
|
|
p.Match(MySqlParserPRIMARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2594)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2596)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2595)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddPrimaryKeyContext).index = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(2599)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(2598)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2601)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(2605)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(2602)
|
|
p.IndexOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(2607)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewAlterByAddUniqueKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(2608)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2613)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2609)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2611)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2610)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddUniqueKeyContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2615)
|
|
p.Match(MySqlParserUNIQUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2617)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(2616)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByAddUniqueKeyContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByAddUniqueKeyContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2620)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2619)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddUniqueKeyContext).indexName = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(2623)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(2622)
|
|
p.IndexType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2625)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(2629)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(2626)
|
|
p.IndexOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(2631)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewAlterByAddSpecialIndexContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(2632)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2633)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByAddSpecialIndexContext).keyType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByAddSpecialIndexContext).keyType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(2635)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(2634)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByAddSpecialIndexContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByAddSpecialIndexContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2638)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2637)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2640)
|
|
p.IndexColumnNames()
|
|
}
|
|
p.SetState(2644)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(2641)
|
|
p.IndexOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(2646)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewAlterByAddForeignKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(2647)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2652)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2648)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2650)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2649)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddForeignKeyContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2654)
|
|
p.Match(MySqlParserFOREIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2655)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2657)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2656)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddForeignKeyContext).indexName = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2659)
|
|
p.IndexColumnNames()
|
|
}
|
|
{
|
|
p.SetState(2660)
|
|
p.ReferenceDefinition()
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewAlterByAddCheckTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(2662)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2667)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2663)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2665)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2664)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddCheckTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2669)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2676)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 339, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(2670)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(2671)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(2672)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2673)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2674)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(2679)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(2678)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2682)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENFORCED {
|
|
{
|
|
p.SetState(2681)
|
|
p.Match(MySqlParserENFORCED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewAlterByAlterCheckTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(2684)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2689)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2685)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2687)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2686)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAlterCheckTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2691)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2698)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(2692)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(2693)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(2694)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2695)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2696)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(2701)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(2700)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2704)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENFORCED {
|
|
{
|
|
p.SetState(2703)
|
|
p.Match(MySqlParserENFORCED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewAlterByAddCheckTableConstraintContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(2706)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2711)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONSTRAINT {
|
|
{
|
|
p.SetState(2707)
|
|
p.Match(MySqlParserCONSTRAINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2709)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(2708)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByAddCheckTableConstraintContext).name = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2713)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2714)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2715)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2716)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewAlterBySetAlgorithmContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(2718)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2720)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2719)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2722)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterBySetAlgorithmContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE || _la == MySqlParserINSTANT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterBySetAlgorithmContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewAlterByChangeDefaultContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(2723)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2725)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2724)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2727)
|
|
p.Uid()
|
|
}
|
|
p.SetState(2733)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSET:
|
|
{
|
|
p.SetState(2728)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2729)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2730)
|
|
p.DefaultValue()
|
|
}
|
|
|
|
case MySqlParserDROP:
|
|
{
|
|
p.SetState(2731)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2732)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewAlterByChangeColumnContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(2735)
|
|
p.Match(MySqlParserCHANGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2737)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2736)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2739)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByChangeColumnContext).oldColumn = _x
|
|
}
|
|
{
|
|
p.SetState(2740)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByChangeColumnContext).newColumn = _x
|
|
}
|
|
{
|
|
p.SetState(2741)
|
|
p.ColumnDefinition()
|
|
}
|
|
p.SetState(2745)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFIRST:
|
|
{
|
|
p.SetState(2742)
|
|
p.Match(MySqlParserFIRST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserAFTER:
|
|
{
|
|
p.SetState(2743)
|
|
p.Match(MySqlParserAFTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2744)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByChangeColumnContext).afterColumn = _x
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewAlterByRenameColumnContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(2747)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2748)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2749)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByRenameColumnContext).oldColumn = _x
|
|
}
|
|
{
|
|
p.SetState(2750)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2751)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AlterByRenameColumnContext).newColumn = _x
|
|
}
|
|
|
|
case 16:
|
|
localctx = NewAlterByLockContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(2753)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2755)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(2754)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2757)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByLockContext).lockType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByLockContext).lockType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 17:
|
|
localctx = NewAlterByModifyColumnContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(2758)
|
|
p.Match(MySqlParserMODIFY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2760)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2759)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2762)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2763)
|
|
p.ColumnDefinition()
|
|
}
|
|
p.SetState(2767)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFIRST:
|
|
{
|
|
p.SetState(2764)
|
|
p.Match(MySqlParserFIRST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserAFTER:
|
|
{
|
|
p.SetState(2765)
|
|
p.Match(MySqlParserAFTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2766)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case 18:
|
|
localctx = NewAlterByDropColumnContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(2769)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2771)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2770)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2773)
|
|
p.Uid()
|
|
}
|
|
p.SetState(2775)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserRESTRICT {
|
|
{
|
|
p.SetState(2774)
|
|
p.Match(MySqlParserRESTRICT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 19:
|
|
localctx = NewAlterByDropConstraintCheckContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(2777)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2778)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHECK || _la == MySqlParserCONSTRAINT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2779)
|
|
p.Uid()
|
|
}
|
|
|
|
case 20:
|
|
localctx = NewAlterByDropPrimaryKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(2780)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2781)
|
|
p.Match(MySqlParserPRIMARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2782)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 21:
|
|
localctx = NewAlterByDropIndexContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(2783)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2784)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByDropIndexContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByDropIndexContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2785)
|
|
p.Uid()
|
|
}
|
|
|
|
case 22:
|
|
localctx = NewAlterByRenameIndexContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(2786)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2787)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByRenameIndexContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByRenameIndexContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2788)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2789)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2790)
|
|
p.Uid()
|
|
}
|
|
|
|
case 23:
|
|
localctx = NewAlterByAlterColumnDefaultContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(2792)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2794)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2793)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2796)
|
|
p.Uid()
|
|
}
|
|
p.SetState(2810)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(2797)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2798)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2804)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTART_NATIONAL_STRING_LITERAL, MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
|
|
{
|
|
p.SetState(2799)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(2800)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2801)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(2802)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(2806)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2807)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(2808)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2809)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
case 24:
|
|
localctx = NewAlterByAlterIndexVisibilityContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(2812)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2813)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2814)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2815)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 25:
|
|
localctx = NewAlterByDropForeignKeyContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 25)
|
|
{
|
|
p.SetState(2817)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2818)
|
|
p.Match(MySqlParserFOREIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2819)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2820)
|
|
p.Uid()
|
|
}
|
|
|
|
case 26:
|
|
localctx = NewAlterByDisableKeysContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 26)
|
|
{
|
|
p.SetState(2821)
|
|
p.Match(MySqlParserDISABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2822)
|
|
p.Match(MySqlParserKEYS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 27:
|
|
localctx = NewAlterByEnableKeysContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 27)
|
|
{
|
|
p.SetState(2823)
|
|
p.Match(MySqlParserENABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2824)
|
|
p.Match(MySqlParserKEYS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 28:
|
|
localctx = NewAlterByRenameContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 28)
|
|
{
|
|
p.SetState(2825)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2827)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS || _la == MySqlParserTO {
|
|
{
|
|
p.SetState(2826)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByRenameContext).renameFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserAS || _la == MySqlParserTO) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByRenameContext).renameFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(2831)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 363, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(2829)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(2830)
|
|
p.FullId()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
case 29:
|
|
localctx = NewAlterByOrderContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 29)
|
|
{
|
|
p.SetState(2833)
|
|
p.Match(MySqlParserORDER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2834)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2835)
|
|
p.UidList()
|
|
}
|
|
|
|
case 30:
|
|
localctx = NewAlterByConvertCharsetContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 30)
|
|
{
|
|
p.SetState(2836)
|
|
p.Match(MySqlParserCONVERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2837)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2841)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCHARSET:
|
|
{
|
|
p.SetState(2838)
|
|
p.Match(MySqlParserCHARSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHARACTER:
|
|
{
|
|
p.SetState(2839)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2840)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(2843)
|
|
p.CharsetName()
|
|
}
|
|
p.SetState(2846)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLLATE {
|
|
{
|
|
p.SetState(2844)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2845)
|
|
p.CollationName()
|
|
}
|
|
|
|
}
|
|
|
|
case 31:
|
|
localctx = NewAlterByDefaultCharsetContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 31)
|
|
p.SetState(2849)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(2848)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2851)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2852)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2853)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2854)
|
|
p.CharsetName()
|
|
}
|
|
p.SetState(2858)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLLATE {
|
|
{
|
|
p.SetState(2855)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2856)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2857)
|
|
p.CollationName()
|
|
}
|
|
|
|
}
|
|
|
|
case 32:
|
|
localctx = NewAlterByDiscardTablespaceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 32)
|
|
{
|
|
p.SetState(2860)
|
|
p.Match(MySqlParserDISCARD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2861)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 33:
|
|
localctx = NewAlterByImportTablespaceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 33)
|
|
{
|
|
p.SetState(2862)
|
|
p.Match(MySqlParserIMPORT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2863)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 34:
|
|
localctx = NewAlterByForceContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 34)
|
|
{
|
|
p.SetState(2864)
|
|
p.Match(MySqlParserFORCE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 35:
|
|
localctx = NewAlterByValidateContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 35)
|
|
{
|
|
p.SetState(2865)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByValidateContext).validationFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserWITH || _la == MySqlParserWITHOUT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByValidateContext).validationFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2866)
|
|
p.Match(MySqlParserVALIDATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 36:
|
|
localctx = NewAlterByAddDefinitionsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 36)
|
|
{
|
|
p.SetState(2867)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2869)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMN {
|
|
{
|
|
p.SetState(2868)
|
|
p.Match(MySqlParserCOLUMN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(2871)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2872)
|
|
p.CreateDefinition()
|
|
}
|
|
p.SetState(2877)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2873)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2874)
|
|
p.CreateDefinition()
|
|
}
|
|
|
|
p.SetState(2879)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2880)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 37:
|
|
localctx = NewAlterPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 37)
|
|
{
|
|
p.SetState(2882)
|
|
p.AlterPartitionSpecification()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterPartitionSpecificationContext is an interface to support dynamic dispatch.
|
|
type IAlterPartitionSpecificationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsAlterPartitionSpecificationContext differentiates from other interfaces.
|
|
IsAlterPartitionSpecificationContext()
|
|
}
|
|
|
|
type AlterPartitionSpecificationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterPartitionSpecificationContext() *AlterPartitionSpecificationContext {
|
|
var p = new(AlterPartitionSpecificationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterPartitionSpecification
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterPartitionSpecificationContext(p *AlterPartitionSpecificationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterPartitionSpecification
|
|
}
|
|
|
|
func (*AlterPartitionSpecificationContext) IsAlterPartitionSpecificationContext() {}
|
|
|
|
func NewAlterPartitionSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterPartitionSpecificationContext {
|
|
var p = new(AlterPartitionSpecificationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterPartitionSpecification
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterPartitionSpecificationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterPartitionSpecificationContext) CopyAll(ctx *AlterPartitionSpecificationContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *AlterPartitionSpecificationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterPartitionSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type AlterByImportPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByImportPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByImportPartitionContext {
|
|
var p = new(AlterByImportPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) IMPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIMPORT, 0)
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByImportPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByImportPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByImportPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByImportPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDropPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDropPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropPartitionContext {
|
|
var p = new(AlterByDropPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDropPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDropPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDropPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDropPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByDiscardPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByDiscardPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDiscardPartitionContext {
|
|
var p = new(AlterByDiscardPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) DISCARD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISCARD, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByDiscardPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByDiscardPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByDiscardPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByDiscardPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAddPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAddPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddPartitionContext {
|
|
var p = new(AlterByAddPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADD, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) AllPartitionDefinition() []IPartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
tst[i] = t.(IPartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) PartitionDefinition(i int) IPartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAddPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAddPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAddPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAddPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRemovePartitioningContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByRemovePartitioningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRemovePartitioningContext {
|
|
var p = new(AlterByRemovePartitioningContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) REMOVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREMOVE, 0)
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) PARTITIONING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONING, 0)
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRemovePartitioning(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRemovePartitioning(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRemovePartitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRemovePartitioning(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByOptimizePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByOptimizePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByOptimizePartitionContext {
|
|
var p = new(AlterByOptimizePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) OPTIMIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIMIZE, 0)
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByOptimizePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByOptimizePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByOptimizePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByOptimizePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByCheckPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByCheckPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByCheckPartitionContext {
|
|
var p = new(AlterByCheckPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByCheckPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByCheckPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByCheckPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByCheckPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByCoalescePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByCoalescePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByCoalescePartitionContext {
|
|
var p = new(AlterByCoalescePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) COALESCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOALESCE, 0)
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByCoalescePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByCoalescePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByCoalescePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByCoalescePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByReorganizePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByReorganizePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByReorganizePartitionContext {
|
|
var p = new(AlterByReorganizePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) REORGANIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREORGANIZE, 0)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) AllPartitionDefinition() []IPartitionDefinitionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPartitionDefinitionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
tst[i] = t.(IPartitionDefinitionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) PartitionDefinition(i int) IPartitionDefinitionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionDefinitionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionDefinitionContext)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByReorganizePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByReorganizePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByReorganizePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByReorganizePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByAnalyzePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByAnalyzePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAnalyzePartitionContext {
|
|
var p = new(AlterByAnalyzePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) ANALYZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserANALYZE, 0)
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByAnalyzePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByAnalyzePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByAnalyzePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByAnalyzePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRebuildPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByRebuildPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRebuildPartitionContext {
|
|
var p = new(AlterByRebuildPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) REBUILD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREBUILD, 0)
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRebuildPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRebuildPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRebuildPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRebuildPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByUpgradePartitioningContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByUpgradePartitioningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByUpgradePartitioningContext {
|
|
var p = new(AlterByUpgradePartitioningContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) UPGRADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPGRADE, 0)
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) PARTITIONING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONING, 0)
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByUpgradePartitioning(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByUpgradePartitioning(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByUpgradePartitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByUpgradePartitioning(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByTruncatePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByTruncatePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByTruncatePartitionContext {
|
|
var p = new(AlterByTruncatePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) TRUNCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRUNCATE, 0)
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByTruncatePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByTruncatePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByTruncatePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByTruncatePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByRepairPartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
}
|
|
|
|
func NewAlterByRepairPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRepairPartitionContext {
|
|
var p = new(AlterByRepairPartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) REPAIR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPAIR, 0)
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByRepairPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByRepairPartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByRepairPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByRepairPartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterByExchangePartitionContext struct {
|
|
AlterPartitionSpecificationContext
|
|
validationFormat antlr.Token
|
|
}
|
|
|
|
func NewAlterByExchangePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByExchangePartitionContext {
|
|
var p = new(AlterByExchangePartitionContext)
|
|
|
|
InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterPartitionSpecificationContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) GetValidationFormat() antlr.Token {
|
|
return s.validationFormat
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) SetValidationFormat(v antlr.Token) { s.validationFormat = v }
|
|
|
|
func (s *AlterByExchangePartitionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) EXCHANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCHANGE, 0)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) AllWITH() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserWITH)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) WITH(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, i)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) VALIDATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALIDATION, 0)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) WITHOUT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITHOUT, 0)
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterByExchangePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterByExchangePartition(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterByExchangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterByExchangePartition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterPartitionSpecification() (localctx IAlterPartitionSpecificationContext) {
|
|
localctx = NewAlterPartitionSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 150, MySqlParserRULE_alterPartitionSpecification)
|
|
var _la int
|
|
|
|
p.SetState(2983)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserADD:
|
|
localctx = NewAlterByAddPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2885)
|
|
p.Match(MySqlParserADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2886)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2887)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2888)
|
|
p.PartitionDefinition()
|
|
}
|
|
p.SetState(2893)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2889)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2890)
|
|
p.PartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2895)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2896)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDROP:
|
|
localctx = NewAlterByDropPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(2898)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2899)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2900)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserDISCARD:
|
|
localctx = NewAlterByDiscardPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(2901)
|
|
p.Match(MySqlParserDISCARD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2902)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2905)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2903)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2904)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(2907)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserIMPORT:
|
|
localctx = NewAlterByImportPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(2908)
|
|
p.Match(MySqlParserIMPORT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2909)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2912)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2910)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2911)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(2914)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTRUNCATE:
|
|
localctx = NewAlterByTruncatePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(2915)
|
|
p.Match(MySqlParserTRUNCATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2916)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2919)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2917)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2918)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserCOALESCE:
|
|
localctx = NewAlterByCoalescePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(2921)
|
|
p.Match(MySqlParserCOALESCE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2922)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2923)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserREORGANIZE:
|
|
localctx = NewAlterByReorganizePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(2924)
|
|
p.Match(MySqlParserREORGANIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2925)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2926)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(2927)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2928)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2929)
|
|
p.PartitionDefinition()
|
|
}
|
|
p.SetState(2934)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(2930)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2931)
|
|
p.PartitionDefinition()
|
|
}
|
|
|
|
p.SetState(2936)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(2937)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEXCHANGE:
|
|
localctx = NewAlterByExchangePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(2939)
|
|
p.Match(MySqlParserEXCHANGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2940)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2941)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(2942)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2943)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2944)
|
|
p.TableName()
|
|
}
|
|
p.SetState(2947)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 376, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2945)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AlterByExchangePartitionContext).validationFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserWITH || _la == MySqlParserWITHOUT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AlterByExchangePartitionContext).validationFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2946)
|
|
p.Match(MySqlParserVALIDATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserANALYZE:
|
|
localctx = NewAlterByAnalyzePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(2949)
|
|
p.Match(MySqlParserANALYZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2950)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2953)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2951)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2952)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserCHECK:
|
|
localctx = NewAlterByCheckPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(2955)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2956)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2959)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2957)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2958)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserOPTIMIZE:
|
|
localctx = NewAlterByOptimizePartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(2961)
|
|
p.Match(MySqlParserOPTIMIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2962)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2965)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2963)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2964)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserREBUILD:
|
|
localctx = NewAlterByRebuildPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(2967)
|
|
p.Match(MySqlParserREBUILD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2968)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2971)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2969)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2970)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserREPAIR:
|
|
localctx = NewAlterByRepairPartitionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(2973)
|
|
p.Match(MySqlParserREPAIR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2974)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2977)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(2975)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(2976)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserREMOVE:
|
|
localctx = NewAlterByRemovePartitioningContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(2979)
|
|
p.Match(MySqlParserREMOVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2980)
|
|
p.Match(MySqlParserPARTITIONING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUPGRADE:
|
|
localctx = NewAlterByUpgradePartitioningContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(2981)
|
|
p.Match(MySqlParserUPGRADE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2982)
|
|
p.Match(MySqlParserPARTITIONING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropDatabaseContext is an interface to support dynamic dispatch.
|
|
type IDropDatabaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDbFormat returns the dbFormat token.
|
|
GetDbFormat() antlr.Token
|
|
|
|
// SetDbFormat sets the dbFormat token.
|
|
SetDbFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
DATABASE() antlr.TerminalNode
|
|
SCHEMA() antlr.TerminalNode
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropDatabaseContext differentiates from other interfaces.
|
|
IsDropDatabaseContext()
|
|
}
|
|
|
|
type DropDatabaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
dbFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyDropDatabaseContext() *DropDatabaseContext {
|
|
var p = new(DropDatabaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropDatabase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropDatabaseContext(p *DropDatabaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropDatabase
|
|
}
|
|
|
|
func (*DropDatabaseContext) IsDropDatabaseContext() {}
|
|
|
|
func NewDropDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropDatabaseContext {
|
|
var p = new(DropDatabaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropDatabase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropDatabaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat }
|
|
|
|
func (s *DropDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v }
|
|
|
|
func (s *DropDatabaseContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropDatabaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropDatabaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropDatabase(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropDatabase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropDatabase() (localctx IDropDatabaseContext) {
|
|
localctx = NewDropDatabaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 152, MySqlParserRULE_dropDatabase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2985)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2986)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropDatabaseContext).dbFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropDatabaseContext).dbFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(2988)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2987)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(2990)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropEventContext is an interface to support dynamic dispatch.
|
|
type IDropEventContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
EVENT() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropEventContext differentiates from other interfaces.
|
|
IsDropEventContext()
|
|
}
|
|
|
|
type DropEventContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropEventContext() *DropEventContext {
|
|
var p = new(DropEventContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropEvent
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropEventContext(p *DropEventContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropEvent
|
|
}
|
|
|
|
func (*DropEventContext) IsDropEventContext() {}
|
|
|
|
func NewDropEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropEventContext {
|
|
var p = new(DropEventContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropEvent
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropEventContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropEventContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropEventContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *DropEventContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DropEventContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropEventContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropEventContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropEventContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropEvent(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropEvent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropEvent() (localctx IDropEventContext) {
|
|
localctx = NewDropEventContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 154, MySqlParserRULE_dropEvent)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2992)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(2993)
|
|
p.Match(MySqlParserEVENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(2995)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 384, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(2994)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(2997)
|
|
p.FullId()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropIndexContext is an interface to support dynamic dispatch.
|
|
type IDropIndexContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIntimeAction returns the intimeAction token.
|
|
GetIntimeAction() antlr.Token
|
|
|
|
// GetAlgType returns the algType token.
|
|
GetAlgType() antlr.Token
|
|
|
|
// GetLockType returns the lockType token.
|
|
GetLockType() antlr.Token
|
|
|
|
// SetIntimeAction sets the intimeAction token.
|
|
SetIntimeAction(antlr.Token)
|
|
|
|
// SetAlgType sets the algType token.
|
|
SetAlgType(antlr.Token)
|
|
|
|
// SetLockType sets the lockType token.
|
|
SetLockType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ON() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
AllALGORITHM() []antlr.TerminalNode
|
|
ALGORITHM(i int) antlr.TerminalNode
|
|
AllLOCK() []antlr.TerminalNode
|
|
LOCK(i int) antlr.TerminalNode
|
|
ONLINE() antlr.TerminalNode
|
|
OFFLINE() antlr.TerminalNode
|
|
AllDEFAULT() []antlr.TerminalNode
|
|
DEFAULT(i int) antlr.TerminalNode
|
|
AllINPLACE() []antlr.TerminalNode
|
|
INPLACE(i int) antlr.TerminalNode
|
|
AllCOPY() []antlr.TerminalNode
|
|
COPY(i int) antlr.TerminalNode
|
|
AllNONE() []antlr.TerminalNode
|
|
NONE(i int) antlr.TerminalNode
|
|
AllSHARED() []antlr.TerminalNode
|
|
SHARED(i int) antlr.TerminalNode
|
|
AllEXCLUSIVE() []antlr.TerminalNode
|
|
EXCLUSIVE(i int) antlr.TerminalNode
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
|
|
// IsDropIndexContext differentiates from other interfaces.
|
|
IsDropIndexContext()
|
|
}
|
|
|
|
type DropIndexContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
intimeAction antlr.Token
|
|
algType antlr.Token
|
|
lockType antlr.Token
|
|
}
|
|
|
|
func NewEmptyDropIndexContext() *DropIndexContext {
|
|
var p = new(DropIndexContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropIndex
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropIndexContext(p *DropIndexContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropIndex
|
|
}
|
|
|
|
func (*DropIndexContext) IsDropIndexContext() {}
|
|
|
|
func NewDropIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropIndexContext {
|
|
var p = new(DropIndexContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropIndex
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropIndexContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropIndexContext) GetIntimeAction() antlr.Token { return s.intimeAction }
|
|
|
|
func (s *DropIndexContext) GetAlgType() antlr.Token { return s.algType }
|
|
|
|
func (s *DropIndexContext) GetLockType() antlr.Token { return s.lockType }
|
|
|
|
func (s *DropIndexContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v }
|
|
|
|
func (s *DropIndexContext) SetAlgType(v antlr.Token) { s.algType = v }
|
|
|
|
func (s *DropIndexContext) SetLockType(v antlr.Token) { s.lockType = v }
|
|
|
|
func (s *DropIndexContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropIndexContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *DropIndexContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DropIndexContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *DropIndexContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllALGORITHM() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserALGORITHM)
|
|
}
|
|
|
|
func (s *DropIndexContext) ALGORITHM(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllLOCK() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLOCK)
|
|
}
|
|
|
|
func (s *DropIndexContext) LOCK(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) ONLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLINE, 0)
|
|
}
|
|
|
|
func (s *DropIndexContext) OFFLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFLINE, 0)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllDEFAULT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserDEFAULT)
|
|
}
|
|
|
|
func (s *DropIndexContext) DEFAULT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllINPLACE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserINPLACE)
|
|
}
|
|
|
|
func (s *DropIndexContext) INPLACE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINPLACE, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllCOPY() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOPY)
|
|
}
|
|
|
|
func (s *DropIndexContext) COPY(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOPY, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllNONE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserNONE)
|
|
}
|
|
|
|
func (s *DropIndexContext) NONE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllSHARED() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSHARED)
|
|
}
|
|
|
|
func (s *DropIndexContext) SHARED(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARED, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllEXCLUSIVE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEXCLUSIVE)
|
|
}
|
|
|
|
func (s *DropIndexContext) EXCLUSIVE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLUSIVE, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *DropIndexContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *DropIndexContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropIndexContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropIndexContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropIndex(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropIndex(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropIndex() (localctx IDropIndexContext) {
|
|
localctx = NewDropIndexContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 156, MySqlParserRULE_dropIndex)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(2999)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3000)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3002)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 385, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3001)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropIndexContext).intimeAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropIndexContext).intimeAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3004)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(3005)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3006)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3019)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 389, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(3017)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALGORITHM:
|
|
{
|
|
p.SetState(3007)
|
|
p.Match(MySqlParserALGORITHM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3009)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(3008)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3011)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropIndexContext).algType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropIndexContext).algType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCK:
|
|
{
|
|
p.SetState(3012)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3014)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(3013)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3016)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropIndexContext).lockType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropIndexContext).lockType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(3021)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 389, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropLogfileGroupContext is an interface to support dynamic dispatch.
|
|
type IDropLogfileGroupContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
LOGFILE() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ENGINE() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
|
|
// IsDropLogfileGroupContext differentiates from other interfaces.
|
|
IsDropLogfileGroupContext()
|
|
}
|
|
|
|
type DropLogfileGroupContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropLogfileGroupContext() *DropLogfileGroupContext {
|
|
var p = new(DropLogfileGroupContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropLogfileGroup
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropLogfileGroupContext(p *DropLogfileGroupContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropLogfileGroup
|
|
}
|
|
|
|
func (*DropLogfileGroupContext) IsDropLogfileGroupContext() {}
|
|
|
|
func NewDropLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropLogfileGroupContext {
|
|
var p = new(DropLogfileGroupContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropLogfileGroup
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropLogfileGroupContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) LOGFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGFILE, 0)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropLogfileGroup(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropLogfileGroup(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropLogfileGroup() (localctx IDropLogfileGroupContext) {
|
|
localctx = NewDropLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 158, MySqlParserRULE_dropLogfileGroup)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3022)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3023)
|
|
p.Match(MySqlParserLOGFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3024)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3025)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(3026)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3027)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3028)
|
|
p.EngineName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropProcedureContext is an interface to support dynamic dispatch.
|
|
type IDropProcedureContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
PROCEDURE() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropProcedureContext differentiates from other interfaces.
|
|
IsDropProcedureContext()
|
|
}
|
|
|
|
type DropProcedureContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropProcedureContext() *DropProcedureContext {
|
|
var p = new(DropProcedureContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropProcedure
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropProcedureContext(p *DropProcedureContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropProcedure
|
|
}
|
|
|
|
func (*DropProcedureContext) IsDropProcedureContext() {}
|
|
|
|
func NewDropProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropProcedureContext {
|
|
var p = new(DropProcedureContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropProcedure
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropProcedureContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropProcedureContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropProcedureContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *DropProcedureContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DropProcedureContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropProcedureContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropProcedureContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropProcedureContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropProcedure(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropProcedure(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropProcedure() (localctx IDropProcedureContext) {
|
|
localctx = NewDropProcedureContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 160, MySqlParserRULE_dropProcedure)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3030)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3031)
|
|
p.Match(MySqlParserPROCEDURE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3033)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 390, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3032)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3035)
|
|
p.FullId()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropFunctionContext is an interface to support dynamic dispatch.
|
|
type IDropFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropFunctionContext differentiates from other interfaces.
|
|
IsDropFunctionContext()
|
|
}
|
|
|
|
type DropFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropFunctionContext() *DropFunctionContext {
|
|
var p = new(DropFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropFunctionContext(p *DropFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropFunction
|
|
}
|
|
|
|
func (*DropFunctionContext) IsDropFunctionContext() {}
|
|
|
|
func NewDropFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropFunctionContext {
|
|
var p = new(DropFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropFunctionContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropFunctionContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *DropFunctionContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DropFunctionContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropFunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropFunction() (localctx IDropFunctionContext) {
|
|
localctx = NewDropFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 162, MySqlParserRULE_dropFunction)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3037)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3038)
|
|
p.Match(MySqlParserFUNCTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3040)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 391, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3039)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3042)
|
|
p.FullId()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropServerContext is an interface to support dynamic dispatch.
|
|
type IDropServerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
SERVER() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropServerContext differentiates from other interfaces.
|
|
IsDropServerContext()
|
|
}
|
|
|
|
type DropServerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropServerContext() *DropServerContext {
|
|
var p = new(DropServerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropServer
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropServerContext(p *DropServerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropServer
|
|
}
|
|
|
|
func (*DropServerContext) IsDropServerContext() {}
|
|
|
|
func NewDropServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropServerContext {
|
|
var p = new(DropServerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropServer
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropServerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropServerContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropServerContext) SERVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERVER, 0)
|
|
}
|
|
|
|
func (s *DropServerContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DropServerContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropServerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropServerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropServerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropServer(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropServer(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropServer() (localctx IDropServerContext) {
|
|
localctx = NewDropServerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 164, MySqlParserRULE_dropServer)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3044)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3045)
|
|
p.Match(MySqlParserSERVER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3047)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3046)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3049)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropTableContext is an interface to support dynamic dispatch.
|
|
type IDropTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDropType returns the dropType token.
|
|
GetDropType() antlr.Token
|
|
|
|
// SetDropType sets the dropType token.
|
|
SetDropType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
TEMPORARY() antlr.TerminalNode
|
|
IfExists() IIfExistsContext
|
|
RESTRICT() antlr.TerminalNode
|
|
CASCADE() antlr.TerminalNode
|
|
|
|
// IsDropTableContext differentiates from other interfaces.
|
|
IsDropTableContext()
|
|
}
|
|
|
|
type DropTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
dropType antlr.Token
|
|
}
|
|
|
|
func NewEmptyDropTableContext() *DropTableContext {
|
|
var p = new(DropTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropTableContext(p *DropTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTable
|
|
}
|
|
|
|
func (*DropTableContext) IsDropTableContext() {}
|
|
|
|
func NewDropTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTableContext {
|
|
var p = new(DropTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropTableContext) GetDropType() antlr.Token { return s.dropType }
|
|
|
|
func (s *DropTableContext) SetDropType(v antlr.Token) { s.dropType = v }
|
|
|
|
func (s *DropTableContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *DropTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *DropTableContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *DropTableContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropTableContext) RESTRICT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESTRICT, 0)
|
|
}
|
|
|
|
func (s *DropTableContext) CASCADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADE, 0)
|
|
}
|
|
|
|
func (s *DropTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropTable() (localctx IDropTableContext) {
|
|
localctx = NewDropTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 166, MySqlParserRULE_dropTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3051)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3053)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserTEMPORARY {
|
|
{
|
|
p.SetState(3052)
|
|
p.Match(MySqlParserTEMPORARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3055)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3057)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3056)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3059)
|
|
p.Tables()
|
|
}
|
|
p.SetState(3061)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCASCADE || _la == MySqlParserRESTRICT {
|
|
{
|
|
p.SetState(3060)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropTableContext).dropType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCASCADE || _la == MySqlParserRESTRICT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropTableContext).dropType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropTablespaceContext is an interface to support dynamic dispatch.
|
|
type IDropTablespaceContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ENGINE() antlr.TerminalNode
|
|
EngineName() IEngineNameContext
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
|
|
// IsDropTablespaceContext differentiates from other interfaces.
|
|
IsDropTablespaceContext()
|
|
}
|
|
|
|
type DropTablespaceContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropTablespaceContext() *DropTablespaceContext {
|
|
var p = new(DropTablespaceContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTablespace
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropTablespaceContext(p *DropTablespaceContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTablespace
|
|
}
|
|
|
|
func (*DropTablespaceContext) IsDropTablespaceContext() {}
|
|
|
|
func NewDropTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTablespaceContext {
|
|
var p = new(DropTablespaceContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropTablespace
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropTablespaceContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropTablespaceContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropTablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropTablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropTablespace(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropTablespace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropTablespace() (localctx IDropTablespaceContext) {
|
|
localctx = NewDropTablespaceContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 168, MySqlParserRULE_dropTablespace)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3063)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3064)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3065)
|
|
p.Uid()
|
|
}
|
|
p.SetState(3071)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserENGINE {
|
|
{
|
|
p.SetState(3066)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3068)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEQUAL_SYMBOL {
|
|
{
|
|
p.SetState(3067)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3070)
|
|
p.EngineName()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropTriggerContext is an interface to support dynamic dispatch.
|
|
type IDropTriggerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
TRIGGER() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
IfExists() IIfExistsContext
|
|
|
|
// IsDropTriggerContext differentiates from other interfaces.
|
|
IsDropTriggerContext()
|
|
}
|
|
|
|
type DropTriggerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropTriggerContext() *DropTriggerContext {
|
|
var p = new(DropTriggerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTrigger
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropTriggerContext(p *DropTriggerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropTrigger
|
|
}
|
|
|
|
func (*DropTriggerContext) IsDropTriggerContext() {}
|
|
|
|
func NewDropTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTriggerContext {
|
|
var p = new(DropTriggerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropTrigger
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropTriggerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropTriggerContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropTriggerContext) TRIGGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGER, 0)
|
|
}
|
|
|
|
func (s *DropTriggerContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DropTriggerContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropTriggerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropTrigger(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropTrigger() (localctx IDropTriggerContext) {
|
|
localctx = NewDropTriggerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 170, MySqlParserRULE_dropTrigger)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3073)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3074)
|
|
p.Match(MySqlParserTRIGGER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3076)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3075)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3078)
|
|
p.FullId()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropViewContext is an interface to support dynamic dispatch.
|
|
type IDropViewContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDropType returns the dropType token.
|
|
GetDropType() antlr.Token
|
|
|
|
// SetDropType sets the dropType token.
|
|
SetDropType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
VIEW() antlr.TerminalNode
|
|
AllFullId() []IFullIdContext
|
|
FullId(i int) IFullIdContext
|
|
IfExists() IIfExistsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
RESTRICT() antlr.TerminalNode
|
|
CASCADE() antlr.TerminalNode
|
|
|
|
// IsDropViewContext differentiates from other interfaces.
|
|
IsDropViewContext()
|
|
}
|
|
|
|
type DropViewContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
dropType antlr.Token
|
|
}
|
|
|
|
func NewEmptyDropViewContext() *DropViewContext {
|
|
var p = new(DropViewContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropView
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropViewContext(p *DropViewContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropView
|
|
}
|
|
|
|
func (*DropViewContext) IsDropViewContext() {}
|
|
|
|
func NewDropViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropViewContext {
|
|
var p = new(DropViewContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropView
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropViewContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropViewContext) GetDropType() antlr.Token { return s.dropType }
|
|
|
|
func (s *DropViewContext) SetDropType(v antlr.Token) { s.dropType = v }
|
|
|
|
func (s *DropViewContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropViewContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *DropViewContext) AllFullId() []IFullIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullIdContext); ok {
|
|
tst[i] = t.(IFullIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DropViewContext) FullId(i int) IFullIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DropViewContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropViewContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DropViewContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DropViewContext) RESTRICT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESTRICT, 0)
|
|
}
|
|
|
|
func (s *DropViewContext) CASCADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADE, 0)
|
|
}
|
|
|
|
func (s *DropViewContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropViewContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropView(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropViewContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropView(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropView(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropView() (localctx IDropViewContext) {
|
|
localctx = NewDropViewContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 172, MySqlParserRULE_dropView)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3080)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3081)
|
|
p.Match(MySqlParserVIEW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3083)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 399, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3082)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3085)
|
|
p.FullId()
|
|
}
|
|
p.SetState(3090)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3086)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3087)
|
|
p.FullId()
|
|
}
|
|
|
|
p.SetState(3092)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(3094)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCASCADE || _la == MySqlParserRESTRICT {
|
|
{
|
|
p.SetState(3093)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DropViewContext).dropType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCASCADE || _la == MySqlParserRESTRICT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DropViewContext).dropType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropRoleContext is an interface to support dynamic dispatch.
|
|
type IDropRoleContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
ROLE() antlr.TerminalNode
|
|
AllRoleName() []IRoleNameContext
|
|
RoleName(i int) IRoleNameContext
|
|
IfExists() IIfExistsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsDropRoleContext differentiates from other interfaces.
|
|
IsDropRoleContext()
|
|
}
|
|
|
|
type DropRoleContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropRoleContext() *DropRoleContext {
|
|
var p = new(DropRoleContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropRole
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropRoleContext(p *DropRoleContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropRole
|
|
}
|
|
|
|
func (*DropRoleContext) IsDropRoleContext() {}
|
|
|
|
func NewDropRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropRoleContext {
|
|
var p = new(DropRoleContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropRole
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropRoleContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropRoleContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropRoleContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *DropRoleContext) AllRoleName() []IRoleNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoleNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoleNameContext); ok {
|
|
tst[i] = t.(IRoleNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DropRoleContext) RoleName(i int) IRoleNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleNameContext)
|
|
}
|
|
|
|
func (s *DropRoleContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropRoleContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DropRoleContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DropRoleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropRoleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropRoleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropRole(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropRole() (localctx IDropRoleContext) {
|
|
localctx = NewDropRoleContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 174, MySqlParserRULE_dropRole)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3096)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3097)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3099)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3098)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3101)
|
|
p.RoleName()
|
|
}
|
|
p.SetState(3106)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3102)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3103)
|
|
p.RoleName()
|
|
}
|
|
|
|
p.SetState(3108)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISetRoleContext is an interface to support dynamic dispatch.
|
|
type ISetRoleContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SET() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
ROLE() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
NONE() antlr.TerminalNode
|
|
ALL() antlr.TerminalNode
|
|
AllRoleName() []IRoleNameContext
|
|
RoleName(i int) IRoleNameContext
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
RoleOption() IRoleOptionContext
|
|
|
|
// IsSetRoleContext differentiates from other interfaces.
|
|
IsSetRoleContext()
|
|
}
|
|
|
|
type SetRoleContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySetRoleContext() *SetRoleContext {
|
|
var p = new(SetRoleContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setRole
|
|
return p
|
|
}
|
|
|
|
func InitEmptySetRoleContext(p *SetRoleContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setRole
|
|
}
|
|
|
|
func (*SetRoleContext) IsSetRoleContext() {}
|
|
|
|
func NewSetRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetRoleContext {
|
|
var p = new(SetRoleContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_setRole
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetRoleContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SetRoleContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *SetRoleContext) AllRoleName() []IRoleNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRoleNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRoleNameContext); ok {
|
|
tst[i] = t.(IRoleNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetRoleContext) RoleName(i int) IRoleNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleNameContext)
|
|
}
|
|
|
|
func (s *SetRoleContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetRoleContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *SetRoleContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetRoleContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SetRoleContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SetRoleContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SetRoleContext) RoleOption() IRoleOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleOptionContext)
|
|
}
|
|
|
|
func (s *SetRoleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SetRoleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetRoleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetRole(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetRole(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SetRole() (localctx ISetRoleContext) {
|
|
localctx = NewSetRoleContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 176, MySqlParserRULE_setRole)
|
|
var _la int
|
|
|
|
p.SetState(3142)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 409, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3109)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3110)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3111)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3122)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(3112)
|
|
p.Match(MySqlParserNONE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(3113)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(3114)
|
|
p.RoleName()
|
|
}
|
|
p.SetState(3119)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3115)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3116)
|
|
p.RoleName()
|
|
}
|
|
|
|
p.SetState(3121)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3124)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3127)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 406, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(3125)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(3126)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(3136)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3129)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3132)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 407, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(3130)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(3131)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(3138)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3139)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3140)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3141)
|
|
p.RoleOption()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRenameTableContext is an interface to support dynamic dispatch.
|
|
type IRenameTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RENAME() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
AllRenameTableClause() []IRenameTableClauseContext
|
|
RenameTableClause(i int) IRenameTableClauseContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsRenameTableContext differentiates from other interfaces.
|
|
IsRenameTableContext()
|
|
}
|
|
|
|
type RenameTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRenameTableContext() *RenameTableContext {
|
|
var p = new(RenameTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRenameTableContext(p *RenameTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameTable
|
|
}
|
|
|
|
func (*RenameTableContext) IsRenameTableContext() {}
|
|
|
|
func NewRenameTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameTableContext {
|
|
var p = new(RenameTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_renameTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RenameTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RenameTableContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *RenameTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *RenameTableContext) AllRenameTableClause() []IRenameTableClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRenameTableClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRenameTableClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRenameTableClauseContext); ok {
|
|
tst[i] = t.(IRenameTableClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RenameTableContext) RenameTableClause(i int) IRenameTableClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRenameTableClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRenameTableClauseContext)
|
|
}
|
|
|
|
func (s *RenameTableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RenameTableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RenameTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RenameTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RenameTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRenameTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRenameTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRenameTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RenameTable() (localctx IRenameTableContext) {
|
|
localctx = NewRenameTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 178, MySqlParserRULE_renameTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3144)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3145)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3146)
|
|
p.RenameTableClause()
|
|
}
|
|
p.SetState(3151)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3147)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3148)
|
|
p.RenameTableClause()
|
|
}
|
|
|
|
p.SetState(3153)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRenameTableClauseContext is an interface to support dynamic dispatch.
|
|
type IRenameTableClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllTableName() []ITableNameContext
|
|
TableName(i int) ITableNameContext
|
|
TO() antlr.TerminalNode
|
|
|
|
// IsRenameTableClauseContext differentiates from other interfaces.
|
|
IsRenameTableClauseContext()
|
|
}
|
|
|
|
type RenameTableClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRenameTableClauseContext() *RenameTableClauseContext {
|
|
var p = new(RenameTableClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameTableClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRenameTableClauseContext(p *RenameTableClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameTableClause
|
|
}
|
|
|
|
func (*RenameTableClauseContext) IsRenameTableClauseContext() {}
|
|
|
|
func NewRenameTableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameTableClauseContext {
|
|
var p = new(RenameTableClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_renameTableClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RenameTableClauseContext) AllTableName() []ITableNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableNameContext); ok {
|
|
tst[i] = t.(ITableNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) TableName(i int) ITableNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRenameTableClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRenameTableClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameTableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRenameTableClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RenameTableClause() (localctx IRenameTableClauseContext) {
|
|
localctx = NewRenameTableClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 180, MySqlParserRULE_renameTableClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3154)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(3155)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3156)
|
|
p.TableName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITruncateTableContext is an interface to support dynamic dispatch.
|
|
type ITruncateTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
TRUNCATE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
TABLE() antlr.TerminalNode
|
|
|
|
// IsTruncateTableContext differentiates from other interfaces.
|
|
IsTruncateTableContext()
|
|
}
|
|
|
|
type TruncateTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTruncateTableContext() *TruncateTableContext {
|
|
var p = new(TruncateTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_truncateTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTruncateTableContext(p *TruncateTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_truncateTable
|
|
}
|
|
|
|
func (*TruncateTableContext) IsTruncateTableContext() {}
|
|
|
|
func NewTruncateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncateTableContext {
|
|
var p = new(TruncateTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_truncateTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TruncateTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TruncateTableContext) TRUNCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRUNCATE, 0)
|
|
}
|
|
|
|
func (s *TruncateTableContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *TruncateTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *TruncateTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TruncateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TruncateTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTruncateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *TruncateTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTruncateTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *TruncateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTruncateTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TruncateTable() (localctx ITruncateTableContext) {
|
|
localctx = NewTruncateTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 182, MySqlParserRULE_truncateTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3158)
|
|
p.Match(MySqlParserTRUNCATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3160)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserTABLE {
|
|
{
|
|
p.SetState(3159)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3162)
|
|
p.TableName()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICallStatementContext is an interface to support dynamic dispatch.
|
|
type ICallStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CALL() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
Constants() IConstantsContext
|
|
Expressions() IExpressionsContext
|
|
|
|
// IsCallStatementContext differentiates from other interfaces.
|
|
IsCallStatementContext()
|
|
}
|
|
|
|
type CallStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCallStatementContext() *CallStatementContext {
|
|
var p = new(CallStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_callStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCallStatementContext(p *CallStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_callStatement
|
|
}
|
|
|
|
func (*CallStatementContext) IsCallStatementContext() {}
|
|
|
|
func NewCallStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallStatementContext {
|
|
var p = new(CallStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_callStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CallStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CallStatementContext) CALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCALL, 0)
|
|
}
|
|
|
|
func (s *CallStatementContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *CallStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CallStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CallStatementContext) Constants() IConstantsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantsContext)
|
|
}
|
|
|
|
func (s *CallStatementContext) Expressions() IExpressionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionsContext)
|
|
}
|
|
|
|
func (s *CallStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CallStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CallStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCallStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CallStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCallStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CallStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCallStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CallStatement() (localctx ICallStatementContext) {
|
|
localctx = NewCallStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 184, MySqlParserRULE_callStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3164)
|
|
p.Match(MySqlParserCALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3165)
|
|
p.FullId()
|
|
}
|
|
p.SetState(3172)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 413, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3166)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3169)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3167)
|
|
p.Constants()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(3168)
|
|
p.Expressions()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3171)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeleteStatementContext is an interface to support dynamic dispatch.
|
|
type IDeleteStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SingleDeleteStatement() ISingleDeleteStatementContext
|
|
MultipleDeleteStatement() IMultipleDeleteStatementContext
|
|
|
|
// IsDeleteStatementContext differentiates from other interfaces.
|
|
IsDeleteStatementContext()
|
|
}
|
|
|
|
type DeleteStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDeleteStatementContext() *DeleteStatementContext {
|
|
var p = new(DeleteStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_deleteStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeleteStatementContext(p *DeleteStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_deleteStatement
|
|
}
|
|
|
|
func (*DeleteStatementContext) IsDeleteStatementContext() {}
|
|
|
|
func NewDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteStatementContext {
|
|
var p = new(DeleteStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_deleteStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeleteStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeleteStatementContext) SingleDeleteStatement() ISingleDeleteStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISingleDeleteStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISingleDeleteStatementContext)
|
|
}
|
|
|
|
func (s *DeleteStatementContext) MultipleDeleteStatement() IMultipleDeleteStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMultipleDeleteStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMultipleDeleteStatementContext)
|
|
}
|
|
|
|
func (s *DeleteStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeleteStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeleteStatement() (localctx IDeleteStatementContext) {
|
|
localctx = NewDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 186, MySqlParserRULE_deleteStatement)
|
|
p.SetState(3176)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 414, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3174)
|
|
p.SingleDeleteStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3175)
|
|
p.MultipleDeleteStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDoStatementContext is an interface to support dynamic dispatch.
|
|
type IDoStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DO() antlr.TerminalNode
|
|
Expressions() IExpressionsContext
|
|
|
|
// IsDoStatementContext differentiates from other interfaces.
|
|
IsDoStatementContext()
|
|
}
|
|
|
|
type DoStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDoStatementContext() *DoStatementContext {
|
|
var p = new(DoStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_doStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDoStatementContext(p *DoStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_doStatement
|
|
}
|
|
|
|
func (*DoStatementContext) IsDoStatementContext() {}
|
|
|
|
func NewDoStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoStatementContext {
|
|
var p = new(DoStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_doStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DoStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DoStatementContext) DO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDO, 0)
|
|
}
|
|
|
|
func (s *DoStatementContext) Expressions() IExpressionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionsContext)
|
|
}
|
|
|
|
func (s *DoStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DoStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DoStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDoStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDoStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDoStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DoStatement() (localctx IDoStatementContext) {
|
|
localctx = NewDoStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 188, MySqlParserRULE_doStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3178)
|
|
p.Match(MySqlParserDO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3179)
|
|
p.Expressions()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerStatementContext is an interface to support dynamic dispatch.
|
|
type IHandlerStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HandlerOpenStatement() IHandlerOpenStatementContext
|
|
HandlerReadIndexStatement() IHandlerReadIndexStatementContext
|
|
HandlerReadStatement() IHandlerReadStatementContext
|
|
HandlerCloseStatement() IHandlerCloseStatementContext
|
|
|
|
// IsHandlerStatementContext differentiates from other interfaces.
|
|
IsHandlerStatementContext()
|
|
}
|
|
|
|
type HandlerStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHandlerStatementContext() *HandlerStatementContext {
|
|
var p = new(HandlerStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerStatementContext(p *HandlerStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerStatement
|
|
}
|
|
|
|
func (*HandlerStatementContext) IsHandlerStatementContext() {}
|
|
|
|
func NewHandlerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerStatementContext {
|
|
var p = new(HandlerStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerStatementContext) HandlerOpenStatement() IHandlerOpenStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerOpenStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerOpenStatementContext)
|
|
}
|
|
|
|
func (s *HandlerStatementContext) HandlerReadIndexStatement() IHandlerReadIndexStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerReadIndexStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerReadIndexStatementContext)
|
|
}
|
|
|
|
func (s *HandlerStatementContext) HandlerReadStatement() IHandlerReadStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerReadStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerReadStatementContext)
|
|
}
|
|
|
|
func (s *HandlerStatementContext) HandlerCloseStatement() IHandlerCloseStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerCloseStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerCloseStatementContext)
|
|
}
|
|
|
|
func (s *HandlerStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HandlerStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerStatement() (localctx IHandlerStatementContext) {
|
|
localctx = NewHandlerStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 190, MySqlParserRULE_handlerStatement)
|
|
p.SetState(3185)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 415, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3181)
|
|
p.HandlerOpenStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3182)
|
|
p.HandlerReadIndexStatement()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(3183)
|
|
p.HandlerReadStatement()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(3184)
|
|
p.HandlerCloseStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IInsertStatementContext is an interface to support dynamic dispatch.
|
|
type IInsertStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// GetPartitions returns the partitions rule contexts.
|
|
GetPartitions() IUidListContext
|
|
|
|
// GetColumns returns the columns rule contexts.
|
|
GetColumns() IFullColumnNameListContext
|
|
|
|
// GetSetFirst returns the setFirst rule contexts.
|
|
GetSetFirst() IUpdatedElementContext
|
|
|
|
// Get_updatedElement returns the _updatedElement rule contexts.
|
|
Get_updatedElement() IUpdatedElementContext
|
|
|
|
// GetDuplicatedFirst returns the duplicatedFirst rule contexts.
|
|
GetDuplicatedFirst() IUpdatedElementContext
|
|
|
|
// SetPartitions sets the partitions rule contexts.
|
|
SetPartitions(IUidListContext)
|
|
|
|
// SetColumns sets the columns rule contexts.
|
|
SetColumns(IFullColumnNameListContext)
|
|
|
|
// SetSetFirst sets the setFirst rule contexts.
|
|
SetSetFirst(IUpdatedElementContext)
|
|
|
|
// Set_updatedElement sets the _updatedElement rule contexts.
|
|
Set_updatedElement(IUpdatedElementContext)
|
|
|
|
// SetDuplicatedFirst sets the duplicatedFirst rule contexts.
|
|
SetDuplicatedFirst(IUpdatedElementContext)
|
|
|
|
// GetSetElements returns the setElements rule context list.
|
|
GetSetElements() []IUpdatedElementContext
|
|
|
|
// GetDuplicatedElements returns the duplicatedElements rule context list.
|
|
GetDuplicatedElements() []IUpdatedElementContext
|
|
|
|
// SetSetElements sets the setElements rule context list.
|
|
SetSetElements([]IUpdatedElementContext)
|
|
|
|
// SetDuplicatedElements sets the duplicatedElements rule context list.
|
|
SetDuplicatedElements([]IUpdatedElementContext)
|
|
|
|
// Getter signatures
|
|
INSERT() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
InsertStatementValue() IInsertStatementValueContext
|
|
SET() antlr.TerminalNode
|
|
IGNORE() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
PARTITION() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
ON() antlr.TerminalNode
|
|
DUPLICATE() antlr.TerminalNode
|
|
KEY() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
DELAYED() antlr.TerminalNode
|
|
HIGH_PRIORITY() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
AS() antlr.TerminalNode
|
|
FullColumnNameList() IFullColumnNameListContext
|
|
|
|
// IsInsertStatementContext differentiates from other interfaces.
|
|
IsInsertStatementContext()
|
|
}
|
|
|
|
type InsertStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
partitions IUidListContext
|
|
columns IFullColumnNameListContext
|
|
setFirst IUpdatedElementContext
|
|
_updatedElement IUpdatedElementContext
|
|
setElements []IUpdatedElementContext
|
|
duplicatedFirst IUpdatedElementContext
|
|
duplicatedElements []IUpdatedElementContext
|
|
}
|
|
|
|
func NewEmptyInsertStatementContext() *InsertStatementContext {
|
|
var p = new(InsertStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_insertStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyInsertStatementContext(p *InsertStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_insertStatement
|
|
}
|
|
|
|
func (*InsertStatementContext) IsInsertStatementContext() {}
|
|
|
|
func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementContext {
|
|
var p = new(InsertStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_insertStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InsertStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *InsertStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *InsertStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *InsertStatementContext) GetPartitions() IUidListContext { return s.partitions }
|
|
|
|
func (s *InsertStatementContext) GetColumns() IFullColumnNameListContext { return s.columns }
|
|
|
|
func (s *InsertStatementContext) GetSetFirst() IUpdatedElementContext { return s.setFirst }
|
|
|
|
func (s *InsertStatementContext) Get_updatedElement() IUpdatedElementContext {
|
|
return s._updatedElement
|
|
}
|
|
|
|
func (s *InsertStatementContext) GetDuplicatedFirst() IUpdatedElementContext {
|
|
return s.duplicatedFirst
|
|
}
|
|
|
|
func (s *InsertStatementContext) SetPartitions(v IUidListContext) { s.partitions = v }
|
|
|
|
func (s *InsertStatementContext) SetColumns(v IFullColumnNameListContext) { s.columns = v }
|
|
|
|
func (s *InsertStatementContext) SetSetFirst(v IUpdatedElementContext) { s.setFirst = v }
|
|
|
|
func (s *InsertStatementContext) Set_updatedElement(v IUpdatedElementContext) { s._updatedElement = v }
|
|
|
|
func (s *InsertStatementContext) SetDuplicatedFirst(v IUpdatedElementContext) { s.duplicatedFirst = v }
|
|
|
|
func (s *InsertStatementContext) GetSetElements() []IUpdatedElementContext { return s.setElements }
|
|
|
|
func (s *InsertStatementContext) GetDuplicatedElements() []IUpdatedElementContext {
|
|
return s.duplicatedElements
|
|
}
|
|
|
|
func (s *InsertStatementContext) SetSetElements(v []IUpdatedElementContext) { s.setElements = v }
|
|
|
|
func (s *InsertStatementContext) SetDuplicatedElements(v []IUpdatedElementContext) {
|
|
s.duplicatedElements = v
|
|
}
|
|
|
|
func (s *InsertStatementContext) INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) InsertStatementValue() IInsertStatementValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IInsertStatementValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IInsertStatementValueContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *InsertStatementContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *InsertStatementContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *InsertStatementContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *InsertStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *InsertStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) DUPLICATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDUPLICATE, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) DELAYED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELAYED, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) HIGH_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHIGH_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *InsertStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *InsertStatementContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *InsertStatementContext) FullColumnNameList() IFullColumnNameListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameListContext)
|
|
}
|
|
|
|
func (s *InsertStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InsertStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *InsertStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInsertStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *InsertStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInsertStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *InsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInsertStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) InsertStatement() (localctx IInsertStatementContext) {
|
|
localctx = NewInsertStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 192, MySqlParserRULE_insertStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3187)
|
|
p.Match(MySqlParserINSERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3189)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if (int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&-9223372032559808511) != 0 {
|
|
{
|
|
p.SetState(3188)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*InsertStatementContext).priority = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&-9223372032559808511) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*InsertStatementContext).priority = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3192)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3191)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3195)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINTO {
|
|
{
|
|
p.SetState(3194)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3197)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3204)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(3198)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3199)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3201)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(3200)
|
|
|
|
var _x = p.UidList()
|
|
|
|
localctx.(*InsertStatementContext).partitions = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3203)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3229)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT, MySqlParserVALUES, MySqlParserVALUE, MySqlParserLR_BRACKET:
|
|
p.SetState(3211)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3206)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3208)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 421, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3207)
|
|
|
|
var _x = p.FullColumnNameList()
|
|
|
|
localctx.(*InsertStatementContext).columns = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3210)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3213)
|
|
p.InsertStatementValue()
|
|
}
|
|
p.SetState(3218)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 424, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(3215)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3214)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3217)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserSET:
|
|
{
|
|
p.SetState(3220)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3221)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*InsertStatementContext).setFirst = _x
|
|
}
|
|
p.SetState(3226)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3222)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3223)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*InsertStatementContext)._updatedElement = _x
|
|
}
|
|
localctx.(*InsertStatementContext).setElements = append(localctx.(*InsertStatementContext).setElements, localctx.(*InsertStatementContext)._updatedElement)
|
|
|
|
p.SetState(3228)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(3243)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserON {
|
|
{
|
|
p.SetState(3231)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3232)
|
|
p.Match(MySqlParserDUPLICATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3233)
|
|
p.Match(MySqlParserKEY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3234)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3235)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*InsertStatementContext).duplicatedFirst = _x
|
|
}
|
|
p.SetState(3240)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3236)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3237)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*InsertStatementContext)._updatedElement = _x
|
|
}
|
|
localctx.(*InsertStatementContext).duplicatedElements = append(localctx.(*InsertStatementContext).duplicatedElements, localctx.(*InsertStatementContext)._updatedElement)
|
|
|
|
p.SetState(3242)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILoadDataStatementContext is an interface to support dynamic dispatch.
|
|
type ILoadDataStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// GetFilename returns the filename token.
|
|
GetFilename() antlr.Token
|
|
|
|
// GetViolation returns the violation token.
|
|
GetViolation() antlr.Token
|
|
|
|
// GetFieldsFormat returns the fieldsFormat token.
|
|
GetFieldsFormat() antlr.Token
|
|
|
|
// GetLinesFormat returns the linesFormat token.
|
|
GetLinesFormat() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// SetFilename sets the filename token.
|
|
SetFilename(antlr.Token)
|
|
|
|
// SetViolation sets the violation token.
|
|
SetViolation(antlr.Token)
|
|
|
|
// SetFieldsFormat sets the fieldsFormat token.
|
|
SetFieldsFormat(antlr.Token)
|
|
|
|
// SetLinesFormat sets the linesFormat token.
|
|
SetLinesFormat(antlr.Token)
|
|
|
|
// GetCharset returns the charset rule contexts.
|
|
GetCharset() ICharsetNameContext
|
|
|
|
// SetCharset sets the charset rule contexts.
|
|
SetCharset(ICharsetNameContext)
|
|
|
|
// Getter signatures
|
|
LOAD() antlr.TerminalNode
|
|
DATA() antlr.TerminalNode
|
|
INFILE() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
PARTITION() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
CHARACTER() antlr.TerminalNode
|
|
AllSET() []antlr.TerminalNode
|
|
SET(i int) antlr.TerminalNode
|
|
AllLINES() []antlr.TerminalNode
|
|
LINES(i int) antlr.TerminalNode
|
|
AllIGNORE() []antlr.TerminalNode
|
|
IGNORE(i int) antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
AllAssignmentField() []IAssignmentFieldContext
|
|
AssignmentField(i int) IAssignmentFieldContext
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
CharsetName() ICharsetNameContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
CONCURRENT() antlr.TerminalNode
|
|
REPLACE() antlr.TerminalNode
|
|
FIELDS() antlr.TerminalNode
|
|
COLUMNS() antlr.TerminalNode
|
|
ROWS() antlr.TerminalNode
|
|
AllSelectFieldsInto() []ISelectFieldsIntoContext
|
|
SelectFieldsInto(i int) ISelectFieldsIntoContext
|
|
AllSelectLinesInto() []ISelectLinesIntoContext
|
|
SelectLinesInto(i int) ISelectLinesIntoContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsLoadDataStatementContext differentiates from other interfaces.
|
|
IsLoadDataStatementContext()
|
|
}
|
|
|
|
type LoadDataStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
filename antlr.Token
|
|
violation antlr.Token
|
|
charset ICharsetNameContext
|
|
fieldsFormat antlr.Token
|
|
linesFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyLoadDataStatementContext() *LoadDataStatementContext {
|
|
var p = new(LoadDataStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadDataStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLoadDataStatementContext(p *LoadDataStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadDataStatement
|
|
}
|
|
|
|
func (*LoadDataStatementContext) IsLoadDataStatementContext() {}
|
|
|
|
func NewLoadDataStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadDataStatementContext {
|
|
var p = new(LoadDataStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_loadDataStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LoadDataStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *LoadDataStatementContext) GetFilename() antlr.Token { return s.filename }
|
|
|
|
func (s *LoadDataStatementContext) GetViolation() antlr.Token { return s.violation }
|
|
|
|
func (s *LoadDataStatementContext) GetFieldsFormat() antlr.Token { return s.fieldsFormat }
|
|
|
|
func (s *LoadDataStatementContext) GetLinesFormat() antlr.Token { return s.linesFormat }
|
|
|
|
func (s *LoadDataStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *LoadDataStatementContext) SetFilename(v antlr.Token) { s.filename = v }
|
|
|
|
func (s *LoadDataStatementContext) SetViolation(v antlr.Token) { s.violation = v }
|
|
|
|
func (s *LoadDataStatementContext) SetFieldsFormat(v antlr.Token) { s.fieldsFormat = v }
|
|
|
|
func (s *LoadDataStatementContext) SetLinesFormat(v antlr.Token) { s.linesFormat = v }
|
|
|
|
func (s *LoadDataStatementContext) GetCharset() ICharsetNameContext { return s.charset }
|
|
|
|
func (s *LoadDataStatementContext) SetCharset(v ICharsetNameContext) { s.charset = v }
|
|
|
|
func (s *LoadDataStatementContext) LOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOAD, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) INFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINFILE, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllSET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSET)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) SET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllLINES() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLINES)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) LINES(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINES, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllIGNORE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserIGNORE)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) IGNORE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllAssignmentField() []IAssignmentFieldContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IAssignmentFieldContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IAssignmentFieldContext); ok {
|
|
tst[i] = t.(IAssignmentFieldContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AssignmentField(i int) IAssignmentFieldContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAssignmentFieldContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) CONCURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONCURRENT, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) FIELDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIELDS, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROWS, 0)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllSelectFieldsInto() []ISelectFieldsIntoContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectFieldsIntoContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
tst[i] = t.(ISelectFieldsIntoContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) SelectFieldsInto(i int) ISelectFieldsIntoContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectFieldsIntoContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllSelectLinesInto() []ISelectLinesIntoContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectLinesIntoContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
tst[i] = t.(ISelectLinesIntoContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) SelectLinesInto(i int) ISelectLinesIntoContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectLinesIntoContext)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLoadDataStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLoadDataStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadDataStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLoadDataStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LoadDataStatement() (localctx ILoadDataStatementContext) {
|
|
localctx = NewLoadDataStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 194, MySqlParserRULE_loadDataStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3245)
|
|
p.Match(MySqlParserLOAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3246)
|
|
p.Match(MySqlParserDATA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3248)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT {
|
|
{
|
|
p.SetState(3247)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadDataStatementContext).priority = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadDataStatementContext).priority = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3251)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(3250)
|
|
p.Match(MySqlParserLOCAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3253)
|
|
p.Match(MySqlParserINFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3254)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*LoadDataStatementContext).filename = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3256)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE {
|
|
{
|
|
p.SetState(3255)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadDataStatementContext).violation = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadDataStatementContext).violation = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3258)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3259)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3260)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3266)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(3261)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3262)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3263)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(3264)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3271)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCHARACTER {
|
|
{
|
|
p.SetState(3268)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3269)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3270)
|
|
|
|
var _x = p.CharsetName()
|
|
|
|
localctx.(*LoadDataStatementContext).charset = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(3279)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS {
|
|
{
|
|
p.SetState(3273)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadDataStatementContext).fieldsFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadDataStatementContext).fieldsFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(3275)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserENCLOSED || _la == MySqlParserESCAPED || _la == MySqlParserOPTIONALLY || _la == MySqlParserTERMINATED {
|
|
{
|
|
p.SetState(3274)
|
|
p.SelectFieldsInto()
|
|
}
|
|
|
|
p.SetState(3277)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(3287)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINES {
|
|
{
|
|
p.SetState(3281)
|
|
p.Match(MySqlParserLINES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3283)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserSTARTING || _la == MySqlParserTERMINATED {
|
|
{
|
|
p.SetState(3282)
|
|
p.SelectLinesInto()
|
|
}
|
|
|
|
p.SetState(3285)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(3293)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3289)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3290)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(3291)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadDataStatementContext).linesFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLINES || _la == MySqlParserROWS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadDataStatementContext).linesFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3306)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3295)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3296)
|
|
p.AssignmentField()
|
|
}
|
|
p.SetState(3301)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3297)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3298)
|
|
p.AssignmentField()
|
|
}
|
|
|
|
p.SetState(3303)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(3304)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3317)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3308)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3309)
|
|
p.UpdatedElement()
|
|
}
|
|
p.SetState(3314)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3310)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3311)
|
|
p.UpdatedElement()
|
|
}
|
|
|
|
p.SetState(3316)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILoadXmlStatementContext is an interface to support dynamic dispatch.
|
|
type ILoadXmlStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// GetFilename returns the filename token.
|
|
GetFilename() antlr.Token
|
|
|
|
// GetViolation returns the violation token.
|
|
GetViolation() antlr.Token
|
|
|
|
// GetTag returns the tag token.
|
|
GetTag() antlr.Token
|
|
|
|
// GetLinesFormat returns the linesFormat token.
|
|
GetLinesFormat() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// SetFilename sets the filename token.
|
|
SetFilename(antlr.Token)
|
|
|
|
// SetViolation sets the violation token.
|
|
SetViolation(antlr.Token)
|
|
|
|
// SetTag sets the tag token.
|
|
SetTag(antlr.Token)
|
|
|
|
// SetLinesFormat sets the linesFormat token.
|
|
SetLinesFormat(antlr.Token)
|
|
|
|
// GetCharset returns the charset rule contexts.
|
|
GetCharset() ICharsetNameContext
|
|
|
|
// SetCharset sets the charset rule contexts.
|
|
SetCharset(ICharsetNameContext)
|
|
|
|
// Getter signatures
|
|
LOAD() antlr.TerminalNode
|
|
XML() antlr.TerminalNode
|
|
INFILE() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
CHARACTER() antlr.TerminalNode
|
|
AllSET() []antlr.TerminalNode
|
|
SET(i int) antlr.TerminalNode
|
|
AllROWS() []antlr.TerminalNode
|
|
ROWS(i int) antlr.TerminalNode
|
|
IDENTIFIED() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
LESS_SYMBOL() antlr.TerminalNode
|
|
GREATER_SYMBOL() antlr.TerminalNode
|
|
AllIGNORE() []antlr.TerminalNode
|
|
IGNORE(i int) antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllAssignmentField() []IAssignmentFieldContext
|
|
AssignmentField(i int) IAssignmentFieldContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
CharsetName() ICharsetNameContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
CONCURRENT() antlr.TerminalNode
|
|
REPLACE() antlr.TerminalNode
|
|
LINES() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsLoadXmlStatementContext differentiates from other interfaces.
|
|
IsLoadXmlStatementContext()
|
|
}
|
|
|
|
type LoadXmlStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
filename antlr.Token
|
|
violation antlr.Token
|
|
charset ICharsetNameContext
|
|
tag antlr.Token
|
|
linesFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyLoadXmlStatementContext() *LoadXmlStatementContext {
|
|
var p = new(LoadXmlStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadXmlStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLoadXmlStatementContext(p *LoadXmlStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadXmlStatement
|
|
}
|
|
|
|
func (*LoadXmlStatementContext) IsLoadXmlStatementContext() {}
|
|
|
|
func NewLoadXmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadXmlStatementContext {
|
|
var p = new(LoadXmlStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_loadXmlStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LoadXmlStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *LoadXmlStatementContext) GetFilename() antlr.Token { return s.filename }
|
|
|
|
func (s *LoadXmlStatementContext) GetViolation() antlr.Token { return s.violation }
|
|
|
|
func (s *LoadXmlStatementContext) GetTag() antlr.Token { return s.tag }
|
|
|
|
func (s *LoadXmlStatementContext) GetLinesFormat() antlr.Token { return s.linesFormat }
|
|
|
|
func (s *LoadXmlStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *LoadXmlStatementContext) SetFilename(v antlr.Token) { s.filename = v }
|
|
|
|
func (s *LoadXmlStatementContext) SetViolation(v antlr.Token) { s.violation = v }
|
|
|
|
func (s *LoadXmlStatementContext) SetTag(v antlr.Token) { s.tag = v }
|
|
|
|
func (s *LoadXmlStatementContext) SetLinesFormat(v antlr.Token) { s.linesFormat = v }
|
|
|
|
func (s *LoadXmlStatementContext) GetCharset() ICharsetNameContext { return s.charset }
|
|
|
|
func (s *LoadXmlStatementContext) SetCharset(v ICharsetNameContext) { s.charset = v }
|
|
|
|
func (s *LoadXmlStatementContext) LOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOAD, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) XML() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXML, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) INFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINFILE, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllSET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSET)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) SET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, i)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllROWS() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserROWS)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) ROWS(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROWS, i)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) LESS_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLESS_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) GREATER_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREATER_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllIGNORE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserIGNORE)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) IGNORE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, i)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllAssignmentField() []IAssignmentFieldContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IAssignmentFieldContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IAssignmentFieldContext); ok {
|
|
tst[i] = t.(IAssignmentFieldContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AssignmentField(i int) IAssignmentFieldContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAssignmentFieldContext)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) CONCURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONCURRENT, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) LINES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINES, 0)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLoadXmlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLoadXmlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadXmlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLoadXmlStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LoadXmlStatement() (localctx ILoadXmlStatementContext) {
|
|
localctx = NewLoadXmlStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 196, MySqlParserRULE_loadXmlStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3319)
|
|
p.Match(MySqlParserLOAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3320)
|
|
p.Match(MySqlParserXML)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3322)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT {
|
|
{
|
|
p.SetState(3321)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadXmlStatementContext).priority = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadXmlStatementContext).priority = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3325)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(3324)
|
|
p.Match(MySqlParserLOCAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3327)
|
|
p.Match(MySqlParserINFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3328)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*LoadXmlStatementContext).filename = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3330)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE {
|
|
{
|
|
p.SetState(3329)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadXmlStatementContext).violation = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadXmlStatementContext).violation = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3332)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3333)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3334)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3338)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCHARACTER {
|
|
{
|
|
p.SetState(3335)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3336)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3337)
|
|
|
|
var _x = p.CharsetName()
|
|
|
|
localctx.(*LoadXmlStatementContext).charset = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(3346)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserROWS {
|
|
{
|
|
p.SetState(3340)
|
|
p.Match(MySqlParserROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3341)
|
|
p.Match(MySqlParserIDENTIFIED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3342)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3343)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3344)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*LoadXmlStatementContext).tag = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3345)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3352)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3348)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3349)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(3350)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadXmlStatementContext).linesFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLINES || _la == MySqlParserROWS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadXmlStatementContext).linesFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3365)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3354)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3355)
|
|
p.AssignmentField()
|
|
}
|
|
p.SetState(3360)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3356)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3357)
|
|
p.AssignmentField()
|
|
}
|
|
|
|
p.SetState(3362)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(3363)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3376)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3367)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3368)
|
|
p.UpdatedElement()
|
|
}
|
|
p.SetState(3373)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3369)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3370)
|
|
p.UpdatedElement()
|
|
}
|
|
|
|
p.SetState(3375)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReplaceStatementContext is an interface to support dynamic dispatch.
|
|
type IReplaceStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// GetPartitions returns the partitions rule contexts.
|
|
GetPartitions() IUidListContext
|
|
|
|
// GetColumns returns the columns rule contexts.
|
|
GetColumns() IUidListContext
|
|
|
|
// GetSetFirst returns the setFirst rule contexts.
|
|
GetSetFirst() IUpdatedElementContext
|
|
|
|
// Get_updatedElement returns the _updatedElement rule contexts.
|
|
Get_updatedElement() IUpdatedElementContext
|
|
|
|
// SetPartitions sets the partitions rule contexts.
|
|
SetPartitions(IUidListContext)
|
|
|
|
// SetColumns sets the columns rule contexts.
|
|
SetColumns(IUidListContext)
|
|
|
|
// SetSetFirst sets the setFirst rule contexts.
|
|
SetSetFirst(IUpdatedElementContext)
|
|
|
|
// Set_updatedElement sets the _updatedElement rule contexts.
|
|
Set_updatedElement(IUpdatedElementContext)
|
|
|
|
// GetSetElements returns the setElements rule context list.
|
|
GetSetElements() []IUpdatedElementContext
|
|
|
|
// SetSetElements sets the setElements rule context list.
|
|
SetSetElements([]IUpdatedElementContext)
|
|
|
|
// Getter signatures
|
|
REPLACE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
InsertStatementValue() IInsertStatementValueContext
|
|
SET() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
PARTITION() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
AllUidList() []IUidListContext
|
|
UidList(i int) IUidListContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
DELAYED() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsReplaceStatementContext differentiates from other interfaces.
|
|
IsReplaceStatementContext()
|
|
}
|
|
|
|
type ReplaceStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
partitions IUidListContext
|
|
columns IUidListContext
|
|
setFirst IUpdatedElementContext
|
|
_updatedElement IUpdatedElementContext
|
|
setElements []IUpdatedElementContext
|
|
}
|
|
|
|
func NewEmptyReplaceStatementContext() *ReplaceStatementContext {
|
|
var p = new(ReplaceStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replaceStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReplaceStatementContext(p *ReplaceStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replaceStatement
|
|
}
|
|
|
|
func (*ReplaceStatementContext) IsReplaceStatementContext() {}
|
|
|
|
func NewReplaceStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplaceStatementContext {
|
|
var p = new(ReplaceStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_replaceStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReplaceStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *ReplaceStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *ReplaceStatementContext) GetPartitions() IUidListContext { return s.partitions }
|
|
|
|
func (s *ReplaceStatementContext) GetColumns() IUidListContext { return s.columns }
|
|
|
|
func (s *ReplaceStatementContext) GetSetFirst() IUpdatedElementContext { return s.setFirst }
|
|
|
|
func (s *ReplaceStatementContext) Get_updatedElement() IUpdatedElementContext {
|
|
return s._updatedElement
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) SetPartitions(v IUidListContext) { s.partitions = v }
|
|
|
|
func (s *ReplaceStatementContext) SetColumns(v IUidListContext) { s.columns = v }
|
|
|
|
func (s *ReplaceStatementContext) SetSetFirst(v IUpdatedElementContext) { s.setFirst = v }
|
|
|
|
func (s *ReplaceStatementContext) Set_updatedElement(v IUpdatedElementContext) { s._updatedElement = v }
|
|
|
|
func (s *ReplaceStatementContext) GetSetElements() []IUpdatedElementContext { return s.setElements }
|
|
|
|
func (s *ReplaceStatementContext) SetSetElements(v []IUpdatedElementContext) { s.setElements = v }
|
|
|
|
func (s *ReplaceStatementContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) InsertStatementValue() IInsertStatementValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IInsertStatementValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IInsertStatementValueContext)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) AllUidList() []IUidListContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidListContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidListContext); ok {
|
|
tst[i] = t.(IUidListContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) UidList(i int) IUidListContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) DELAYED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELAYED, 0)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReplaceStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReplaceStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReplaceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReplaceStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReplaceStatement() (localctx IReplaceStatementContext) {
|
|
localctx = NewReplaceStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 198, MySqlParserRULE_replaceStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3378)
|
|
p.Match(MySqlParserREPLACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3380)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDELAYED || _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(3379)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ReplaceStatementContext).priority = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDELAYED || _la == MySqlParserLOW_PRIORITY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ReplaceStatementContext).priority = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3383)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINTO {
|
|
{
|
|
p.SetState(3382)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3385)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3391)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(3386)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3387)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3388)
|
|
|
|
var _x = p.UidList()
|
|
|
|
localctx.(*ReplaceStatementContext).partitions = _x
|
|
}
|
|
{
|
|
p.SetState(3389)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3409)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT, MySqlParserVALUES, MySqlParserVALUE, MySqlParserLR_BRACKET:
|
|
p.SetState(3397)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3393)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3394)
|
|
|
|
var _x = p.UidList()
|
|
|
|
localctx.(*ReplaceStatementContext).columns = _x
|
|
}
|
|
{
|
|
p.SetState(3395)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3399)
|
|
p.InsertStatementValue()
|
|
}
|
|
|
|
case MySqlParserSET:
|
|
{
|
|
p.SetState(3400)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3401)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*ReplaceStatementContext).setFirst = _x
|
|
}
|
|
p.SetState(3406)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3402)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3403)
|
|
|
|
var _x = p.UpdatedElement()
|
|
|
|
localctx.(*ReplaceStatementContext)._updatedElement = _x
|
|
}
|
|
localctx.(*ReplaceStatementContext).setElements = append(localctx.(*ReplaceStatementContext).setElements, localctx.(*ReplaceStatementContext)._updatedElement)
|
|
|
|
p.SetState(3408)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectStatementContext is an interface to support dynamic dispatch.
|
|
type ISelectStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSelectStatementContext differentiates from other interfaces.
|
|
IsSelectStatementContext()
|
|
}
|
|
|
|
type SelectStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySelectStatementContext() *SelectStatementContext {
|
|
var p = new(SelectStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectStatementContext(p *SelectStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectStatement
|
|
}
|
|
|
|
func (*SelectStatementContext) IsSelectStatementContext() {}
|
|
|
|
func NewSelectStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStatementContext {
|
|
var p = new(SelectStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectStatementContext) CopyAll(ctx *SelectStatementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SelectStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type UnionSelectContext struct {
|
|
SelectStatementContext
|
|
unionType antlr.Token
|
|
}
|
|
|
|
func NewUnionSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionSelectContext {
|
|
var p = new(UnionSelectContext)
|
|
|
|
InitEmptySelectStatementContext(&p.SelectStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnionSelectContext) GetUnionType() antlr.Token { return s.unionType }
|
|
|
|
func (s *UnionSelectContext) SetUnionType(v antlr.Token) { s.unionType = v }
|
|
|
|
func (s *UnionSelectContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnionSelectContext) QuerySpecificationNointo() IQuerySpecificationNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationNointoContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) AllUnionStatement() []IUnionStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUnionStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUnionStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUnionStatementContext); ok {
|
|
tst[i] = t.(IUnionStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UnionSelectContext) UnionStatement(i int) IUnionStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnionStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnionStatementContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNION, 0)
|
|
}
|
|
|
|
func (s *UnionSelectContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) LockClause() ILockClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockClauseContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) QuerySpecification() IQuerySpecificationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) QueryExpression() IQueryExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionContext)
|
|
}
|
|
|
|
func (s *UnionSelectContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *UnionSelectContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *UnionSelectContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnionSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionSelectContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnionSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnionSelect(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type UnionParenthesisSelectContext struct {
|
|
SelectStatementContext
|
|
unionType antlr.Token
|
|
}
|
|
|
|
func NewUnionParenthesisSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionParenthesisSelectContext {
|
|
var p = new(UnionParenthesisSelectContext)
|
|
|
|
InitEmptySelectStatementContext(&p.SelectStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) GetUnionType() antlr.Token { return s.unionType }
|
|
|
|
func (s *UnionParenthesisSelectContext) SetUnionType(v antlr.Token) { s.unionType = v }
|
|
|
|
func (s *UnionParenthesisSelectContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) AllUnionParenthesis() []IUnionParenthesisContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUnionParenthesisContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUnionParenthesisContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUnionParenthesisContext); ok {
|
|
tst[i] = t.(IUnionParenthesisContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) UnionParenthesis(i int) IUnionParenthesisContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnionParenthesisContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnionParenthesisContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNION, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) QueryExpression() IQueryExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) LockClause() ILockClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockClauseContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnionParenthesisSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnionParenthesisSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionParenthesisSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnionParenthesisSelect(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SimpleSelectContext struct {
|
|
SelectStatementContext
|
|
}
|
|
|
|
func NewSimpleSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleSelectContext {
|
|
var p = new(SimpleSelectContext)
|
|
|
|
InitEmptySelectStatementContext(&p.SelectStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleSelectContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleSelectContext) QuerySpecification() IQuerySpecificationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationContext)
|
|
}
|
|
|
|
func (s *SimpleSelectContext) LockClause() ILockClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockClauseContext)
|
|
}
|
|
|
|
func (s *SimpleSelectContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleSelectContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleSelect(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ParenthesisSelectContext struct {
|
|
SelectStatementContext
|
|
}
|
|
|
|
func NewParenthesisSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesisSelectContext {
|
|
var p = new(ParenthesisSelectContext)
|
|
|
|
InitEmptySelectStatementContext(&p.SelectStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) QueryExpression() IQueryExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionContext)
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) LockClause() ILockClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockClauseContext)
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterParenthesisSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitParenthesisSelect(s)
|
|
}
|
|
}
|
|
|
|
func (s *ParenthesisSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitParenthesisSelect(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type WithLateralStatementContext struct {
|
|
SelectStatementContext
|
|
}
|
|
|
|
func NewWithLateralStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WithLateralStatementContext {
|
|
var p = new(WithLateralStatementContext)
|
|
|
|
InitEmptySelectStatementContext(&p.SelectStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationNointoContext)
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) AllLateralStatement() []ILateralStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ILateralStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ILateralStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ILateralStatementContext); ok {
|
|
tst[i] = t.(ILateralStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) LateralStatement(i int) ILateralStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILateralStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILateralStatementContext)
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWithLateralStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWithLateralStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithLateralStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWithLateralStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectStatement() (localctx ISelectStatementContext) {
|
|
localctx = NewSelectStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 200, MySqlParserRULE_selectStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(3476)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 476, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSimpleSelectContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3411)
|
|
p.QuerySpecification()
|
|
}
|
|
p.SetState(3413)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 459, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3412)
|
|
p.LockClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewParenthesisSelectContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3415)
|
|
p.QueryExpression()
|
|
}
|
|
p.SetState(3417)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3416)
|
|
p.LockClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewUnionSelectContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(3421)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT:
|
|
{
|
|
p.SetState(3419)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(3420)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(3424)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(3423)
|
|
p.UnionStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(3426)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 462, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3436)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUNION {
|
|
{
|
|
p.SetState(3428)
|
|
p.Match(MySqlParserUNION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3430)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALL || _la == MySqlParserDISTINCT {
|
|
{
|
|
p.SetState(3429)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UnionSelectContext).unionType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UnionSelectContext).unionType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3434)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT:
|
|
{
|
|
p.SetState(3432)
|
|
p.QuerySpecification()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(3433)
|
|
p.QueryExpression()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(3439)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3438)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3442)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3441)
|
|
p.LimitClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3445)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3444)
|
|
p.LockClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewUnionParenthesisSelectContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(3447)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
p.SetState(3449)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(3448)
|
|
p.UnionParenthesis()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(3451)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3458)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUNION {
|
|
{
|
|
p.SetState(3453)
|
|
p.Match(MySqlParserUNION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3455)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALL || _la == MySqlParserDISTINCT {
|
|
{
|
|
p.SetState(3454)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UnionParenthesisSelectContext).unionType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UnionParenthesisSelectContext).unionType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3457)
|
|
p.QueryExpression()
|
|
}
|
|
|
|
}
|
|
p.SetState(3461)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 472, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3460)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3464)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3463)
|
|
p.LimitClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3467)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3466)
|
|
p.LockClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewWithLateralStatementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(3469)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
p.SetState(3472)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3470)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3471)
|
|
p.LateralStatement()
|
|
}
|
|
|
|
p.SetState(3474)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUpdateStatementContext is an interface to support dynamic dispatch.
|
|
type IUpdateStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SingleUpdateStatement() ISingleUpdateStatementContext
|
|
MultipleUpdateStatement() IMultipleUpdateStatementContext
|
|
|
|
// IsUpdateStatementContext differentiates from other interfaces.
|
|
IsUpdateStatementContext()
|
|
}
|
|
|
|
type UpdateStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUpdateStatementContext() *UpdateStatementContext {
|
|
var p = new(UpdateStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_updateStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUpdateStatementContext(p *UpdateStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_updateStatement
|
|
}
|
|
|
|
func (*UpdateStatementContext) IsUpdateStatementContext() {}
|
|
|
|
func NewUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateStatementContext {
|
|
var p = new(UpdateStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_updateStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UpdateStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UpdateStatementContext) SingleUpdateStatement() ISingleUpdateStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISingleUpdateStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISingleUpdateStatementContext)
|
|
}
|
|
|
|
func (s *UpdateStatementContext) MultipleUpdateStatement() IMultipleUpdateStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMultipleUpdateStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMultipleUpdateStatementContext)
|
|
}
|
|
|
|
func (s *UpdateStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUpdateStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UpdateStatement() (localctx IUpdateStatementContext) {
|
|
localctx = NewUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 202, MySqlParserRULE_updateStatement)
|
|
p.SetState(3480)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 477, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3478)
|
|
p.SingleUpdateStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3479)
|
|
p.MultipleUpdateStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IValuesStatementContext is an interface to support dynamic dispatch.
|
|
type IValuesStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
VALUES() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext
|
|
ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsValuesStatementContext differentiates from other interfaces.
|
|
IsValuesStatementContext()
|
|
}
|
|
|
|
type ValuesStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyValuesStatementContext() *ValuesStatementContext {
|
|
var p = new(ValuesStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_valuesStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyValuesStatementContext(p *ValuesStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_valuesStatement
|
|
}
|
|
|
|
func (*ValuesStatementContext) IsValuesStatementContext() {}
|
|
|
|
func NewValuesStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValuesStatementContext {
|
|
var p = new(ValuesStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_valuesStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ValuesStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ValuesStatementContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionsWithDefaultsContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
tst[i] = t.(IExpressionsWithDefaultsContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ValuesStatementContext) ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionsWithDefaultsContext)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ValuesStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ValuesStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterValuesStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ValuesStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitValuesStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ValuesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitValuesStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ValuesStatement() (localctx IValuesStatementContext) {
|
|
localctx = NewValuesStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 204, MySqlParserRULE_valuesStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3482)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3483)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3485)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3484)
|
|
p.ExpressionsWithDefaults()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3487)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3496)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3488)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3489)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3491)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3490)
|
|
p.ExpressionsWithDefaults()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3493)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(3498)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IInsertStatementValueContext is an interface to support dynamic dispatch.
|
|
type IInsertStatementValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetInsertFormat returns the insertFormat token.
|
|
GetInsertFormat() antlr.Token
|
|
|
|
// SetInsertFormat sets the insertFormat token.
|
|
SetInsertFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
SelectStatement() ISelectStatementContext
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
VALUES() antlr.TerminalNode
|
|
VALUE() antlr.TerminalNode
|
|
AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext
|
|
ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsInsertStatementValueContext differentiates from other interfaces.
|
|
IsInsertStatementValueContext()
|
|
}
|
|
|
|
type InsertStatementValueContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
insertFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyInsertStatementValueContext() *InsertStatementValueContext {
|
|
var p = new(InsertStatementValueContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_insertStatementValue
|
|
return p
|
|
}
|
|
|
|
func InitEmptyInsertStatementValueContext(p *InsertStatementValueContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_insertStatementValue
|
|
}
|
|
|
|
func (*InsertStatementValueContext) IsInsertStatementValueContext() {}
|
|
|
|
func NewInsertStatementValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementValueContext {
|
|
var p = new(InsertStatementValueContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_insertStatementValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *InsertStatementValueContext) GetInsertFormat() antlr.Token { return s.insertFormat }
|
|
|
|
func (s *InsertStatementValueContext) SetInsertFormat(v antlr.Token) { s.insertFormat = v }
|
|
|
|
func (s *InsertStatementValueContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionsWithDefaultsContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
tst[i] = t.(IExpressionsWithDefaultsContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionsWithDefaultsContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionsWithDefaultsContext)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInsertStatementValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInsertStatementValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *InsertStatementValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInsertStatementValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) InsertStatementValue() (localctx IInsertStatementValueContext) {
|
|
localctx = NewInsertStatementValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 206, MySqlParserRULE_insertStatementValue)
|
|
var _la int
|
|
|
|
p.SetState(3517)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT, MySqlParserLR_BRACKET:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3499)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case MySqlParserVALUES, MySqlParserVALUE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3500)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*InsertStatementValueContext).insertFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserVALUES || _la == MySqlParserVALUE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*InsertStatementValueContext).insertFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3501)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3503)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3502)
|
|
p.ExpressionsWithDefaults()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3505)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3514)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3506)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3507)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3509)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3508)
|
|
p.ExpressionsWithDefaults()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3511)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(3516)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUpdatedElementContext is an interface to support dynamic dispatch.
|
|
type IUpdatedElementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FullColumnName() IFullColumnNameContext
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
DEFAULT() antlr.TerminalNode
|
|
|
|
// IsUpdatedElementContext differentiates from other interfaces.
|
|
IsUpdatedElementContext()
|
|
}
|
|
|
|
type UpdatedElementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUpdatedElementContext() *UpdatedElementContext {
|
|
var p = new(UpdatedElementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_updatedElement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUpdatedElementContext(p *UpdatedElementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_updatedElement
|
|
}
|
|
|
|
func (*UpdatedElementContext) IsUpdatedElementContext() {}
|
|
|
|
func NewUpdatedElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatedElementContext {
|
|
var p = new(UpdatedElementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_updatedElement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UpdatedElementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UpdatedElementContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *UpdatedElementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *UpdatedElementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *UpdatedElementContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *UpdatedElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UpdatedElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UpdatedElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUpdatedElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UpdatedElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUpdatedElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UpdatedElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUpdatedElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UpdatedElement() (localctx IUpdatedElementContext) {
|
|
localctx = NewUpdatedElementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 208, MySqlParserRULE_updatedElement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3519)
|
|
p.FullColumnName()
|
|
}
|
|
{
|
|
p.SetState(3520)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3523)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(3521)
|
|
p.expression(0)
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(3522)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAssignmentFieldContext is an interface to support dynamic dispatch.
|
|
type IAssignmentFieldContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
LOCAL_ID() antlr.TerminalNode
|
|
|
|
// IsAssignmentFieldContext differentiates from other interfaces.
|
|
IsAssignmentFieldContext()
|
|
}
|
|
|
|
type AssignmentFieldContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAssignmentFieldContext() *AssignmentFieldContext {
|
|
var p = new(AssignmentFieldContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_assignmentField
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAssignmentFieldContext(p *AssignmentFieldContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_assignmentField
|
|
}
|
|
|
|
func (*AssignmentFieldContext) IsAssignmentFieldContext() {}
|
|
|
|
func NewAssignmentFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentFieldContext {
|
|
var p = new(AssignmentFieldContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_assignmentField
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AssignmentFieldContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAssignmentField(s)
|
|
}
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAssignmentField(s)
|
|
}
|
|
}
|
|
|
|
func (s *AssignmentFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAssignmentField(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AssignmentField() (localctx IAssignmentFieldContext) {
|
|
localctx = NewAssignmentFieldContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 210, MySqlParserRULE_assignmentField)
|
|
p.SetState(3527)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3525)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserLOCAL_ID:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3526)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILockClauseContext is an interface to support dynamic dispatch.
|
|
type ILockClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FOR() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
LOCK() antlr.TerminalNode
|
|
IN() antlr.TerminalNode
|
|
SHARE() antlr.TerminalNode
|
|
MODE() antlr.TerminalNode
|
|
|
|
// IsLockClauseContext differentiates from other interfaces.
|
|
IsLockClauseContext()
|
|
}
|
|
|
|
type LockClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLockClauseContext() *LockClauseContext {
|
|
var p = new(LockClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLockClauseContext(p *LockClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockClause
|
|
}
|
|
|
|
func (*LockClauseContext) IsLockClauseContext() {}
|
|
|
|
func NewLockClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockClauseContext {
|
|
var p = new(LockClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lockClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LockClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LockClauseContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) SHARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARE, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) MODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODE, 0)
|
|
}
|
|
|
|
func (s *LockClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LockClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LockClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLockClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLockClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLockClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LockClause() (localctx ILockClauseContext) {
|
|
localctx = NewLockClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 212, MySqlParserRULE_lockClause)
|
|
p.SetState(3535)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFOR:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3529)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3530)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCK:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3531)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3532)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3533)
|
|
p.Match(MySqlParserSHARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3534)
|
|
p.Match(MySqlParserMODE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISingleDeleteStatementContext is an interface to support dynamic dispatch.
|
|
type ISingleDeleteStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DELETE() antlr.TerminalNode
|
|
FROM() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
QUICK() antlr.TerminalNode
|
|
IGNORE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
PARTITION() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
OrderByClause() IOrderByClauseContext
|
|
LIMIT() antlr.TerminalNode
|
|
LimitClauseAtom() ILimitClauseAtomContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsSingleDeleteStatementContext differentiates from other interfaces.
|
|
IsSingleDeleteStatementContext()
|
|
}
|
|
|
|
type SingleDeleteStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
}
|
|
|
|
func NewEmptySingleDeleteStatementContext() *SingleDeleteStatementContext {
|
|
var p = new(SingleDeleteStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_singleDeleteStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySingleDeleteStatementContext(p *SingleDeleteStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_singleDeleteStatement
|
|
}
|
|
|
|
func (*SingleDeleteStatementContext) IsSingleDeleteStatementContext() {}
|
|
|
|
func NewSingleDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleDeleteStatementContext {
|
|
var p = new(SingleDeleteStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_singleDeleteStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SingleDeleteStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *SingleDeleteStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *SingleDeleteStatementContext) DELETE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELETE, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) LimitClauseAtom() ILimitClauseAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseAtomContext)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSingleDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSingleDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SingleDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSingleDeleteStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SingleDeleteStatement() (localctx ISingleDeleteStatementContext) {
|
|
localctx = NewSingleDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 214, MySqlParserRULE_singleDeleteStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3537)
|
|
p.Match(MySqlParserDELETE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3539)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(3538)
|
|
|
|
var _m = p.Match(MySqlParserLOW_PRIORITY)
|
|
|
|
localctx.(*SingleDeleteStatementContext).priority = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3542)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserQUICK {
|
|
{
|
|
p.SetState(3541)
|
|
p.Match(MySqlParserQUICK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3545)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3544)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3547)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3548)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3553)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 492, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(3550)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3549)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3552)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3560)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(3555)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3556)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3557)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(3558)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3564)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3562)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3563)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(3567)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserORDER {
|
|
{
|
|
p.SetState(3566)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3571)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3569)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3570)
|
|
p.LimitClauseAtom()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IMultipleDeleteStatementContext is an interface to support dynamic dispatch.
|
|
type IMultipleDeleteStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DELETE() antlr.TerminalNode
|
|
AllTableName() []ITableNameContext
|
|
TableName(i int) ITableNameContext
|
|
FROM() antlr.TerminalNode
|
|
TableSources() ITableSourcesContext
|
|
USING() antlr.TerminalNode
|
|
QUICK() antlr.TerminalNode
|
|
IGNORE() antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
AllDOT() []antlr.TerminalNode
|
|
DOT(i int) antlr.TerminalNode
|
|
AllSTAR() []antlr.TerminalNode
|
|
STAR(i int) antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsMultipleDeleteStatementContext differentiates from other interfaces.
|
|
IsMultipleDeleteStatementContext()
|
|
}
|
|
|
|
type MultipleDeleteStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
}
|
|
|
|
func NewEmptyMultipleDeleteStatementContext() *MultipleDeleteStatementContext {
|
|
var p = new(MultipleDeleteStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multipleDeleteStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyMultipleDeleteStatementContext(p *MultipleDeleteStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multipleDeleteStatement
|
|
}
|
|
|
|
func (*MultipleDeleteStatementContext) IsMultipleDeleteStatementContext() {}
|
|
|
|
func NewMultipleDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipleDeleteStatementContext {
|
|
var p = new(MultipleDeleteStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_multipleDeleteStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *MultipleDeleteStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *MultipleDeleteStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *MultipleDeleteStatementContext) DELETE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELETE, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) AllTableName() []ITableNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableNameContext); ok {
|
|
tst[i] = t.(ITableNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) TableName(i int) ITableNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) TableSources() ITableSourcesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourcesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourcesContext)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) AllDOT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserDOT)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) DOT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, i)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) AllSTAR() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTAR)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) STAR(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, i)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMultipleDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMultipleDeleteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultipleDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMultipleDeleteStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) MultipleDeleteStatement() (localctx IMultipleDeleteStatementContext) {
|
|
localctx = NewMultipleDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 216, MySqlParserRULE_multipleDeleteStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3573)
|
|
p.Match(MySqlParserDELETE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3575)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(3574)
|
|
|
|
var _m = p.Match(MySqlParserLOW_PRIORITY)
|
|
|
|
localctx.(*MultipleDeleteStatementContext).priority = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3578)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 498, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3577)
|
|
p.Match(MySqlParserQUICK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3581)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3580)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3622)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(3583)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3586)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDOT {
|
|
{
|
|
p.SetState(3584)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3585)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3596)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3588)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3589)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3592)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDOT {
|
|
{
|
|
p.SetState(3590)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3591)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
p.SetState(3598)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(3599)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3600)
|
|
p.TableSources()
|
|
}
|
|
|
|
case MySqlParserFROM:
|
|
{
|
|
p.SetState(3602)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3603)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3606)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDOT {
|
|
{
|
|
p.SetState(3604)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3605)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3616)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3608)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3609)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3612)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDOT {
|
|
{
|
|
p.SetState(3610)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3611)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
p.SetState(3618)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(3619)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3620)
|
|
p.TableSources()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(3626)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3624)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3625)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerOpenStatementContext is an interface to support dynamic dispatch.
|
|
type IHandlerOpenStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HANDLER() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
OPEN() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsHandlerOpenStatementContext differentiates from other interfaces.
|
|
IsHandlerOpenStatementContext()
|
|
}
|
|
|
|
type HandlerOpenStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHandlerOpenStatementContext() *HandlerOpenStatementContext {
|
|
var p = new(HandlerOpenStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerOpenStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerOpenStatementContext(p *HandlerOpenStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerOpenStatement
|
|
}
|
|
|
|
func (*HandlerOpenStatementContext) IsHandlerOpenStatementContext() {}
|
|
|
|
func NewHandlerOpenStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerOpenStatementContext {
|
|
var p = new(HandlerOpenStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerOpenStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerOpenStatementContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) OPEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPEN, 0)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerOpenStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerOpenStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerOpenStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerOpenStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerOpenStatement() (localctx IHandlerOpenStatementContext) {
|
|
localctx = NewHandlerOpenStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 218, MySqlParserRULE_handlerOpenStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3628)
|
|
p.Match(MySqlParserHANDLER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3629)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(3630)
|
|
p.Match(MySqlParserOPEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3635)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 509, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(3632)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3631)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3634)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerReadIndexStatementContext is an interface to support dynamic dispatch.
|
|
type IHandlerReadIndexStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetMoveOrder returns the moveOrder token.
|
|
GetMoveOrder() antlr.Token
|
|
|
|
// SetMoveOrder sets the moveOrder token.
|
|
SetMoveOrder(antlr.Token)
|
|
|
|
// GetIndex returns the index rule contexts.
|
|
GetIndex() IUidContext
|
|
|
|
// SetIndex sets the index rule contexts.
|
|
SetIndex(IUidContext)
|
|
|
|
// Getter signatures
|
|
HANDLER() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
READ() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
ComparisonOperator() IComparisonOperatorContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
Constants() IConstantsContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
LIMIT() antlr.TerminalNode
|
|
LimitClauseAtom() ILimitClauseAtomContext
|
|
FIRST() antlr.TerminalNode
|
|
NEXT() antlr.TerminalNode
|
|
PREV() antlr.TerminalNode
|
|
LAST() antlr.TerminalNode
|
|
|
|
// IsHandlerReadIndexStatementContext differentiates from other interfaces.
|
|
IsHandlerReadIndexStatementContext()
|
|
}
|
|
|
|
type HandlerReadIndexStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
index IUidContext
|
|
moveOrder antlr.Token
|
|
}
|
|
|
|
func NewEmptyHandlerReadIndexStatementContext() *HandlerReadIndexStatementContext {
|
|
var p = new(HandlerReadIndexStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerReadIndexStatementContext(p *HandlerReadIndexStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement
|
|
}
|
|
|
|
func (*HandlerReadIndexStatementContext) IsHandlerReadIndexStatementContext() {}
|
|
|
|
func NewHandlerReadIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerReadIndexStatementContext {
|
|
var p = new(HandlerReadIndexStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerReadIndexStatementContext) GetMoveOrder() antlr.Token { return s.moveOrder }
|
|
|
|
func (s *HandlerReadIndexStatementContext) SetMoveOrder(v antlr.Token) { s.moveOrder = v }
|
|
|
|
func (s *HandlerReadIndexStatementContext) GetIndex() IUidContext { return s.index }
|
|
|
|
func (s *HandlerReadIndexStatementContext) SetIndex(v IUidContext) { s.index = v }
|
|
|
|
func (s *HandlerReadIndexStatementContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) ComparisonOperator() IComparisonOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IComparisonOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IComparisonOperatorContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) Constants() IConstantsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantsContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) LimitClauseAtom() ILimitClauseAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseAtomContext)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) NEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEXT, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) PREV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREV, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) LAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST, 0)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerReadIndexStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerReadIndexStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerReadIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerReadIndexStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerReadIndexStatement() (localctx IHandlerReadIndexStatementContext) {
|
|
localctx = NewHandlerReadIndexStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 220, MySqlParserRULE_handlerReadIndexStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3637)
|
|
p.Match(MySqlParserHANDLER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3638)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(3639)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3640)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*HandlerReadIndexStatementContext).index = _x
|
|
}
|
|
p.SetState(3647)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserEQUAL_SYMBOL, MySqlParserGREATER_SYMBOL, MySqlParserLESS_SYMBOL, MySqlParserEXCLAMATION_SYMBOL:
|
|
{
|
|
p.SetState(3641)
|
|
p.ComparisonOperator()
|
|
}
|
|
{
|
|
p.SetState(3642)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3643)
|
|
p.Constants()
|
|
}
|
|
{
|
|
p.SetState(3644)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFIRST, MySqlParserLAST, MySqlParserNEXT, MySqlParserPREV:
|
|
{
|
|
p.SetState(3646)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*HandlerReadIndexStatementContext).moveOrder = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFIRST || _la == MySqlParserLAST || _la == MySqlParserNEXT || _la == MySqlParserPREV) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*HandlerReadIndexStatementContext).moveOrder = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(3651)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3649)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3650)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(3655)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3653)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3654)
|
|
p.LimitClauseAtom()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerReadStatementContext is an interface to support dynamic dispatch.
|
|
type IHandlerReadStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetMoveOrder returns the moveOrder token.
|
|
GetMoveOrder() antlr.Token
|
|
|
|
// SetMoveOrder sets the moveOrder token.
|
|
SetMoveOrder(antlr.Token)
|
|
|
|
// Getter signatures
|
|
HANDLER() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
READ() antlr.TerminalNode
|
|
FIRST() antlr.TerminalNode
|
|
NEXT() antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
LIMIT() antlr.TerminalNode
|
|
LimitClauseAtom() ILimitClauseAtomContext
|
|
|
|
// IsHandlerReadStatementContext differentiates from other interfaces.
|
|
IsHandlerReadStatementContext()
|
|
}
|
|
|
|
type HandlerReadStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
moveOrder antlr.Token
|
|
}
|
|
|
|
func NewEmptyHandlerReadStatementContext() *HandlerReadStatementContext {
|
|
var p = new(HandlerReadStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerReadStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerReadStatementContext(p *HandlerReadStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerReadStatement
|
|
}
|
|
|
|
func (*HandlerReadStatementContext) IsHandlerReadStatementContext() {}
|
|
|
|
func NewHandlerReadStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerReadStatementContext {
|
|
var p = new(HandlerReadStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerReadStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerReadStatementContext) GetMoveOrder() antlr.Token { return s.moveOrder }
|
|
|
|
func (s *HandlerReadStatementContext) SetMoveOrder(v antlr.Token) { s.moveOrder = v }
|
|
|
|
func (s *HandlerReadStatementContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) NEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEXT, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) LimitClauseAtom() ILimitClauseAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseAtomContext)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerReadStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerReadStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerReadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerReadStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerReadStatement() (localctx IHandlerReadStatementContext) {
|
|
localctx = NewHandlerReadStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 222, MySqlParserRULE_handlerReadStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3657)
|
|
p.Match(MySqlParserHANDLER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3658)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(3659)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3660)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*HandlerReadStatementContext).moveOrder = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFIRST || _la == MySqlParserNEXT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*HandlerReadStatementContext).moveOrder = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(3663)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3661)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3662)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(3667)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3665)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3666)
|
|
p.LimitClauseAtom()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerCloseStatementContext is an interface to support dynamic dispatch.
|
|
type IHandlerCloseStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HANDLER() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
CLOSE() antlr.TerminalNode
|
|
|
|
// IsHandlerCloseStatementContext differentiates from other interfaces.
|
|
IsHandlerCloseStatementContext()
|
|
}
|
|
|
|
type HandlerCloseStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHandlerCloseStatementContext() *HandlerCloseStatementContext {
|
|
var p = new(HandlerCloseStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerCloseStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerCloseStatementContext(p *HandlerCloseStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerCloseStatement
|
|
}
|
|
|
|
func (*HandlerCloseStatementContext) IsHandlerCloseStatementContext() {}
|
|
|
|
func NewHandlerCloseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerCloseStatementContext {
|
|
var p = new(HandlerCloseStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerCloseStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerCloseStatementContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) CLOSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLOSE, 0)
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerCloseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerCloseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerCloseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerCloseStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerCloseStatement() (localctx IHandlerCloseStatementContext) {
|
|
localctx = NewHandlerCloseStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 224, MySqlParserRULE_handlerCloseStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3669)
|
|
p.Match(MySqlParserHANDLER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3670)
|
|
p.TableName()
|
|
}
|
|
{
|
|
p.SetState(3671)
|
|
p.Match(MySqlParserCLOSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISingleUpdateStatementContext is an interface to support dynamic dispatch.
|
|
type ISingleUpdateStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// Getter signatures
|
|
UPDATE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
SET() antlr.TerminalNode
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
IGNORE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
OrderByClause() IOrderByClauseContext
|
|
LimitClause() ILimitClauseContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsSingleUpdateStatementContext differentiates from other interfaces.
|
|
IsSingleUpdateStatementContext()
|
|
}
|
|
|
|
type SingleUpdateStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
}
|
|
|
|
func NewEmptySingleUpdateStatementContext() *SingleUpdateStatementContext {
|
|
var p = new(SingleUpdateStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_singleUpdateStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySingleUpdateStatementContext(p *SingleUpdateStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_singleUpdateStatement
|
|
}
|
|
|
|
func (*SingleUpdateStatementContext) IsSingleUpdateStatementContext() {}
|
|
|
|
func NewSingleUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleUpdateStatementContext {
|
|
var p = new(SingleUpdateStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_singleUpdateStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SingleUpdateStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *SingleUpdateStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *SingleUpdateStatementContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSingleUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSingleUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SingleUpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSingleUpdateStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SingleUpdateStatement() (localctx ISingleUpdateStatementContext) {
|
|
localctx = NewSingleUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 226, MySqlParserRULE_singleUpdateStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3673)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3675)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(3674)
|
|
|
|
var _m = p.Match(MySqlParserLOW_PRIORITY)
|
|
|
|
localctx.(*SingleUpdateStatementContext).priority = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3678)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3677)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3680)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3685)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513126400) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
p.SetState(3682)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3681)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3684)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3687)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3688)
|
|
p.UpdatedElement()
|
|
}
|
|
p.SetState(3693)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3689)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3690)
|
|
p.UpdatedElement()
|
|
}
|
|
|
|
p.SetState(3695)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(3698)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3696)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3697)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(3701)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserORDER {
|
|
{
|
|
p.SetState(3700)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3704)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(3703)
|
|
p.LimitClause()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IMultipleUpdateStatementContext is an interface to support dynamic dispatch.
|
|
type IMultipleUpdateStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPriority returns the priority token.
|
|
GetPriority() antlr.Token
|
|
|
|
// SetPriority sets the priority token.
|
|
SetPriority(antlr.Token)
|
|
|
|
// Getter signatures
|
|
UPDATE() antlr.TerminalNode
|
|
TableSources() ITableSourcesContext
|
|
SET() antlr.TerminalNode
|
|
AllUpdatedElement() []IUpdatedElementContext
|
|
UpdatedElement(i int) IUpdatedElementContext
|
|
IGNORE() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
|
|
// IsMultipleUpdateStatementContext differentiates from other interfaces.
|
|
IsMultipleUpdateStatementContext()
|
|
}
|
|
|
|
type MultipleUpdateStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
priority antlr.Token
|
|
}
|
|
|
|
func NewEmptyMultipleUpdateStatementContext() *MultipleUpdateStatementContext {
|
|
var p = new(MultipleUpdateStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multipleUpdateStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyMultipleUpdateStatementContext(p *MultipleUpdateStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multipleUpdateStatement
|
|
}
|
|
|
|
func (*MultipleUpdateStatementContext) IsMultipleUpdateStatementContext() {}
|
|
|
|
func NewMultipleUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipleUpdateStatementContext {
|
|
var p = new(MultipleUpdateStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_multipleUpdateStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *MultipleUpdateStatementContext) GetPriority() antlr.Token { return s.priority }
|
|
|
|
func (s *MultipleUpdateStatementContext) SetPriority(v antlr.Token) { s.priority = v }
|
|
|
|
func (s *MultipleUpdateStatementContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) TableSources() ITableSourcesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourcesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourcesContext)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) AllUpdatedElement() []IUpdatedElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUpdatedElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUpdatedElementContext); ok {
|
|
tst[i] = t.(IUpdatedElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) UpdatedElement(i int) IUpdatedElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdatedElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdatedElementContext)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMultipleUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMultipleUpdateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultipleUpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMultipleUpdateStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) MultipleUpdateStatement() (localctx IMultipleUpdateStatementContext) {
|
|
localctx = NewMultipleUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 228, MySqlParserRULE_multipleUpdateStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3706)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3708)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(3707)
|
|
|
|
var _m = p.Match(MySqlParserLOW_PRIORITY)
|
|
|
|
localctx.(*MultipleUpdateStatementContext).priority = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3711)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(3710)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3713)
|
|
p.TableSources()
|
|
}
|
|
{
|
|
p.SetState(3714)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3715)
|
|
p.UpdatedElement()
|
|
}
|
|
p.SetState(3720)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(3716)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3717)
|
|
p.UpdatedElement()
|
|
}
|
|
|
|
p.SetState(3722)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(3725)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(3723)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3724)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOrderByClauseContext is an interface to support dynamic dispatch.
|
|
type IOrderByClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ORDER() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
AllOrderByExpression() []IOrderByExpressionContext
|
|
OrderByExpression(i int) IOrderByExpressionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsOrderByClauseContext differentiates from other interfaces.
|
|
IsOrderByClauseContext()
|
|
}
|
|
|
|
type OrderByClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyOrderByClauseContext() *OrderByClauseContext {
|
|
var p = new(OrderByClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orderByClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOrderByClauseContext(p *OrderByClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orderByClause
|
|
}
|
|
|
|
func (*OrderByClauseContext) IsOrderByClauseContext() {}
|
|
|
|
func NewOrderByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByClauseContext {
|
|
var p = new(OrderByClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_orderByClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OrderByClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OrderByClauseContext) ORDER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDER, 0)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) AllOrderByExpression() []IOrderByExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IOrderByExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IOrderByExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IOrderByExpressionContext); ok {
|
|
tst[i] = t.(IOrderByExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *OrderByClauseContext) OrderByExpression(i int) IOrderByExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByExpressionContext)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OrderByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OrderByClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOrderByClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrderByClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOrderByClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrderByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOrderByClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OrderByClause() (localctx IOrderByClauseContext) {
|
|
localctx = NewOrderByClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 230, MySqlParserRULE_orderByClause)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3727)
|
|
p.Match(MySqlParserORDER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3728)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3729)
|
|
p.OrderByExpression()
|
|
}
|
|
p.SetState(3734)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3730)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3731)
|
|
p.OrderByExpression()
|
|
}
|
|
|
|
}
|
|
p.SetState(3736)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOrderByExpressionContext is an interface to support dynamic dispatch.
|
|
type IOrderByExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOrder returns the order token.
|
|
GetOrder() antlr.Token
|
|
|
|
// SetOrder sets the order token.
|
|
SetOrder(antlr.Token)
|
|
|
|
// Getter signatures
|
|
Expression() IExpressionContext
|
|
ASC() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
|
|
// IsOrderByExpressionContext differentiates from other interfaces.
|
|
IsOrderByExpressionContext()
|
|
}
|
|
|
|
type OrderByExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
order antlr.Token
|
|
}
|
|
|
|
func NewEmptyOrderByExpressionContext() *OrderByExpressionContext {
|
|
var p = new(OrderByExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orderByExpression
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOrderByExpressionContext(p *OrderByExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orderByExpression
|
|
}
|
|
|
|
func (*OrderByExpressionContext) IsOrderByExpressionContext() {}
|
|
|
|
func NewOrderByExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByExpressionContext {
|
|
var p = new(OrderByExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_orderByExpression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OrderByExpressionContext) GetOrder() antlr.Token { return s.order }
|
|
|
|
func (s *OrderByExpressionContext) SetOrder(v antlr.Token) { s.order = v }
|
|
|
|
func (s *OrderByExpressionContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) ASC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASC, 0)
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOrderByExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOrderByExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrderByExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOrderByExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OrderByExpression() (localctx IOrderByExpressionContext) {
|
|
localctx = NewOrderByExpressionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 232, MySqlParserRULE_orderByExpression)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3737)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(3739)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3738)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*OrderByExpressionContext).order = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserASC || _la == MySqlParserDESC) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*OrderByExpressionContext).order = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableSourcesContext is an interface to support dynamic dispatch.
|
|
type ITableSourcesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllTableSource() []ITableSourceContext
|
|
TableSource(i int) ITableSourceContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsTableSourcesContext differentiates from other interfaces.
|
|
IsTableSourcesContext()
|
|
}
|
|
|
|
type TableSourcesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableSourcesContext() *TableSourcesContext {
|
|
var p = new(TableSourcesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSources
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableSourcesContext(p *TableSourcesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSources
|
|
}
|
|
|
|
func (*TableSourcesContext) IsTableSourcesContext() {}
|
|
|
|
func NewTableSourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourcesContext {
|
|
var p = new(TableSourcesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableSources
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourcesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableSourcesContext) AllTableSource() []ITableSourceContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableSourceContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableSourceContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableSourceContext); ok {
|
|
tst[i] = t.(ITableSourceContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TableSourcesContext) TableSource(i int) ITableSourceContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceContext)
|
|
}
|
|
|
|
func (s *TableSourcesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *TableSourcesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *TableSourcesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TableSourcesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableSources(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourcesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableSources(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableSources(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableSources() (localctx ITableSourcesContext) {
|
|
localctx = NewTableSourcesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 234, MySqlParserRULE_tableSources)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3741)
|
|
p.TableSource()
|
|
}
|
|
p.SetState(3746)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3742)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3743)
|
|
p.TableSource()
|
|
}
|
|
|
|
}
|
|
p.SetState(3748)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableSourceContext is an interface to support dynamic dispatch.
|
|
type ITableSourceContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsTableSourceContext differentiates from other interfaces.
|
|
IsTableSourceContext()
|
|
}
|
|
|
|
type TableSourceContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableSourceContext() *TableSourceContext {
|
|
var p = new(TableSourceContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSource
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableSourceContext(p *TableSourceContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSource
|
|
}
|
|
|
|
func (*TableSourceContext) IsTableSourceContext() {}
|
|
|
|
func NewTableSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceContext {
|
|
var p = new(TableSourceContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableSource
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourceContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableSourceContext) CopyAll(ctx *TableSourceContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *TableSourceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type TableJsonContext struct {
|
|
TableSourceContext
|
|
}
|
|
|
|
func NewTableJsonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableJsonContext {
|
|
var p = new(TableJsonContext)
|
|
|
|
InitEmptyTableSourceContext(&p.TableSourceContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableJsonContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableJsonContext) JsonTable() IJsonTableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonTableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonTableContext)
|
|
}
|
|
|
|
func (s *TableJsonContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableJson(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableJsonContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableJson(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableJsonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableJson(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableSourceNestedContext struct {
|
|
TableSourceContext
|
|
}
|
|
|
|
func NewTableSourceNestedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourceNestedContext {
|
|
var p = new(TableSourceNestedContext)
|
|
|
|
InitEmptyTableSourceContext(&p.TableSourceContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) AllJoinPart() []IJoinPartContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IJoinPartContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IJoinPartContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IJoinPartContext); ok {
|
|
tst[i] = t.(IJoinPartContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) JoinPart(i int) IJoinPartContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJoinPartContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJoinPartContext)
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableSourceNested(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableSourceNested(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourceNestedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableSourceNested(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableSourceBaseContext struct {
|
|
TableSourceContext
|
|
}
|
|
|
|
func NewTableSourceBaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourceBaseContext {
|
|
var p = new(TableSourceBaseContext)
|
|
|
|
InitEmptyTableSourceContext(&p.TableSourceContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) AllJoinPart() []IJoinPartContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IJoinPartContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IJoinPartContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IJoinPartContext); ok {
|
|
tst[i] = t.(IJoinPartContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) JoinPart(i int) IJoinPartContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJoinPartContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJoinPartContext)
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableSourceBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableSourceBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourceBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableSourceBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableSource() (localctx ITableSourceContext) {
|
|
localctx = NewTableSourceContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 236, MySqlParserRULE_tableSource)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(3767)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 532, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewTableSourceBaseContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3749)
|
|
p.TableSourceItem()
|
|
}
|
|
p.SetState(3753)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3750)
|
|
p.JoinPart()
|
|
}
|
|
|
|
}
|
|
p.SetState(3755)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewTableSourceNestedContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3756)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3757)
|
|
p.TableSourceItem()
|
|
}
|
|
p.SetState(3761)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ((int64((_la-34)) & ^0x3f) == 0 && ((int64(1)<<(_la-34))&-9150751492863426559) != 0) || ((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&288230410511450113) != 0) {
|
|
{
|
|
p.SetState(3758)
|
|
p.JoinPart()
|
|
}
|
|
|
|
p.SetState(3763)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(3764)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewTableJsonContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(3766)
|
|
p.JsonTable()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableSourceItemContext is an interface to support dynamic dispatch.
|
|
type ITableSourceItemContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsTableSourceItemContext differentiates from other interfaces.
|
|
IsTableSourceItemContext()
|
|
}
|
|
|
|
type TableSourceItemContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableSourceItemContext() *TableSourceItemContext {
|
|
var p = new(TableSourceItemContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSourceItem
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableSourceItemContext(p *TableSourceItemContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableSourceItem
|
|
}
|
|
|
|
func (*TableSourceItemContext) IsTableSourceItemContext() {}
|
|
|
|
func NewTableSourceItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceItemContext {
|
|
var p = new(TableSourceItemContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableSourceItem
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourceItemContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableSourceItemContext) CopyAll(ctx *TableSourceItemContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *TableSourceItemContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourceItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SubqueryTableItemContext struct {
|
|
TableSourceItemContext
|
|
parenthesisSubquery ISelectStatementContext
|
|
alias IUidContext
|
|
}
|
|
|
|
func NewSubqueryTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryTableItemContext {
|
|
var p = new(SubqueryTableItemContext)
|
|
|
|
InitEmptyTableSourceItemContext(&p.TableSourceItemContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceItemContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) GetParenthesisSubquery() ISelectStatementContext {
|
|
return s.parenthesisSubquery
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) GetAlias() IUidContext { return s.alias }
|
|
|
|
func (s *SubqueryTableItemContext) SetParenthesisSubquery(v ISelectStatementContext) {
|
|
s.parenthesisSubquery = v
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) SetAlias(v IUidContext) { s.alias = v }
|
|
|
|
func (s *SubqueryTableItemContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubqueryTableItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubqueryTableItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubqueryTableItem(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AtomTableItemContext struct {
|
|
TableSourceItemContext
|
|
alias IUidContext
|
|
}
|
|
|
|
func NewAtomTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AtomTableItemContext {
|
|
var p = new(AtomTableItemContext)
|
|
|
|
InitEmptyTableSourceItemContext(&p.TableSourceItemContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceItemContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AtomTableItemContext) GetAlias() IUidContext { return s.alias }
|
|
|
|
func (s *AtomTableItemContext) SetAlias(v IUidContext) { s.alias = v }
|
|
|
|
func (s *AtomTableItemContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AtomTableItemContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) AllIndexHint() []IIndexHintContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexHintContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexHintContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexHintContext); ok {
|
|
tst[i] = t.(IIndexHintContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AtomTableItemContext) IndexHint(i int) IIndexHintContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexHintContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexHintContext)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AtomTableItemContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAtomTableItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *AtomTableItemContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAtomTableItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *AtomTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAtomTableItem(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TableSourcesItemContext struct {
|
|
TableSourceItemContext
|
|
}
|
|
|
|
func NewTableSourcesItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourcesItemContext {
|
|
var p = new(TableSourcesItemContext)
|
|
|
|
InitEmptyTableSourceItemContext(&p.TableSourceItemContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*TableSourceItemContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) TableSources() ITableSourcesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourcesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourcesContext)
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableSourcesItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableSourcesItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableSourcesItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableSourcesItem(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableSourceItem() (localctx ITableSourceItemContext) {
|
|
localctx = NewTableSourceItemContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 238, MySqlParserRULE_tableSourceItem)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(3809)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewAtomTableItemContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3769)
|
|
p.TableName()
|
|
}
|
|
p.SetState(3775)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(3770)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3771)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3772)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(3773)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(3781)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(3778)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3777)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3780)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*AtomTableItemContext).alias = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3791)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 537, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3783)
|
|
p.IndexHint()
|
|
}
|
|
p.SetState(3788)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3784)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3785)
|
|
p.IndexHint()
|
|
}
|
|
|
|
}
|
|
p.SetState(3790)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewSubqueryTableItemContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(3798)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(3793)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(3794)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3795)
|
|
|
|
var _x = p.SelectStatement()
|
|
|
|
localctx.(*SubqueryTableItemContext).parenthesisSubquery = _x
|
|
}
|
|
{
|
|
p.SetState(3796)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(3801)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(3800)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3803)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*SubqueryTableItemContext).alias = _x
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewTableSourcesItemContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(3805)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3806)
|
|
p.TableSources()
|
|
}
|
|
{
|
|
p.SetState(3807)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexHintContext is an interface to support dynamic dispatch.
|
|
type IIndexHintContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIndexHintAction returns the indexHintAction token.
|
|
GetIndexHintAction() antlr.Token
|
|
|
|
// GetKeyFormat returns the keyFormat token.
|
|
GetKeyFormat() antlr.Token
|
|
|
|
// SetIndexHintAction sets the indexHintAction token.
|
|
SetIndexHintAction(antlr.Token)
|
|
|
|
// SetKeyFormat sets the keyFormat token.
|
|
SetKeyFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
USE() antlr.TerminalNode
|
|
IGNORE() antlr.TerminalNode
|
|
FORCE() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
KEY() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
IndexHintType() IIndexHintTypeContext
|
|
|
|
// IsIndexHintContext differentiates from other interfaces.
|
|
IsIndexHintContext()
|
|
}
|
|
|
|
type IndexHintContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
indexHintAction antlr.Token
|
|
keyFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyIndexHintContext() *IndexHintContext {
|
|
var p = new(IndexHintContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexHint
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexHintContext(p *IndexHintContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexHint
|
|
}
|
|
|
|
func (*IndexHintContext) IsIndexHintContext() {}
|
|
|
|
func NewIndexHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintContext {
|
|
var p = new(IndexHintContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexHint
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexHintContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexHintContext) GetIndexHintAction() antlr.Token { return s.indexHintAction }
|
|
|
|
func (s *IndexHintContext) GetKeyFormat() antlr.Token { return s.keyFormat }
|
|
|
|
func (s *IndexHintContext) SetIndexHintAction(v antlr.Token) { s.indexHintAction = v }
|
|
|
|
func (s *IndexHintContext) SetKeyFormat(v antlr.Token) { s.keyFormat = v }
|
|
|
|
func (s *IndexHintContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *IndexHintContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) USE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSE, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) FORCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFORCE, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *IndexHintContext) IndexHintType() IIndexHintTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexHintTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexHintTypeContext)
|
|
}
|
|
|
|
func (s *IndexHintContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexHintContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexHint(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexHintContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexHint(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexHint(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexHint() (localctx IIndexHintContext) {
|
|
localctx = NewIndexHintContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 240, MySqlParserRULE_indexHint)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3811)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*IndexHintContext).indexHintAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFORCE || _la == MySqlParserIGNORE || _la == MySqlParserUSE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*IndexHintContext).indexHintAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3812)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*IndexHintContext).keyFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*IndexHintContext).keyFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(3815)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(3813)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3814)
|
|
p.IndexHintType()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3817)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3818)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(3819)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexHintTypeContext is an interface to support dynamic dispatch.
|
|
type IIndexHintTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
JOIN() antlr.TerminalNode
|
|
ORDER() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
|
|
// IsIndexHintTypeContext differentiates from other interfaces.
|
|
IsIndexHintTypeContext()
|
|
}
|
|
|
|
type IndexHintTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIndexHintTypeContext() *IndexHintTypeContext {
|
|
var p = new(IndexHintTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexHintType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexHintTypeContext(p *IndexHintTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexHintType
|
|
}
|
|
|
|
func (*IndexHintTypeContext) IsIndexHintTypeContext() {}
|
|
|
|
func NewIndexHintTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintTypeContext {
|
|
var p = new(IndexHintTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexHintType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexHintTypeContext) JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJOIN, 0)
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) ORDER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDER, 0)
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexHintType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexHintType(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexHintTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexHintType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexHintType() (localctx IIndexHintTypeContext) {
|
|
localctx = NewIndexHintTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 242, MySqlParserRULE_indexHintType)
|
|
p.SetState(3826)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserJOIN:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3821)
|
|
p.Match(MySqlParserJOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserORDER:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3822)
|
|
p.Match(MySqlParserORDER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3823)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserGROUP:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(3824)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3825)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJoinPartContext is an interface to support dynamic dispatch.
|
|
type IJoinPartContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsJoinPartContext differentiates from other interfaces.
|
|
IsJoinPartContext()
|
|
}
|
|
|
|
type JoinPartContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJoinPartContext() *JoinPartContext {
|
|
var p = new(JoinPartContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_joinPart
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJoinPartContext(p *JoinPartContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_joinPart
|
|
}
|
|
|
|
func (*JoinPartContext) IsJoinPartContext() {}
|
|
|
|
func NewJoinPartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinPartContext {
|
|
var p = new(JoinPartContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_joinPart
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JoinPartContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JoinPartContext) CopyAll(ctx *JoinPartContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *JoinPartContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JoinPartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type InnerJoinContext struct {
|
|
JoinPartContext
|
|
}
|
|
|
|
func NewInnerJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InnerJoinContext {
|
|
var p = new(InnerJoinContext)
|
|
|
|
InitEmptyJoinPartContext(&p.JoinPartContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*JoinPartContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InnerJoinContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InnerJoinContext) JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJOIN, 0)
|
|
}
|
|
|
|
func (s *InnerJoinContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *InnerJoinContext) LATERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATERAL, 0)
|
|
}
|
|
|
|
func (s *InnerJoinContext) AllJoinSpec() []IJoinSpecContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IJoinSpecContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IJoinSpecContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IJoinSpecContext); ok {
|
|
tst[i] = t.(IJoinSpecContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *InnerJoinContext) JoinSpec(i int) IJoinSpecContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJoinSpecContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJoinSpecContext)
|
|
}
|
|
|
|
func (s *InnerJoinContext) INNER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNER, 0)
|
|
}
|
|
|
|
func (s *InnerJoinContext) CROSS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCROSS, 0)
|
|
}
|
|
|
|
func (s *InnerJoinContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInnerJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *InnerJoinContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInnerJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *InnerJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInnerJoin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NaturalJoinContext struct {
|
|
JoinPartContext
|
|
}
|
|
|
|
func NewNaturalJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NaturalJoinContext {
|
|
var p = new(NaturalJoinContext)
|
|
|
|
InitEmptyJoinPartContext(&p.JoinPartContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*JoinPartContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NaturalJoinContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NaturalJoinContext) NATURAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNATURAL, 0)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJOIN, 0)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) LEFT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEFT, 0)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) RIGHT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRIGHT, 0)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) OUTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOUTER, 0)
|
|
}
|
|
|
|
func (s *NaturalJoinContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNaturalJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *NaturalJoinContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNaturalJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *NaturalJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNaturalJoin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type OuterJoinContext struct {
|
|
JoinPartContext
|
|
}
|
|
|
|
func NewOuterJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OuterJoinContext {
|
|
var p = new(OuterJoinContext)
|
|
|
|
InitEmptyJoinPartContext(&p.JoinPartContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*JoinPartContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OuterJoinContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OuterJoinContext) JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJOIN, 0)
|
|
}
|
|
|
|
func (s *OuterJoinContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *OuterJoinContext) LEFT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEFT, 0)
|
|
}
|
|
|
|
func (s *OuterJoinContext) RIGHT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRIGHT, 0)
|
|
}
|
|
|
|
func (s *OuterJoinContext) OUTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOUTER, 0)
|
|
}
|
|
|
|
func (s *OuterJoinContext) LATERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATERAL, 0)
|
|
}
|
|
|
|
func (s *OuterJoinContext) AllJoinSpec() []IJoinSpecContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IJoinSpecContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IJoinSpecContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IJoinSpecContext); ok {
|
|
tst[i] = t.(IJoinSpecContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *OuterJoinContext) JoinSpec(i int) IJoinSpecContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJoinSpecContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJoinSpecContext)
|
|
}
|
|
|
|
func (s *OuterJoinContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOuterJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *OuterJoinContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOuterJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *OuterJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOuterJoin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type StraightJoinContext struct {
|
|
JoinPartContext
|
|
}
|
|
|
|
func NewStraightJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StraightJoinContext {
|
|
var p = new(StraightJoinContext)
|
|
|
|
InitEmptyJoinPartContext(&p.JoinPartContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*JoinPartContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StraightJoinContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StraightJoinContext) STRAIGHT_JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRAIGHT_JOIN, 0)
|
|
}
|
|
|
|
func (s *StraightJoinContext) TableSourceItem() ITableSourceItemContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourceItemContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourceItemContext)
|
|
}
|
|
|
|
func (s *StraightJoinContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *StraightJoinContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *StraightJoinContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *StraightJoinContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *StraightJoinContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStraightJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *StraightJoinContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStraightJoin(s)
|
|
}
|
|
}
|
|
|
|
func (s *StraightJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStraightJoin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JoinPart() (localctx IJoinPartContext) {
|
|
localctx = NewJoinPartContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 244, MySqlParserRULE_joinPart)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(3875)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCROSS, MySqlParserINNER, MySqlParserJOIN:
|
|
localctx = NewInnerJoinContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(3829)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCROSS || _la == MySqlParserINNER {
|
|
{
|
|
p.SetState(3828)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCROSS || _la == MySqlParserINNER) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3831)
|
|
p.Match(MySqlParserJOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3833)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3832)
|
|
p.Match(MySqlParserLATERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3835)
|
|
p.TableSourceItem()
|
|
}
|
|
p.SetState(3839)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 545, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3836)
|
|
p.JoinSpec()
|
|
}
|
|
|
|
}
|
|
p.SetState(3841)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 545, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTRAIGHT_JOIN:
|
|
localctx = NewStraightJoinContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3842)
|
|
p.Match(MySqlParserSTRAIGHT_JOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3843)
|
|
p.TableSourceItem()
|
|
}
|
|
p.SetState(3848)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3844)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3845)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(3850)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLEFT, MySqlParserRIGHT:
|
|
localctx = NewOuterJoinContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(3851)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLEFT || _la == MySqlParserRIGHT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(3853)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOUTER {
|
|
{
|
|
p.SetState(3852)
|
|
p.Match(MySqlParserOUTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3855)
|
|
p.Match(MySqlParserJOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3857)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 548, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3856)
|
|
p.Match(MySqlParserLATERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(3859)
|
|
p.TableSourceItem()
|
|
}
|
|
p.SetState(3863)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3860)
|
|
p.JoinSpec()
|
|
}
|
|
|
|
}
|
|
p.SetState(3865)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserNATURAL:
|
|
localctx = NewNaturalJoinContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(3866)
|
|
p.Match(MySqlParserNATURAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3871)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLEFT || _la == MySqlParserRIGHT {
|
|
{
|
|
p.SetState(3867)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLEFT || _la == MySqlParserRIGHT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(3869)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOUTER {
|
|
{
|
|
p.SetState(3868)
|
|
p.Match(MySqlParserOUTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3873)
|
|
p.Match(MySqlParserJOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3874)
|
|
p.TableSourceItem()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJoinSpecContext is an interface to support dynamic dispatch.
|
|
type IJoinSpecContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ON() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
USING() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsJoinSpecContext differentiates from other interfaces.
|
|
IsJoinSpecContext()
|
|
}
|
|
|
|
type JoinSpecContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJoinSpecContext() *JoinSpecContext {
|
|
var p = new(JoinSpecContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_joinSpec
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJoinSpecContext(p *JoinSpecContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_joinSpec
|
|
}
|
|
|
|
func (*JoinSpecContext) IsJoinSpecContext() {}
|
|
|
|
func NewJoinSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinSpecContext {
|
|
var p = new(JoinSpecContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_joinSpec
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JoinSpecContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JoinSpecContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *JoinSpecContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *JoinSpecContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *JoinSpecContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JoinSpecContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *JoinSpecContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JoinSpecContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JoinSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JoinSpecContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJoinSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *JoinSpecContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJoinSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *JoinSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJoinSpec(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JoinSpec() (localctx IJoinSpecContext) {
|
|
localctx = NewJoinSpecContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 246, MySqlParserRULE_joinSpec)
|
|
p.SetState(3884)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserON:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3877)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3878)
|
|
p.expression(0)
|
|
}
|
|
|
|
case MySqlParserUSING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3879)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3880)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3881)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(3882)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IQueryExpressionContext is an interface to support dynamic dispatch.
|
|
type IQueryExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
QuerySpecification() IQuerySpecificationContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
QueryExpression() IQueryExpressionContext
|
|
|
|
// IsQueryExpressionContext differentiates from other interfaces.
|
|
IsQueryExpressionContext()
|
|
}
|
|
|
|
type QueryExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyQueryExpressionContext() *QueryExpressionContext {
|
|
var p = new(QueryExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_queryExpression
|
|
return p
|
|
}
|
|
|
|
func InitEmptyQueryExpressionContext(p *QueryExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_queryExpression
|
|
}
|
|
|
|
func (*QueryExpressionContext) IsQueryExpressionContext() {}
|
|
|
|
func NewQueryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryExpressionContext {
|
|
var p = new(QueryExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_queryExpression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *QueryExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *QueryExpressionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *QueryExpressionContext) QuerySpecification() IQuerySpecificationContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationContext)
|
|
}
|
|
|
|
func (s *QueryExpressionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *QueryExpressionContext) QueryExpression() IQueryExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionContext)
|
|
}
|
|
|
|
func (s *QueryExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *QueryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *QueryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterQueryExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitQueryExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitQueryExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) QueryExpression() (localctx IQueryExpressionContext) {
|
|
localctx = NewQueryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 248, MySqlParserRULE_queryExpression)
|
|
p.SetState(3894)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 554, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3886)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3887)
|
|
p.QuerySpecification()
|
|
}
|
|
{
|
|
p.SetState(3888)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3890)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3891)
|
|
p.QueryExpression()
|
|
}
|
|
{
|
|
p.SetState(3892)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IQueryExpressionNointoContext is an interface to support dynamic dispatch.
|
|
type IQueryExpressionNointoContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
QuerySpecificationNointo() IQuerySpecificationNointoContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
QueryExpressionNointo() IQueryExpressionNointoContext
|
|
|
|
// IsQueryExpressionNointoContext differentiates from other interfaces.
|
|
IsQueryExpressionNointoContext()
|
|
}
|
|
|
|
type QueryExpressionNointoContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyQueryExpressionNointoContext() *QueryExpressionNointoContext {
|
|
var p = new(QueryExpressionNointoContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_queryExpressionNointo
|
|
return p
|
|
}
|
|
|
|
func InitEmptyQueryExpressionNointoContext(p *QueryExpressionNointoContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_queryExpressionNointo
|
|
}
|
|
|
|
func (*QueryExpressionNointoContext) IsQueryExpressionNointoContext() {}
|
|
|
|
func NewQueryExpressionNointoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryExpressionNointoContext {
|
|
var p = new(QueryExpressionNointoContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_queryExpressionNointo
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *QueryExpressionNointoContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) QuerySpecificationNointo() IQuerySpecificationNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationNointoContext)
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterQueryExpressionNointo(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitQueryExpressionNointo(s)
|
|
}
|
|
}
|
|
|
|
func (s *QueryExpressionNointoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitQueryExpressionNointo(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) QueryExpressionNointo() (localctx IQueryExpressionNointoContext) {
|
|
localctx = NewQueryExpressionNointoContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 250, MySqlParserRULE_queryExpressionNointo)
|
|
p.SetState(3904)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3896)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3897)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
{
|
|
p.SetState(3898)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3900)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3901)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
{
|
|
p.SetState(3902)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IQuerySpecificationContext is an interface to support dynamic dispatch.
|
|
type IQuerySpecificationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SELECT() antlr.TerminalNode
|
|
SelectElements() ISelectElementsContext
|
|
FromClause() IFromClauseContext
|
|
AllSelectSpec() []ISelectSpecContext
|
|
SelectSpec(i int) ISelectSpecContext
|
|
SelectIntoExpression() ISelectIntoExpressionContext
|
|
GroupByClause() IGroupByClauseContext
|
|
HavingClause() IHavingClauseContext
|
|
WindowClause() IWindowClauseContext
|
|
OrderByClause() IOrderByClauseContext
|
|
LimitClause() ILimitClauseContext
|
|
|
|
// IsQuerySpecificationContext differentiates from other interfaces.
|
|
IsQuerySpecificationContext()
|
|
}
|
|
|
|
type QuerySpecificationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyQuerySpecificationContext() *QuerySpecificationContext {
|
|
var p = new(QuerySpecificationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_querySpecification
|
|
return p
|
|
}
|
|
|
|
func InitEmptyQuerySpecificationContext(p *QuerySpecificationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_querySpecification
|
|
}
|
|
|
|
func (*QuerySpecificationContext) IsQuerySpecificationContext() {}
|
|
|
|
func NewQuerySpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuerySpecificationContext {
|
|
var p = new(QuerySpecificationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_querySpecification
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *QuerySpecificationContext) SELECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSELECT, 0)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) SelectElements() ISelectElementsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectElementsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectElementsContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) FromClause() IFromClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFromClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFromClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) AllSelectSpec() []ISelectSpecContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectSpecContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectSpecContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectSpecContext); ok {
|
|
tst[i] = t.(ISelectSpecContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) SelectSpec(i int) ISelectSpecContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectSpecContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectSpecContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) SelectIntoExpression() ISelectIntoExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectIntoExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectIntoExpressionContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) GroupByClause() IGroupByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGroupByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGroupByClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) HavingClause() IHavingClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHavingClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHavingClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) WindowClause() IWindowClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterQuerySpecification(s)
|
|
}
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitQuerySpecification(s)
|
|
}
|
|
}
|
|
|
|
func (s *QuerySpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitQuerySpecification(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) QuerySpecification() (localctx IQuerySpecificationContext) {
|
|
localctx = NewQuerySpecificationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 252, MySqlParserRULE_querySpecification)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(3960)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 570, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3906)
|
|
p.Match(MySqlParserSELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3910)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3907)
|
|
p.SelectSpec()
|
|
}
|
|
|
|
}
|
|
p.SetState(3912)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3913)
|
|
p.SelectElements()
|
|
}
|
|
p.SetState(3915)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINTO {
|
|
{
|
|
p.SetState(3914)
|
|
p.SelectIntoExpression()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3917)
|
|
p.FromClause()
|
|
}
|
|
p.SetState(3919)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 558, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3918)
|
|
p.GroupByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3922)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserHAVING {
|
|
{
|
|
p.SetState(3921)
|
|
p.HavingClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3925)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWINDOW {
|
|
{
|
|
p.SetState(3924)
|
|
p.WindowClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3928)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3927)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3931)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3930)
|
|
p.LimitClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(3933)
|
|
p.Match(MySqlParserSELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3937)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3934)
|
|
p.SelectSpec()
|
|
}
|
|
|
|
}
|
|
p.SetState(3939)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3940)
|
|
p.SelectElements()
|
|
}
|
|
{
|
|
p.SetState(3941)
|
|
p.FromClause()
|
|
}
|
|
p.SetState(3943)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3942)
|
|
p.GroupByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3946)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserHAVING {
|
|
{
|
|
p.SetState(3945)
|
|
p.HavingClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3949)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWINDOW {
|
|
{
|
|
p.SetState(3948)
|
|
p.WindowClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3952)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3951)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3955)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 568, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3954)
|
|
p.LimitClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3958)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINTO {
|
|
{
|
|
p.SetState(3957)
|
|
p.SelectIntoExpression()
|
|
}
|
|
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IQuerySpecificationNointoContext is an interface to support dynamic dispatch.
|
|
type IQuerySpecificationNointoContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SELECT() antlr.TerminalNode
|
|
SelectElements() ISelectElementsContext
|
|
FromClause() IFromClauseContext
|
|
AllSelectSpec() []ISelectSpecContext
|
|
SelectSpec(i int) ISelectSpecContext
|
|
GroupByClause() IGroupByClauseContext
|
|
HavingClause() IHavingClauseContext
|
|
WindowClause() IWindowClauseContext
|
|
OrderByClause() IOrderByClauseContext
|
|
LimitClause() ILimitClauseContext
|
|
UnionStatement() IUnionStatementContext
|
|
|
|
// IsQuerySpecificationNointoContext differentiates from other interfaces.
|
|
IsQuerySpecificationNointoContext()
|
|
}
|
|
|
|
type QuerySpecificationNointoContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyQuerySpecificationNointoContext() *QuerySpecificationNointoContext {
|
|
var p = new(QuerySpecificationNointoContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_querySpecificationNointo
|
|
return p
|
|
}
|
|
|
|
func InitEmptyQuerySpecificationNointoContext(p *QuerySpecificationNointoContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_querySpecificationNointo
|
|
}
|
|
|
|
func (*QuerySpecificationNointoContext) IsQuerySpecificationNointoContext() {}
|
|
|
|
func NewQuerySpecificationNointoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuerySpecificationNointoContext {
|
|
var p = new(QuerySpecificationNointoContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_querySpecificationNointo
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *QuerySpecificationNointoContext) SELECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSELECT, 0)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) SelectElements() ISelectElementsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectElementsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectElementsContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) FromClause() IFromClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFromClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFromClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) AllSelectSpec() []ISelectSpecContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectSpecContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectSpecContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectSpecContext); ok {
|
|
tst[i] = t.(ISelectSpecContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) SelectSpec(i int) ISelectSpecContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectSpecContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectSpecContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) GroupByClause() IGroupByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGroupByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGroupByClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) HavingClause() IHavingClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHavingClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHavingClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) WindowClause() IWindowClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) UnionStatement() IUnionStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnionStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnionStatementContext)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterQuerySpecificationNointo(s)
|
|
}
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitQuerySpecificationNointo(s)
|
|
}
|
|
}
|
|
|
|
func (s *QuerySpecificationNointoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitQuerySpecificationNointo(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) QuerySpecificationNointo() (localctx IQuerySpecificationNointoContext) {
|
|
localctx = NewQuerySpecificationNointoContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 254, MySqlParserRULE_querySpecificationNointo)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3962)
|
|
p.Match(MySqlParserSELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3966)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(3963)
|
|
p.SelectSpec()
|
|
}
|
|
|
|
}
|
|
p.SetState(3968)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(3969)
|
|
p.SelectElements()
|
|
}
|
|
{
|
|
p.SetState(3970)
|
|
p.FromClause()
|
|
}
|
|
p.SetState(3972)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 572, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3971)
|
|
p.GroupByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3975)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserHAVING {
|
|
{
|
|
p.SetState(3974)
|
|
p.HavingClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3978)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWINDOW {
|
|
{
|
|
p.SetState(3977)
|
|
p.WindowClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(3981)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 575, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3980)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3984)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 576, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3983)
|
|
p.LimitClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(3987)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(3986)
|
|
p.UnionStatement()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUnionParenthesisContext is an interface to support dynamic dispatch.
|
|
type IUnionParenthesisContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetUnionType returns the unionType token.
|
|
GetUnionType() antlr.Token
|
|
|
|
// SetUnionType sets the unionType token.
|
|
SetUnionType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
UNION() antlr.TerminalNode
|
|
QueryExpressionNointo() IQueryExpressionNointoContext
|
|
ALL() antlr.TerminalNode
|
|
DISTINCT() antlr.TerminalNode
|
|
|
|
// IsUnionParenthesisContext differentiates from other interfaces.
|
|
IsUnionParenthesisContext()
|
|
}
|
|
|
|
type UnionParenthesisContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
unionType antlr.Token
|
|
}
|
|
|
|
func NewEmptyUnionParenthesisContext() *UnionParenthesisContext {
|
|
var p = new(UnionParenthesisContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unionParenthesis
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUnionParenthesisContext(p *UnionParenthesisContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unionParenthesis
|
|
}
|
|
|
|
func (*UnionParenthesisContext) IsUnionParenthesisContext() {}
|
|
|
|
func NewUnionParenthesisContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionParenthesisContext {
|
|
var p = new(UnionParenthesisContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_unionParenthesis
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UnionParenthesisContext) GetUnionType() antlr.Token { return s.unionType }
|
|
|
|
func (s *UnionParenthesisContext) SetUnionType(v antlr.Token) { s.unionType = v }
|
|
|
|
func (s *UnionParenthesisContext) UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNION, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnionParenthesis(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnionParenthesis(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionParenthesisContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnionParenthesis(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UnionParenthesis() (localctx IUnionParenthesisContext) {
|
|
localctx = NewUnionParenthesisContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 256, MySqlParserRULE_unionParenthesis)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3989)
|
|
p.Match(MySqlParserUNION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3991)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALL || _la == MySqlParserDISTINCT {
|
|
{
|
|
p.SetState(3990)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UnionParenthesisContext).unionType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UnionParenthesisContext).unionType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(3993)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUnionStatementContext is an interface to support dynamic dispatch.
|
|
type IUnionStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetUnionType returns the unionType token.
|
|
GetUnionType() antlr.Token
|
|
|
|
// SetUnionType sets the unionType token.
|
|
SetUnionType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
UNION() antlr.TerminalNode
|
|
QuerySpecificationNointo() IQuerySpecificationNointoContext
|
|
QueryExpressionNointo() IQueryExpressionNointoContext
|
|
ALL() antlr.TerminalNode
|
|
DISTINCT() antlr.TerminalNode
|
|
|
|
// IsUnionStatementContext differentiates from other interfaces.
|
|
IsUnionStatementContext()
|
|
}
|
|
|
|
type UnionStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
unionType antlr.Token
|
|
}
|
|
|
|
func NewEmptyUnionStatementContext() *UnionStatementContext {
|
|
var p = new(UnionStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unionStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUnionStatementContext(p *UnionStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unionStatement
|
|
}
|
|
|
|
func (*UnionStatementContext) IsUnionStatementContext() {}
|
|
|
|
func NewUnionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionStatementContext {
|
|
var p = new(UnionStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_unionStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnionStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UnionStatementContext) GetUnionType() antlr.Token { return s.unionType }
|
|
|
|
func (s *UnionStatementContext) SetUnionType(v antlr.Token) { s.unionType = v }
|
|
|
|
func (s *UnionStatementContext) UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNION, 0)
|
|
}
|
|
|
|
func (s *UnionStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationNointoContext)
|
|
}
|
|
|
|
func (s *UnionStatementContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *UnionStatementContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *UnionStatementContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *UnionStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UnionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnionStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UnionStatement() (localctx IUnionStatementContext) {
|
|
localctx = NewUnionStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 258, MySqlParserRULE_unionStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(3995)
|
|
p.Match(MySqlParserUNION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(3997)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALL || _la == MySqlParserDISTINCT {
|
|
{
|
|
p.SetState(3996)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UnionStatementContext).unionType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UnionStatementContext).unionType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4001)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT:
|
|
{
|
|
p.SetState(3999)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(4000)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILateralStatementContext is an interface to support dynamic dispatch.
|
|
type ILateralStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LATERAL() antlr.TerminalNode
|
|
QuerySpecificationNointo() IQuerySpecificationNointoContext
|
|
QueryExpressionNointo() IQueryExpressionNointoContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsLateralStatementContext differentiates from other interfaces.
|
|
IsLateralStatementContext()
|
|
}
|
|
|
|
type LateralStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLateralStatementContext() *LateralStatementContext {
|
|
var p = new(LateralStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lateralStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLateralStatementContext(p *LateralStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lateralStatement
|
|
}
|
|
|
|
func (*LateralStatementContext) IsLateralStatementContext() {}
|
|
|
|
func NewLateralStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LateralStatementContext {
|
|
var p = new(LateralStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lateralStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LateralStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LateralStatementContext) LATERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATERAL, 0)
|
|
}
|
|
|
|
func (s *LateralStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQuerySpecificationNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQuerySpecificationNointoContext)
|
|
}
|
|
|
|
func (s *LateralStatementContext) QueryExpressionNointo() IQueryExpressionNointoContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IQueryExpressionNointoContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IQueryExpressionNointoContext)
|
|
}
|
|
|
|
func (s *LateralStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LateralStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LateralStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *LateralStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *LateralStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LateralStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LateralStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLateralStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LateralStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLateralStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LateralStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLateralStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LateralStatement() (localctx ILateralStatementContext) {
|
|
localctx = NewLateralStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 260, MySqlParserRULE_lateralStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4003)
|
|
p.Match(MySqlParserLATERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4018)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(4004)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(4005)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(4006)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4009)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT:
|
|
{
|
|
p.SetState(4007)
|
|
p.QuerySpecificationNointo()
|
|
}
|
|
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(4008)
|
|
p.QueryExpressionNointo()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4011)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4016)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4013)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4012)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4015)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonTableContext is an interface to support dynamic dispatch.
|
|
type IJsonTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
JSON_TABLE() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
COMMA() antlr.TerminalNode
|
|
COLUMNS() antlr.TerminalNode
|
|
JsonColumnList() IJsonColumnListContext
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsJsonTableContext differentiates from other interfaces.
|
|
IsJsonTableContext()
|
|
}
|
|
|
|
type JsonTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonTableContext() *JsonTableContext {
|
|
var p = new(JsonTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonTableContext(p *JsonTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonTable
|
|
}
|
|
|
|
func (*JsonTableContext) IsJsonTableContext() {}
|
|
|
|
func NewJsonTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonTableContext {
|
|
var p = new(JsonTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonTableContext) JSON_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_TABLE, 0)
|
|
}
|
|
|
|
func (s *JsonTableContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *JsonTableContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *JsonTableContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *JsonTableContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *JsonTableContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *JsonTableContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *JsonTableContext) JsonColumnList() IJsonColumnListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonColumnListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonColumnListContext)
|
|
}
|
|
|
|
func (s *JsonTableContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *JsonTableContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *JsonTableContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *JsonTableContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *JsonTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonTable() (localctx IJsonTableContext) {
|
|
localctx = NewJsonTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 262, MySqlParserRULE_jsonTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4020)
|
|
p.Match(MySqlParserJSON_TABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4021)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4022)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4023)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4024)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4025)
|
|
p.Match(MySqlParserCOLUMNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4026)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4027)
|
|
p.JsonColumnList()
|
|
}
|
|
{
|
|
p.SetState(4028)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4029)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4034)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 586, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4031)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4030)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4033)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonColumnListContext is an interface to support dynamic dispatch.
|
|
type IJsonColumnListContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllJsonColumn() []IJsonColumnContext
|
|
JsonColumn(i int) IJsonColumnContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsJsonColumnListContext differentiates from other interfaces.
|
|
IsJsonColumnListContext()
|
|
}
|
|
|
|
type JsonColumnListContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonColumnListContext() *JsonColumnListContext {
|
|
var p = new(JsonColumnListContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonColumnList
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonColumnListContext(p *JsonColumnListContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonColumnList
|
|
}
|
|
|
|
func (*JsonColumnListContext) IsJsonColumnListContext() {}
|
|
|
|
func NewJsonColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonColumnListContext {
|
|
var p = new(JsonColumnListContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonColumnList
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonColumnListContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonColumnListContext) AllJsonColumn() []IJsonColumnContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IJsonColumnContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IJsonColumnContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IJsonColumnContext); ok {
|
|
tst[i] = t.(IJsonColumnContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *JsonColumnListContext) JsonColumn(i int) IJsonColumnContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonColumnContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonColumnContext)
|
|
}
|
|
|
|
func (s *JsonColumnListContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *JsonColumnListContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *JsonColumnListContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonColumnListContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonColumnList(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonColumnListContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonColumnList(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonColumnList(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonColumnList() (localctx IJsonColumnListContext) {
|
|
localctx = NewJsonColumnListContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 264, MySqlParserRULE_jsonColumnList)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4036)
|
|
p.JsonColumn()
|
|
}
|
|
p.SetState(4041)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4037)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4038)
|
|
p.JsonColumn()
|
|
}
|
|
|
|
p.SetState(4043)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonColumnContext is an interface to support dynamic dispatch.
|
|
type IJsonColumnContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FullColumnName() IFullColumnNameContext
|
|
FOR() antlr.TerminalNode
|
|
ORDINALITY() antlr.TerminalNode
|
|
DataType() IDataTypeContext
|
|
PATH() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
EXISTS() antlr.TerminalNode
|
|
JsonOnEmpty() IJsonOnEmptyContext
|
|
JsonOnError() IJsonOnErrorContext
|
|
NESTED() antlr.TerminalNode
|
|
COLUMNS() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
JsonColumnList() IJsonColumnListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsJsonColumnContext differentiates from other interfaces.
|
|
IsJsonColumnContext()
|
|
}
|
|
|
|
type JsonColumnContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonColumnContext() *JsonColumnContext {
|
|
var p = new(JsonColumnContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonColumn
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonColumnContext(p *JsonColumnContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonColumn
|
|
}
|
|
|
|
func (*JsonColumnContext) IsJsonColumnContext() {}
|
|
|
|
func NewJsonColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonColumnContext {
|
|
var p = new(JsonColumnContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonColumn
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonColumnContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonColumnContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *JsonColumnContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) ORDINALITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDINALITY, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *JsonColumnContext) PATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPATH, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) EXISTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXISTS, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) JsonOnEmpty() IJsonOnEmptyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonOnEmptyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonOnEmptyContext)
|
|
}
|
|
|
|
func (s *JsonColumnContext) JsonOnError() IJsonOnErrorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonOnErrorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonOnErrorContext)
|
|
}
|
|
|
|
func (s *JsonColumnContext) NESTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNESTED, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) JsonColumnList() IJsonColumnListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonColumnListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonColumnListContext)
|
|
}
|
|
|
|
func (s *JsonColumnContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonColumnContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonColumnContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonColumnContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonColumn(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonColumn(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonColumn() (localctx IJsonColumnContext) {
|
|
localctx = NewJsonColumnContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 266, MySqlParserRULE_jsonColumn)
|
|
var _la int
|
|
|
|
p.SetState(4073)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4044)
|
|
p.FullColumnName()
|
|
}
|
|
p.SetState(4061)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFOR:
|
|
{
|
|
p.SetState(4045)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4046)
|
|
p.Match(MySqlParserORDINALITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHARACTER, MySqlParserSET, MySqlParserTINYINT, MySqlParserSMALLINT, MySqlParserMEDIUMINT, MySqlParserMIDDLEINT, MySqlParserINT, MySqlParserINT1, MySqlParserINT2, MySqlParserINT3, MySqlParserINT4, MySqlParserINT8, MySqlParserINTEGER, MySqlParserBIGINT, MySqlParserREAL, MySqlParserDOUBLE, MySqlParserFLOAT, MySqlParserFLOAT4, MySqlParserFLOAT8, MySqlParserDECIMAL, MySqlParserDEC, MySqlParserNUMERIC, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserCHAR, MySqlParserVARCHAR, MySqlParserNVARCHAR, MySqlParserNATIONAL, MySqlParserBINARY, MySqlParserVARBINARY, MySqlParserTINYBLOB, MySqlParserBLOB, MySqlParserMEDIUMBLOB, MySqlParserLONG, MySqlParserLONGBLOB, MySqlParserTINYTEXT, MySqlParserTEXT, MySqlParserMEDIUMTEXT, MySqlParserLONGTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserBIT, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserFIXED, MySqlParserJSON, MySqlParserNCHAR, MySqlParserGEOMETRYCOLLECTION, MySqlParserGEOMCOLLECTION, MySqlParserGEOMETRY, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON:
|
|
{
|
|
p.SetState(4047)
|
|
p.DataType()
|
|
}
|
|
p.SetState(4059)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserPATH:
|
|
{
|
|
p.SetState(4048)
|
|
p.Match(MySqlParserPATH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4049)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4051)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4050)
|
|
p.JsonOnEmpty()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(4054)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT || _la == MySqlParserNULL_LITERAL || _la == MySqlParserERROR {
|
|
{
|
|
p.SetState(4053)
|
|
p.JsonOnError()
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserEXISTS:
|
|
{
|
|
p.SetState(4056)
|
|
p.Match(MySqlParserEXISTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4057)
|
|
p.Match(MySqlParserPATH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4058)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4063)
|
|
p.Match(MySqlParserNESTED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4065)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPATH {
|
|
{
|
|
p.SetState(4064)
|
|
p.Match(MySqlParserPATH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4067)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4068)
|
|
p.Match(MySqlParserCOLUMNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4069)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4070)
|
|
p.JsonColumnList()
|
|
}
|
|
{
|
|
p.SetState(4071)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonOnEmptyContext is an interface to support dynamic dispatch.
|
|
type IJsonOnEmptyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ON() antlr.TerminalNode
|
|
EMPTY() antlr.TerminalNode
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
ERROR() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
DefaultValue() IDefaultValueContext
|
|
|
|
// IsJsonOnEmptyContext differentiates from other interfaces.
|
|
IsJsonOnEmptyContext()
|
|
}
|
|
|
|
type JsonOnEmptyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonOnEmptyContext() *JsonOnEmptyContext {
|
|
var p = new(JsonOnEmptyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOnEmpty
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonOnEmptyContext(p *JsonOnEmptyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOnEmpty
|
|
}
|
|
|
|
func (*JsonOnEmptyContext) IsJsonOnEmptyContext() {}
|
|
|
|
func NewJsonOnEmptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOnEmptyContext {
|
|
var p = new(JsonOnEmptyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonOnEmpty
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonOnEmptyContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) EMPTY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEMPTY, 0)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) ERROR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERROR, 0)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) DefaultValue() IDefaultValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDefaultValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDefaultValueContext)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonOnEmpty(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonOnEmpty(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOnEmptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonOnEmpty(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonOnEmpty() (localctx IJsonOnEmptyContext) {
|
|
localctx = NewJsonOnEmptyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 268, MySqlParserRULE_jsonOnEmpty)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4079)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNULL_LITERAL:
|
|
{
|
|
p.SetState(4075)
|
|
p.Match(MySqlParserNULL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserERROR:
|
|
{
|
|
p.SetState(4076)
|
|
p.Match(MySqlParserERROR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(4077)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4078)
|
|
p.DefaultValue()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4081)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4082)
|
|
p.Match(MySqlParserEMPTY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonOnErrorContext is an interface to support dynamic dispatch.
|
|
type IJsonOnErrorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ON() antlr.TerminalNode
|
|
AllERROR() []antlr.TerminalNode
|
|
ERROR(i int) antlr.TerminalNode
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
DefaultValue() IDefaultValueContext
|
|
|
|
// IsJsonOnErrorContext differentiates from other interfaces.
|
|
IsJsonOnErrorContext()
|
|
}
|
|
|
|
type JsonOnErrorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonOnErrorContext() *JsonOnErrorContext {
|
|
var p = new(JsonOnErrorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOnError
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonOnErrorContext(p *JsonOnErrorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOnError
|
|
}
|
|
|
|
func (*JsonOnErrorContext) IsJsonOnErrorContext() {}
|
|
|
|
func NewJsonOnErrorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOnErrorContext {
|
|
var p = new(JsonOnErrorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonOnError
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonOnErrorContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) AllERROR() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserERROR)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) ERROR(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERROR, i)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) DefaultValue() IDefaultValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDefaultValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDefaultValueContext)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonOnError(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonOnError(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOnErrorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonOnError(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonOnError() (localctx IJsonOnErrorContext) {
|
|
localctx = NewJsonOnErrorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 270, MySqlParserRULE_jsonOnError)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4088)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNULL_LITERAL:
|
|
{
|
|
p.SetState(4084)
|
|
p.Match(MySqlParserNULL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserERROR:
|
|
{
|
|
p.SetState(4085)
|
|
p.Match(MySqlParserERROR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(4086)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4087)
|
|
p.DefaultValue()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4090)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4091)
|
|
p.Match(MySqlParserERROR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectSpecContext is an interface to support dynamic dispatch.
|
|
type ISelectSpecContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALL() antlr.TerminalNode
|
|
DISTINCT() antlr.TerminalNode
|
|
DISTINCTROW() antlr.TerminalNode
|
|
HIGH_PRIORITY() antlr.TerminalNode
|
|
STRAIGHT_JOIN() antlr.TerminalNode
|
|
SQL_SMALL_RESULT() antlr.TerminalNode
|
|
SQL_BIG_RESULT() antlr.TerminalNode
|
|
SQL_BUFFER_RESULT() antlr.TerminalNode
|
|
SQL_CACHE() antlr.TerminalNode
|
|
SQL_NO_CACHE() antlr.TerminalNode
|
|
SQL_CALC_FOUND_ROWS() antlr.TerminalNode
|
|
|
|
// IsSelectSpecContext differentiates from other interfaces.
|
|
IsSelectSpecContext()
|
|
}
|
|
|
|
type SelectSpecContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySelectSpecContext() *SelectSpecContext {
|
|
var p = new(SelectSpecContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectSpec
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectSpecContext(p *SelectSpecContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectSpec
|
|
}
|
|
|
|
func (*SelectSpecContext) IsSelectSpecContext() {}
|
|
|
|
func NewSelectSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectSpecContext {
|
|
var p = new(SelectSpecContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectSpec
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectSpecContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectSpecContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) DISTINCTROW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCTROW, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) HIGH_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHIGH_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) STRAIGHT_JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRAIGHT_JOIN, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_SMALL_RESULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_SMALL_RESULT, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_BIG_RESULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_BIG_RESULT, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_BUFFER_RESULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_BUFFER_RESULT, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_CACHE, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_NO_CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_NO_CACHE, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) SQL_CALC_FOUND_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_CALC_FOUND_ROWS, 0)
|
|
}
|
|
|
|
func (s *SelectSpecContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectSpecContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectSpecContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectSpec(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectSpec() (localctx ISelectSpecContext) {
|
|
localctx = NewSelectSpecContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 272, MySqlParserRULE_selectSpec)
|
|
var _la int
|
|
|
|
p.SetState(4101)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALL, MySqlParserDISTINCT, MySqlParserDISTINCTROW:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4093)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&1688849860264000) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserHIGH_PRIORITY:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4094)
|
|
p.Match(MySqlParserHIGH_PRIORITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTRAIGHT_JOIN:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4095)
|
|
p.Match(MySqlParserSTRAIGHT_JOIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQL_SMALL_RESULT:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4096)
|
|
p.Match(MySqlParserSQL_SMALL_RESULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQL_BIG_RESULT:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(4097)
|
|
p.Match(MySqlParserSQL_BIG_RESULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQL_BUFFER_RESULT:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(4098)
|
|
p.Match(MySqlParserSQL_BUFFER_RESULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(4099)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSQL_CACHE || _la == MySqlParserSQL_NO_CACHE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQL_CALC_FOUND_ROWS:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(4100)
|
|
p.Match(MySqlParserSQL_CALC_FOUND_ROWS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectElementsContext is an interface to support dynamic dispatch.
|
|
type ISelectElementsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetStar returns the star token.
|
|
GetStar() antlr.Token
|
|
|
|
// SetStar sets the star token.
|
|
SetStar(antlr.Token)
|
|
|
|
// Getter signatures
|
|
AllSelectElement() []ISelectElementContext
|
|
SelectElement(i int) ISelectElementContext
|
|
STAR() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsSelectElementsContext differentiates from other interfaces.
|
|
IsSelectElementsContext()
|
|
}
|
|
|
|
type SelectElementsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
star antlr.Token
|
|
}
|
|
|
|
func NewEmptySelectElementsContext() *SelectElementsContext {
|
|
var p = new(SelectElementsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectElements
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectElementsContext(p *SelectElementsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectElements
|
|
}
|
|
|
|
func (*SelectElementsContext) IsSelectElementsContext() {}
|
|
|
|
func NewSelectElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementsContext {
|
|
var p = new(SelectElementsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectElements
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectElementsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectElementsContext) GetStar() antlr.Token { return s.star }
|
|
|
|
func (s *SelectElementsContext) SetStar(v antlr.Token) { s.star = v }
|
|
|
|
func (s *SelectElementsContext) AllSelectElement() []ISelectElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectElementContext); ok {
|
|
tst[i] = t.(ISelectElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectElementsContext) SelectElement(i int) ISelectElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectElementContext)
|
|
}
|
|
|
|
func (s *SelectElementsContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *SelectElementsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SelectElementsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SelectElementsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectElementsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectElements(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectElementsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectElements(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectElements(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectElements() (localctx ISelectElementsContext) {
|
|
localctx = NewSelectElementsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 274, MySqlParserRULE_selectElements)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4105)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(4103)
|
|
|
|
var _m = p.Match(MySqlParserSTAR)
|
|
|
|
localctx.(*SelectElementsContext).star = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(4104)
|
|
p.SelectElement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(4111)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4107)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4108)
|
|
p.SelectElement()
|
|
}
|
|
|
|
}
|
|
p.SetState(4113)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectElementContext is an interface to support dynamic dispatch.
|
|
type ISelectElementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSelectElementContext differentiates from other interfaces.
|
|
IsSelectElementContext()
|
|
}
|
|
|
|
type SelectElementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySelectElementContext() *SelectElementContext {
|
|
var p = new(SelectElementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectElement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectElementContext(p *SelectElementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectElement
|
|
}
|
|
|
|
func (*SelectElementContext) IsSelectElementContext() {}
|
|
|
|
func NewSelectElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementContext {
|
|
var p = new(SelectElementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectElement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectElementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectElementContext) CopyAll(ctx *SelectElementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SelectElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SelectExpressionElementContext struct {
|
|
SelectElementContext
|
|
}
|
|
|
|
func NewSelectExpressionElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectExpressionElementContext {
|
|
var p = new(SelectExpressionElementContext)
|
|
|
|
InitEmptySelectElementContext(&p.SelectElementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectElementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) VAR_ASSIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_ASSIGN, 0)
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectExpressionElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectExpressionElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectExpressionElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectExpressionElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SelectFunctionElementContext struct {
|
|
SelectElementContext
|
|
}
|
|
|
|
func NewSelectFunctionElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectFunctionElementContext {
|
|
var p = new(SelectFunctionElementContext)
|
|
|
|
InitEmptySelectElementContext(&p.SelectElementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectElementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) FunctionCall() IFunctionCallContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionCallContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionCallContext)
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectFunctionElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectFunctionElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectFunctionElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectFunctionElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SelectStarElementContext struct {
|
|
SelectElementContext
|
|
}
|
|
|
|
func NewSelectStarElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectStarElementContext {
|
|
var p = new(SelectStarElementContext)
|
|
|
|
InitEmptySelectElementContext(&p.SelectElementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectElementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectStarElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectStarElementContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *SelectStarElementContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *SelectStarElementContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *SelectStarElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectStarElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectStarElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectStarElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectStarElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectStarElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SelectColumnElementContext struct {
|
|
SelectElementContext
|
|
}
|
|
|
|
func NewSelectColumnElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectColumnElementContext {
|
|
var p = new(SelectColumnElementContext)
|
|
|
|
InitEmptySelectElementContext(&p.SelectElementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectElementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectColumnElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectColumnElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectColumnElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectColumnElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectElement() (localctx ISelectElementContext) {
|
|
localctx = NewSelectElementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 276, MySqlParserRULE_selectElement)
|
|
var _la int
|
|
|
|
p.SetState(4143)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSelectStarElementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4114)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(4115)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4116)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewSelectColumnElementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4118)
|
|
p.FullColumnName()
|
|
}
|
|
p.SetState(4123)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4120)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4119)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4122)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewSelectFunctionElementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4125)
|
|
p.FunctionCall()
|
|
}
|
|
p.SetState(4130)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4127)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4126)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4129)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewSelectExpressionElementContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
p.SetState(4134)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4132)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4133)
|
|
p.Match(MySqlParserVAR_ASSIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4136)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(4141)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 605, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4138)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4137)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4140)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectIntoExpressionContext is an interface to support dynamic dispatch.
|
|
type ISelectIntoExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSelectIntoExpressionContext differentiates from other interfaces.
|
|
IsSelectIntoExpressionContext()
|
|
}
|
|
|
|
type SelectIntoExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySelectIntoExpressionContext() *SelectIntoExpressionContext {
|
|
var p = new(SelectIntoExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectIntoExpression
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectIntoExpressionContext(p *SelectIntoExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectIntoExpression
|
|
}
|
|
|
|
func (*SelectIntoExpressionContext) IsSelectIntoExpressionContext() {}
|
|
|
|
func NewSelectIntoExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectIntoExpressionContext {
|
|
var p = new(SelectIntoExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectIntoExpression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectIntoExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectIntoExpressionContext) CopyAll(ctx *SelectIntoExpressionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SelectIntoExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectIntoExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SelectIntoVariablesContext struct {
|
|
SelectIntoExpressionContext
|
|
}
|
|
|
|
func NewSelectIntoVariablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoVariablesContext {
|
|
var p = new(SelectIntoVariablesContext)
|
|
|
|
InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectIntoExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) AllAssignmentField() []IAssignmentFieldContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IAssignmentFieldContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IAssignmentFieldContext); ok {
|
|
tst[i] = t.(IAssignmentFieldContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) AssignmentField(i int) IAssignmentFieldContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAssignmentFieldContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAssignmentFieldContext)
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectIntoVariables(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectIntoVariables(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectIntoVariables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SelectIntoTextFileContext struct {
|
|
SelectIntoExpressionContext
|
|
filename antlr.Token
|
|
charset ICharsetNameContext
|
|
fieldsFormat antlr.Token
|
|
}
|
|
|
|
func NewSelectIntoTextFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoTextFileContext {
|
|
var p = new(SelectIntoTextFileContext)
|
|
|
|
InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectIntoExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) GetFilename() antlr.Token { return s.filename }
|
|
|
|
func (s *SelectIntoTextFileContext) GetFieldsFormat() antlr.Token { return s.fieldsFormat }
|
|
|
|
func (s *SelectIntoTextFileContext) SetFilename(v antlr.Token) { s.filename = v }
|
|
|
|
func (s *SelectIntoTextFileContext) SetFieldsFormat(v antlr.Token) { s.fieldsFormat = v }
|
|
|
|
func (s *SelectIntoTextFileContext) GetCharset() ICharsetNameContext { return s.charset }
|
|
|
|
func (s *SelectIntoTextFileContext) SetCharset(v ICharsetNameContext) { s.charset = v }
|
|
|
|
func (s *SelectIntoTextFileContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) OUTFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOUTFILE, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) LINES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINES, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) FIELDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIELDS, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) AllSelectFieldsInto() []ISelectFieldsIntoContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectFieldsIntoContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
tst[i] = t.(ISelectFieldsIntoContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) SelectFieldsInto(i int) ISelectFieldsIntoContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectFieldsIntoContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectFieldsIntoContext)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) AllSelectLinesInto() []ISelectLinesIntoContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectLinesIntoContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
tst[i] = t.(ISelectLinesIntoContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) SelectLinesInto(i int) ISelectLinesIntoContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectLinesIntoContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectLinesIntoContext)
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectIntoTextFile(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectIntoTextFile(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoTextFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectIntoTextFile(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SelectIntoDumpFileContext struct {
|
|
SelectIntoExpressionContext
|
|
}
|
|
|
|
func NewSelectIntoDumpFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoDumpFileContext {
|
|
var p = new(SelectIntoDumpFileContext)
|
|
|
|
InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SelectIntoExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) DUMPFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDUMPFILE, 0)
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectIntoDumpFile(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectIntoDumpFile(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectIntoDumpFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectIntoDumpFile(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectIntoExpression() (localctx ISelectIntoExpressionContext) {
|
|
localctx = NewSelectIntoExpressionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 278, MySqlParserRULE_selectIntoExpression)
|
|
var _la int
|
|
|
|
p.SetState(4181)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 613, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSelectIntoVariablesContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4145)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4146)
|
|
p.AssignmentField()
|
|
}
|
|
p.SetState(4151)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4147)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4148)
|
|
p.AssignmentField()
|
|
}
|
|
|
|
p.SetState(4153)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewSelectIntoDumpFileContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4154)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4155)
|
|
p.Match(MySqlParserDUMPFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4156)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewSelectIntoTextFileContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4157)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4158)
|
|
p.Match(MySqlParserOUTFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4159)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectIntoTextFileContext).filename = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4163)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCHARACTER {
|
|
{
|
|
p.SetState(4160)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4161)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4162)
|
|
|
|
var _x = p.CharsetName()
|
|
|
|
localctx.(*SelectIntoTextFileContext).charset = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(4171)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 610, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4165)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SelectIntoTextFileContext).fieldsFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SelectIntoTextFileContext).fieldsFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(4167)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserENCLOSED || _la == MySqlParserESCAPED || _la == MySqlParserOPTIONALLY || _la == MySqlParserTERMINATED {
|
|
{
|
|
p.SetState(4166)
|
|
p.SelectFieldsInto()
|
|
}
|
|
|
|
p.SetState(4169)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(4179)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLINES {
|
|
{
|
|
p.SetState(4173)
|
|
p.Match(MySqlParserLINES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4175)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserSTARTING || _la == MySqlParserTERMINATED {
|
|
{
|
|
p.SetState(4174)
|
|
p.SelectLinesInto()
|
|
}
|
|
|
|
p.SetState(4177)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectFieldsIntoContext is an interface to support dynamic dispatch.
|
|
type ISelectFieldsIntoContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetTerminationField returns the terminationField token.
|
|
GetTerminationField() antlr.Token
|
|
|
|
// GetEnclosion returns the enclosion token.
|
|
GetEnclosion() antlr.Token
|
|
|
|
// GetEscaping returns the escaping token.
|
|
GetEscaping() antlr.Token
|
|
|
|
// SetTerminationField sets the terminationField token.
|
|
SetTerminationField(antlr.Token)
|
|
|
|
// SetEnclosion sets the enclosion token.
|
|
SetEnclosion(antlr.Token)
|
|
|
|
// SetEscaping sets the escaping token.
|
|
SetEscaping(antlr.Token)
|
|
|
|
// Getter signatures
|
|
TERMINATED() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
ENCLOSED() antlr.TerminalNode
|
|
OPTIONALLY() antlr.TerminalNode
|
|
ESCAPED() antlr.TerminalNode
|
|
|
|
// IsSelectFieldsIntoContext differentiates from other interfaces.
|
|
IsSelectFieldsIntoContext()
|
|
}
|
|
|
|
type SelectFieldsIntoContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
terminationField antlr.Token
|
|
enclosion antlr.Token
|
|
escaping antlr.Token
|
|
}
|
|
|
|
func NewEmptySelectFieldsIntoContext() *SelectFieldsIntoContext {
|
|
var p = new(SelectFieldsIntoContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectFieldsInto
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectFieldsIntoContext(p *SelectFieldsIntoContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectFieldsInto
|
|
}
|
|
|
|
func (*SelectFieldsIntoContext) IsSelectFieldsIntoContext() {}
|
|
|
|
func NewSelectFieldsIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectFieldsIntoContext {
|
|
var p = new(SelectFieldsIntoContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectFieldsInto
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectFieldsIntoContext) GetTerminationField() antlr.Token { return s.terminationField }
|
|
|
|
func (s *SelectFieldsIntoContext) GetEnclosion() antlr.Token { return s.enclosion }
|
|
|
|
func (s *SelectFieldsIntoContext) GetEscaping() antlr.Token { return s.escaping }
|
|
|
|
func (s *SelectFieldsIntoContext) SetTerminationField(v antlr.Token) { s.terminationField = v }
|
|
|
|
func (s *SelectFieldsIntoContext) SetEnclosion(v antlr.Token) { s.enclosion = v }
|
|
|
|
func (s *SelectFieldsIntoContext) SetEscaping(v antlr.Token) { s.escaping = v }
|
|
|
|
func (s *SelectFieldsIntoContext) TERMINATED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTERMINATED, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) ENCLOSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCLOSED, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) OPTIONALLY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONALLY, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) ESCAPED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserESCAPED, 0)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectFieldsInto(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectFieldsInto(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectFieldsIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectFieldsInto(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectFieldsInto() (localctx ISelectFieldsIntoContext) {
|
|
localctx = NewSelectFieldsIntoContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 280, MySqlParserRULE_selectFieldsInto)
|
|
var _la int
|
|
|
|
p.SetState(4195)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserTERMINATED:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4183)
|
|
p.Match(MySqlParserTERMINATED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4184)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4185)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectFieldsIntoContext).terminationField = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserENCLOSED, MySqlParserOPTIONALLY:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(4187)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserOPTIONALLY {
|
|
{
|
|
p.SetState(4186)
|
|
p.Match(MySqlParserOPTIONALLY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4189)
|
|
p.Match(MySqlParserENCLOSED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4190)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4191)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectFieldsIntoContext).enclosion = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserESCAPED:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4192)
|
|
p.Match(MySqlParserESCAPED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4193)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4194)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectFieldsIntoContext).escaping = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectLinesIntoContext is an interface to support dynamic dispatch.
|
|
type ISelectLinesIntoContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetStarting returns the starting token.
|
|
GetStarting() antlr.Token
|
|
|
|
// GetTerminationLine returns the terminationLine token.
|
|
GetTerminationLine() antlr.Token
|
|
|
|
// SetStarting sets the starting token.
|
|
SetStarting(antlr.Token)
|
|
|
|
// SetTerminationLine sets the terminationLine token.
|
|
SetTerminationLine(antlr.Token)
|
|
|
|
// Getter signatures
|
|
STARTING() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
TERMINATED() antlr.TerminalNode
|
|
|
|
// IsSelectLinesIntoContext differentiates from other interfaces.
|
|
IsSelectLinesIntoContext()
|
|
}
|
|
|
|
type SelectLinesIntoContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
starting antlr.Token
|
|
terminationLine antlr.Token
|
|
}
|
|
|
|
func NewEmptySelectLinesIntoContext() *SelectLinesIntoContext {
|
|
var p = new(SelectLinesIntoContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectLinesInto
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectLinesIntoContext(p *SelectLinesIntoContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_selectLinesInto
|
|
}
|
|
|
|
func (*SelectLinesIntoContext) IsSelectLinesIntoContext() {}
|
|
|
|
func NewSelectLinesIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectLinesIntoContext {
|
|
var p = new(SelectLinesIntoContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_selectLinesInto
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectLinesIntoContext) GetStarting() antlr.Token { return s.starting }
|
|
|
|
func (s *SelectLinesIntoContext) GetTerminationLine() antlr.Token { return s.terminationLine }
|
|
|
|
func (s *SelectLinesIntoContext) SetStarting(v antlr.Token) { s.starting = v }
|
|
|
|
func (s *SelectLinesIntoContext) SetTerminationLine(v antlr.Token) { s.terminationLine = v }
|
|
|
|
func (s *SelectLinesIntoContext) STARTING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTARTING, 0)
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) TERMINATED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTERMINATED, 0)
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSelectLinesInto(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSelectLinesInto(s)
|
|
}
|
|
}
|
|
|
|
func (s *SelectLinesIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSelectLinesInto(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SelectLinesInto() (localctx ISelectLinesIntoContext) {
|
|
localctx = NewSelectLinesIntoContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 282, MySqlParserRULE_selectLinesInto)
|
|
p.SetState(4203)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTARTING:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4197)
|
|
p.Match(MySqlParserSTARTING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4198)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4199)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectLinesIntoContext).starting = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTERMINATED:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4200)
|
|
p.Match(MySqlParserTERMINATED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4201)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4202)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SelectLinesIntoContext).terminationLine = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFromClauseContext is an interface to support dynamic dispatch.
|
|
type IFromClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetWhereExpr returns the whereExpr rule contexts.
|
|
GetWhereExpr() IExpressionContext
|
|
|
|
// SetWhereExpr sets the whereExpr rule contexts.
|
|
SetWhereExpr(IExpressionContext)
|
|
|
|
// Getter signatures
|
|
FROM() antlr.TerminalNode
|
|
TableSources() ITableSourcesContext
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsFromClauseContext differentiates from other interfaces.
|
|
IsFromClauseContext()
|
|
}
|
|
|
|
type FromClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
whereExpr IExpressionContext
|
|
}
|
|
|
|
func NewEmptyFromClauseContext() *FromClauseContext {
|
|
var p = new(FromClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fromClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFromClauseContext(p *FromClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fromClause
|
|
}
|
|
|
|
func (*FromClauseContext) IsFromClauseContext() {}
|
|
|
|
func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromClauseContext {
|
|
var p = new(FromClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fromClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FromClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FromClauseContext) GetWhereExpr() IExpressionContext { return s.whereExpr }
|
|
|
|
func (s *FromClauseContext) SetWhereExpr(v IExpressionContext) { s.whereExpr = v }
|
|
|
|
func (s *FromClauseContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *FromClauseContext) TableSources() ITableSourcesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableSourcesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableSourcesContext)
|
|
}
|
|
|
|
func (s *FromClauseContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *FromClauseContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *FromClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FromClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FromClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFromClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFromClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *FromClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFromClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FromClause() (localctx IFromClauseContext) {
|
|
localctx = NewFromClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 284, MySqlParserRULE_fromClause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4207)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM {
|
|
{
|
|
p.SetState(4205)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4206)
|
|
p.TableSources()
|
|
}
|
|
|
|
}
|
|
p.SetState(4211)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(4209)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4210)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*FromClauseContext).whereExpr = _x
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IGroupByClauseContext is an interface to support dynamic dispatch.
|
|
type IGroupByClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
GROUP() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
AllGroupByItem() []IGroupByItemContext
|
|
GroupByItem(i int) IGroupByItemContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WITH() antlr.TerminalNode
|
|
ROLLUP() antlr.TerminalNode
|
|
|
|
// IsGroupByClauseContext differentiates from other interfaces.
|
|
IsGroupByClauseContext()
|
|
}
|
|
|
|
type GroupByClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyGroupByClauseContext() *GroupByClauseContext {
|
|
var p = new(GroupByClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_groupByClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyGroupByClauseContext(p *GroupByClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_groupByClause
|
|
}
|
|
|
|
func (*GroupByClauseContext) IsGroupByClauseContext() {}
|
|
|
|
func NewGroupByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByClauseContext {
|
|
var p = new(GroupByClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_groupByClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GroupByClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *GroupByClauseContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) AllGroupByItem() []IGroupByItemContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IGroupByItemContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IGroupByItemContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IGroupByItemContext); ok {
|
|
tst[i] = t.(IGroupByItemContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GroupByClauseContext) GroupByItem(i int) IGroupByItemContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGroupByItemContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGroupByItemContext)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) ROLLUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLUP, 0)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GroupByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *GroupByClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGroupByClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *GroupByClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGroupByClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *GroupByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGroupByClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) GroupByClause() (localctx IGroupByClauseContext) {
|
|
localctx = NewGroupByClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 286, MySqlParserRULE_groupByClause)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4213)
|
|
p.Match(MySqlParserGROUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4214)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4215)
|
|
p.GroupByItem()
|
|
}
|
|
p.SetState(4220)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4216)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4217)
|
|
p.GroupByItem()
|
|
}
|
|
|
|
}
|
|
p.SetState(4222)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4225)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4223)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4224)
|
|
p.Match(MySqlParserROLLUP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHavingClauseContext is an interface to support dynamic dispatch.
|
|
type IHavingClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetHavingExpr returns the havingExpr rule contexts.
|
|
GetHavingExpr() IExpressionContext
|
|
|
|
// SetHavingExpr sets the havingExpr rule contexts.
|
|
SetHavingExpr(IExpressionContext)
|
|
|
|
// Getter signatures
|
|
HAVING() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsHavingClauseContext differentiates from other interfaces.
|
|
IsHavingClauseContext()
|
|
}
|
|
|
|
type HavingClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
havingExpr IExpressionContext
|
|
}
|
|
|
|
func NewEmptyHavingClauseContext() *HavingClauseContext {
|
|
var p = new(HavingClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_havingClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHavingClauseContext(p *HavingClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_havingClause
|
|
}
|
|
|
|
func (*HavingClauseContext) IsHavingClauseContext() {}
|
|
|
|
func NewHavingClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HavingClauseContext {
|
|
var p = new(HavingClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_havingClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HavingClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HavingClauseContext) GetHavingExpr() IExpressionContext { return s.havingExpr }
|
|
|
|
func (s *HavingClauseContext) SetHavingExpr(v IExpressionContext) { s.havingExpr = v }
|
|
|
|
func (s *HavingClauseContext) HAVING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHAVING, 0)
|
|
}
|
|
|
|
func (s *HavingClauseContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *HavingClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HavingClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HavingClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHavingClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *HavingClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHavingClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *HavingClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHavingClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HavingClause() (localctx IHavingClauseContext) {
|
|
localctx = NewHavingClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 288, MySqlParserRULE_havingClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4227)
|
|
p.Match(MySqlParserHAVING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4228)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*HavingClauseContext).havingExpr = _x
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWindowClauseContext is an interface to support dynamic dispatch.
|
|
type IWindowClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WINDOW() antlr.TerminalNode
|
|
AllWindowName() []IWindowNameContext
|
|
WindowName(i int) IWindowNameContext
|
|
AllAS() []antlr.TerminalNode
|
|
AS(i int) antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllWindowSpec() []IWindowSpecContext
|
|
WindowSpec(i int) IWindowSpecContext
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsWindowClauseContext differentiates from other interfaces.
|
|
IsWindowClauseContext()
|
|
}
|
|
|
|
type WindowClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWindowClauseContext() *WindowClauseContext {
|
|
var p = new(WindowClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWindowClauseContext(p *WindowClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowClause
|
|
}
|
|
|
|
func (*WindowClauseContext) IsWindowClauseContext() {}
|
|
|
|
func NewWindowClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowClauseContext {
|
|
var p = new(WindowClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_windowClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WindowClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WindowClauseContext) WINDOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWINDOW, 0)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllWindowName() []IWindowNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IWindowNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IWindowNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IWindowNameContext); ok {
|
|
tst[i] = t.(IWindowNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WindowClauseContext) WindowName(i int) IWindowNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowNameContext)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllAS() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserAS)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AS(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, i)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *WindowClauseContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllWindowSpec() []IWindowSpecContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IWindowSpecContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IWindowSpecContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IWindowSpecContext); ok {
|
|
tst[i] = t.(IWindowSpecContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WindowClauseContext) WindowSpec(i int) IWindowSpecContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowSpecContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowSpecContext)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *WindowClauseContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *WindowClauseContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *WindowClauseContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *WindowClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WindowClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WindowClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWindowClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWindowClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWindowClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WindowClause() (localctx IWindowClauseContext) {
|
|
localctx = NewWindowClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 290, MySqlParserRULE_windowClause)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4230)
|
|
p.Match(MySqlParserWINDOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4231)
|
|
p.WindowName()
|
|
}
|
|
{
|
|
p.SetState(4232)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4233)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4234)
|
|
p.WindowSpec()
|
|
}
|
|
{
|
|
p.SetState(4235)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4245)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4236)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4237)
|
|
p.WindowName()
|
|
}
|
|
{
|
|
p.SetState(4238)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4239)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4240)
|
|
p.WindowSpec()
|
|
}
|
|
{
|
|
p.SetState(4241)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4247)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IGroupByItemContext is an interface to support dynamic dispatch.
|
|
type IGroupByItemContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOrder returns the order token.
|
|
GetOrder() antlr.Token
|
|
|
|
// SetOrder sets the order token.
|
|
SetOrder(antlr.Token)
|
|
|
|
// Getter signatures
|
|
Expression() IExpressionContext
|
|
ASC() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
|
|
// IsGroupByItemContext differentiates from other interfaces.
|
|
IsGroupByItemContext()
|
|
}
|
|
|
|
type GroupByItemContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
order antlr.Token
|
|
}
|
|
|
|
func NewEmptyGroupByItemContext() *GroupByItemContext {
|
|
var p = new(GroupByItemContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_groupByItem
|
|
return p
|
|
}
|
|
|
|
func InitEmptyGroupByItemContext(p *GroupByItemContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_groupByItem
|
|
}
|
|
|
|
func (*GroupByItemContext) IsGroupByItemContext() {}
|
|
|
|
func NewGroupByItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByItemContext {
|
|
var p = new(GroupByItemContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_groupByItem
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GroupByItemContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *GroupByItemContext) GetOrder() antlr.Token { return s.order }
|
|
|
|
func (s *GroupByItemContext) SetOrder(v antlr.Token) { s.order = v }
|
|
|
|
func (s *GroupByItemContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *GroupByItemContext) ASC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASC, 0)
|
|
}
|
|
|
|
func (s *GroupByItemContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *GroupByItemContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GroupByItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *GroupByItemContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGroupByItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *GroupByItemContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGroupByItem(s)
|
|
}
|
|
}
|
|
|
|
func (s *GroupByItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGroupByItem(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) GroupByItem() (localctx IGroupByItemContext) {
|
|
localctx = NewGroupByItemContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 292, MySqlParserRULE_groupByItem)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4248)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(4250)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4249)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*GroupByItemContext).order = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserASC || _la == MySqlParserDESC) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*GroupByItemContext).order = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILimitClauseContext is an interface to support dynamic dispatch.
|
|
type ILimitClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOffset returns the offset rule contexts.
|
|
GetOffset() ILimitClauseAtomContext
|
|
|
|
// GetLimit returns the limit rule contexts.
|
|
GetLimit() ILimitClauseAtomContext
|
|
|
|
// SetOffset sets the offset rule contexts.
|
|
SetOffset(ILimitClauseAtomContext)
|
|
|
|
// SetLimit sets the limit rule contexts.
|
|
SetLimit(ILimitClauseAtomContext)
|
|
|
|
// Getter signatures
|
|
LIMIT() antlr.TerminalNode
|
|
OFFSET() antlr.TerminalNode
|
|
AllLimitClauseAtom() []ILimitClauseAtomContext
|
|
LimitClauseAtom(i int) ILimitClauseAtomContext
|
|
COMMA() antlr.TerminalNode
|
|
|
|
// IsLimitClauseContext differentiates from other interfaces.
|
|
IsLimitClauseContext()
|
|
}
|
|
|
|
type LimitClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
offset ILimitClauseAtomContext
|
|
limit ILimitClauseAtomContext
|
|
}
|
|
|
|
func NewEmptyLimitClauseContext() *LimitClauseContext {
|
|
var p = new(LimitClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_limitClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLimitClauseContext(p *LimitClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_limitClause
|
|
}
|
|
|
|
func (*LimitClauseContext) IsLimitClauseContext() {}
|
|
|
|
func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext {
|
|
var p = new(LimitClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_limitClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LimitClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LimitClauseContext) GetOffset() ILimitClauseAtomContext { return s.offset }
|
|
|
|
func (s *LimitClauseContext) GetLimit() ILimitClauseAtomContext { return s.limit }
|
|
|
|
func (s *LimitClauseContext) SetOffset(v ILimitClauseAtomContext) { s.offset = v }
|
|
|
|
func (s *LimitClauseContext) SetLimit(v ILimitClauseAtomContext) { s.limit = v }
|
|
|
|
func (s *LimitClauseContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *LimitClauseContext) OFFSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFSET, 0)
|
|
}
|
|
|
|
func (s *LimitClauseContext) AllLimitClauseAtom() []ILimitClauseAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ILimitClauseAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
tst[i] = t.(ILimitClauseAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LimitClauseContext) LimitClauseAtom(i int) ILimitClauseAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseAtomContext)
|
|
}
|
|
|
|
func (s *LimitClauseContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLimitClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLimitClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLimitClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LimitClause() (localctx ILimitClauseContext) {
|
|
localctx = NewLimitClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 294, MySqlParserRULE_limitClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4252)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4263)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 624, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.SetState(4256)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 623, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4253)
|
|
|
|
var _x = p.LimitClauseAtom()
|
|
|
|
localctx.(*LimitClauseContext).offset = _x
|
|
}
|
|
{
|
|
p.SetState(4254)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4258)
|
|
|
|
var _x = p.LimitClauseAtom()
|
|
|
|
localctx.(*LimitClauseContext).limit = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(4259)
|
|
|
|
var _x = p.LimitClauseAtom()
|
|
|
|
localctx.(*LimitClauseContext).limit = _x
|
|
}
|
|
{
|
|
p.SetState(4260)
|
|
p.Match(MySqlParserOFFSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4261)
|
|
|
|
var _x = p.LimitClauseAtom()
|
|
|
|
localctx.(*LimitClauseContext).offset = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILimitClauseAtomContext is an interface to support dynamic dispatch.
|
|
type ILimitClauseAtomContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
MysqlVariable() IMysqlVariableContext
|
|
SimpleId() ISimpleIdContext
|
|
|
|
// IsLimitClauseAtomContext differentiates from other interfaces.
|
|
IsLimitClauseAtomContext()
|
|
}
|
|
|
|
type LimitClauseAtomContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLimitClauseAtomContext() *LimitClauseAtomContext {
|
|
var p = new(LimitClauseAtomContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_limitClauseAtom
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLimitClauseAtomContext(p *LimitClauseAtomContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_limitClauseAtom
|
|
}
|
|
|
|
func (*LimitClauseAtomContext) IsLimitClauseAtomContext() {}
|
|
|
|
func NewLimitClauseAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseAtomContext {
|
|
var p = new(LimitClauseAtomContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_limitClauseAtom
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LimitClauseAtomContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) MysqlVariable() IMysqlVariableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMysqlVariableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMysqlVariableContext)
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) SimpleId() ISimpleIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleIdContext)
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLimitClauseAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLimitClauseAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *LimitClauseAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLimitClauseAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LimitClauseAtom() (localctx ILimitClauseAtomContext) {
|
|
localctx = NewLimitClauseAtomContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 296, MySqlParserRULE_limitClauseAtom)
|
|
p.SetState(4268)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4265)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4266)
|
|
p.MysqlVariable()
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4267)
|
|
p.SimpleId()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStartTransactionContext is an interface to support dynamic dispatch.
|
|
type IStartTransactionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
START() antlr.TerminalNode
|
|
TRANSACTION() antlr.TerminalNode
|
|
AllTransactionMode() []ITransactionModeContext
|
|
TransactionMode(i int) ITransactionModeContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsStartTransactionContext differentiates from other interfaces.
|
|
IsStartTransactionContext()
|
|
}
|
|
|
|
type StartTransactionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStartTransactionContext() *StartTransactionContext {
|
|
var p = new(StartTransactionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startTransaction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStartTransactionContext(p *StartTransactionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startTransaction
|
|
}
|
|
|
|
func (*StartTransactionContext) IsStartTransactionContext() {}
|
|
|
|
func NewStartTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartTransactionContext {
|
|
var p = new(StartTransactionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_startTransaction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StartTransactionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StartTransactionContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *StartTransactionContext) TRANSACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTION, 0)
|
|
}
|
|
|
|
func (s *StartTransactionContext) AllTransactionMode() []ITransactionModeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITransactionModeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITransactionModeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITransactionModeContext); ok {
|
|
tst[i] = t.(ITransactionModeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *StartTransactionContext) TransactionMode(i int) ITransactionModeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITransactionModeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITransactionModeContext)
|
|
}
|
|
|
|
func (s *StartTransactionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *StartTransactionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *StartTransactionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StartTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StartTransactionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartTransactionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStartTransaction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StartTransaction() (localctx IStartTransactionContext) {
|
|
localctx = NewStartTransactionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 298, MySqlParserRULE_startTransaction)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4270)
|
|
p.Match(MySqlParserSTART)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4271)
|
|
p.Match(MySqlParserTRANSACTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4280)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4272)
|
|
p.TransactionMode()
|
|
}
|
|
p.SetState(4277)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4273)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4274)
|
|
p.TransactionMode()
|
|
}
|
|
|
|
p.SetState(4279)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBeginWorkContext is an interface to support dynamic dispatch.
|
|
type IBeginWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BEGIN() antlr.TerminalNode
|
|
WORK() antlr.TerminalNode
|
|
|
|
// IsBeginWorkContext differentiates from other interfaces.
|
|
IsBeginWorkContext()
|
|
}
|
|
|
|
type BeginWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBeginWorkContext() *BeginWorkContext {
|
|
var p = new(BeginWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_beginWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBeginWorkContext(p *BeginWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_beginWork
|
|
}
|
|
|
|
func (*BeginWorkContext) IsBeginWorkContext() {}
|
|
|
|
func NewBeginWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BeginWorkContext {
|
|
var p = new(BeginWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_beginWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BeginWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BeginWorkContext) BEGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEGIN, 0)
|
|
}
|
|
|
|
func (s *BeginWorkContext) WORK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWORK, 0)
|
|
}
|
|
|
|
func (s *BeginWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BeginWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BeginWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBeginWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *BeginWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBeginWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *BeginWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBeginWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BeginWork() (localctx IBeginWorkContext) {
|
|
localctx = NewBeginWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 300, MySqlParserRULE_beginWork)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4282)
|
|
p.Match(MySqlParserBEGIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4284)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWORK {
|
|
{
|
|
p.SetState(4283)
|
|
p.Match(MySqlParserWORK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICommitWorkContext is an interface to support dynamic dispatch.
|
|
type ICommitWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetNochain returns the nochain token.
|
|
GetNochain() antlr.Token
|
|
|
|
// GetNorelease returns the norelease token.
|
|
GetNorelease() antlr.Token
|
|
|
|
// SetNochain sets the nochain token.
|
|
SetNochain(antlr.Token)
|
|
|
|
// SetNorelease sets the norelease token.
|
|
SetNorelease(antlr.Token)
|
|
|
|
// Getter signatures
|
|
COMMIT() antlr.TerminalNode
|
|
WORK() antlr.TerminalNode
|
|
AND() antlr.TerminalNode
|
|
CHAIN() antlr.TerminalNode
|
|
RELEASE() antlr.TerminalNode
|
|
AllNO() []antlr.TerminalNode
|
|
NO(i int) antlr.TerminalNode
|
|
|
|
// IsCommitWorkContext differentiates from other interfaces.
|
|
IsCommitWorkContext()
|
|
}
|
|
|
|
type CommitWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
nochain antlr.Token
|
|
norelease antlr.Token
|
|
}
|
|
|
|
func NewEmptyCommitWorkContext() *CommitWorkContext {
|
|
var p = new(CommitWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_commitWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCommitWorkContext(p *CommitWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_commitWork
|
|
}
|
|
|
|
func (*CommitWorkContext) IsCommitWorkContext() {}
|
|
|
|
func NewCommitWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommitWorkContext {
|
|
var p = new(CommitWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_commitWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CommitWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CommitWorkContext) GetNochain() antlr.Token { return s.nochain }
|
|
|
|
func (s *CommitWorkContext) GetNorelease() antlr.Token { return s.norelease }
|
|
|
|
func (s *CommitWorkContext) SetNochain(v antlr.Token) { s.nochain = v }
|
|
|
|
func (s *CommitWorkContext) SetNorelease(v antlr.Token) { s.norelease = v }
|
|
|
|
func (s *CommitWorkContext) COMMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMIT, 0)
|
|
}
|
|
|
|
func (s *CommitWorkContext) WORK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWORK, 0)
|
|
}
|
|
|
|
func (s *CommitWorkContext) AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, 0)
|
|
}
|
|
|
|
func (s *CommitWorkContext) CHAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAIN, 0)
|
|
}
|
|
|
|
func (s *CommitWorkContext) RELEASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELEASE, 0)
|
|
}
|
|
|
|
func (s *CommitWorkContext) AllNO() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserNO)
|
|
}
|
|
|
|
func (s *CommitWorkContext) NO(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, i)
|
|
}
|
|
|
|
func (s *CommitWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CommitWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CommitWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCommitWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommitWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCommitWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *CommitWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCommitWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CommitWork() (localctx ICommitWorkContext) {
|
|
localctx = NewCommitWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 302, MySqlParserRULE_commitWork)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4286)
|
|
p.Match(MySqlParserCOMMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4288)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWORK {
|
|
{
|
|
p.SetState(4287)
|
|
p.Match(MySqlParserWORK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4295)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAND {
|
|
{
|
|
p.SetState(4290)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4292)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO {
|
|
{
|
|
p.SetState(4291)
|
|
|
|
var _m = p.Match(MySqlParserNO)
|
|
|
|
localctx.(*CommitWorkContext).nochain = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4294)
|
|
p.Match(MySqlParserCHAIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4301)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4298)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO {
|
|
{
|
|
p.SetState(4297)
|
|
|
|
var _m = p.Match(MySqlParserNO)
|
|
|
|
localctx.(*CommitWorkContext).norelease = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4300)
|
|
p.Match(MySqlParserRELEASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRollbackWorkContext is an interface to support dynamic dispatch.
|
|
type IRollbackWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetNochain returns the nochain token.
|
|
GetNochain() antlr.Token
|
|
|
|
// GetNorelease returns the norelease token.
|
|
GetNorelease() antlr.Token
|
|
|
|
// SetNochain sets the nochain token.
|
|
SetNochain(antlr.Token)
|
|
|
|
// SetNorelease sets the norelease token.
|
|
SetNorelease(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ROLLBACK() antlr.TerminalNode
|
|
WORK() antlr.TerminalNode
|
|
AND() antlr.TerminalNode
|
|
CHAIN() antlr.TerminalNode
|
|
RELEASE() antlr.TerminalNode
|
|
AllNO() []antlr.TerminalNode
|
|
NO(i int) antlr.TerminalNode
|
|
|
|
// IsRollbackWorkContext differentiates from other interfaces.
|
|
IsRollbackWorkContext()
|
|
}
|
|
|
|
type RollbackWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
nochain antlr.Token
|
|
norelease antlr.Token
|
|
}
|
|
|
|
func NewEmptyRollbackWorkContext() *RollbackWorkContext {
|
|
var p = new(RollbackWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_rollbackWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRollbackWorkContext(p *RollbackWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_rollbackWork
|
|
}
|
|
|
|
func (*RollbackWorkContext) IsRollbackWorkContext() {}
|
|
|
|
func NewRollbackWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackWorkContext {
|
|
var p = new(RollbackWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_rollbackWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RollbackWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RollbackWorkContext) GetNochain() antlr.Token { return s.nochain }
|
|
|
|
func (s *RollbackWorkContext) GetNorelease() antlr.Token { return s.norelease }
|
|
|
|
func (s *RollbackWorkContext) SetNochain(v antlr.Token) { s.nochain = v }
|
|
|
|
func (s *RollbackWorkContext) SetNorelease(v antlr.Token) { s.norelease = v }
|
|
|
|
func (s *RollbackWorkContext) ROLLBACK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLBACK, 0)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) WORK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWORK, 0)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, 0)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) CHAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAIN, 0)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) RELEASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELEASE, 0)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) AllNO() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserNO)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) NO(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, i)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RollbackWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RollbackWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRollbackWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *RollbackWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRollbackWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *RollbackWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRollbackWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RollbackWork() (localctx IRollbackWorkContext) {
|
|
localctx = NewRollbackWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 304, MySqlParserRULE_rollbackWork)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4303)
|
|
p.Match(MySqlParserROLLBACK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4305)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWORK {
|
|
{
|
|
p.SetState(4304)
|
|
p.Match(MySqlParserWORK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4312)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAND {
|
|
{
|
|
p.SetState(4307)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4309)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO {
|
|
{
|
|
p.SetState(4308)
|
|
|
|
var _m = p.Match(MySqlParserNO)
|
|
|
|
localctx.(*RollbackWorkContext).nochain = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4311)
|
|
p.Match(MySqlParserCHAIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4318)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 638, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4315)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO {
|
|
{
|
|
p.SetState(4314)
|
|
|
|
var _m = p.Match(MySqlParserNO)
|
|
|
|
localctx.(*RollbackWorkContext).norelease = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4317)
|
|
p.Match(MySqlParserRELEASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISavepointStatementContext is an interface to support dynamic dispatch.
|
|
type ISavepointStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SAVEPOINT() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsSavepointStatementContext differentiates from other interfaces.
|
|
IsSavepointStatementContext()
|
|
}
|
|
|
|
type SavepointStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySavepointStatementContext() *SavepointStatementContext {
|
|
var p = new(SavepointStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_savepointStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySavepointStatementContext(p *SavepointStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_savepointStatement
|
|
}
|
|
|
|
func (*SavepointStatementContext) IsSavepointStatementContext() {}
|
|
|
|
func NewSavepointStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SavepointStatementContext {
|
|
var p = new(SavepointStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_savepointStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SavepointStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SavepointStatementContext) SAVEPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSAVEPOINT, 0)
|
|
}
|
|
|
|
func (s *SavepointStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SavepointStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SavepointStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SavepointStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSavepointStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SavepointStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSavepointStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SavepointStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSavepointStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SavepointStatement() (localctx ISavepointStatementContext) {
|
|
localctx = NewSavepointStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 306, MySqlParserRULE_savepointStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4320)
|
|
p.Match(MySqlParserSAVEPOINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4321)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRollbackStatementContext is an interface to support dynamic dispatch.
|
|
type IRollbackStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ROLLBACK() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
WORK() antlr.TerminalNode
|
|
SAVEPOINT() antlr.TerminalNode
|
|
|
|
// IsRollbackStatementContext differentiates from other interfaces.
|
|
IsRollbackStatementContext()
|
|
}
|
|
|
|
type RollbackStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRollbackStatementContext() *RollbackStatementContext {
|
|
var p = new(RollbackStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_rollbackStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRollbackStatementContext(p *RollbackStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_rollbackStatement
|
|
}
|
|
|
|
func (*RollbackStatementContext) IsRollbackStatementContext() {}
|
|
|
|
func NewRollbackStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackStatementContext {
|
|
var p = new(RollbackStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_rollbackStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RollbackStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RollbackStatementContext) ROLLBACK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLBACK, 0)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) WORK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWORK, 0)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) SAVEPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSAVEPOINT, 0)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RollbackStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RollbackStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRollbackStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *RollbackStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRollbackStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *RollbackStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRollbackStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RollbackStatement() (localctx IRollbackStatementContext) {
|
|
localctx = NewRollbackStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 308, MySqlParserRULE_rollbackStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4323)
|
|
p.Match(MySqlParserROLLBACK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4325)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWORK {
|
|
{
|
|
p.SetState(4324)
|
|
p.Match(MySqlParserWORK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4327)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4329)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4328)
|
|
p.Match(MySqlParserSAVEPOINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4331)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReleaseStatementContext is an interface to support dynamic dispatch.
|
|
type IReleaseStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RELEASE() antlr.TerminalNode
|
|
SAVEPOINT() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsReleaseStatementContext differentiates from other interfaces.
|
|
IsReleaseStatementContext()
|
|
}
|
|
|
|
type ReleaseStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyReleaseStatementContext() *ReleaseStatementContext {
|
|
var p = new(ReleaseStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_releaseStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReleaseStatementContext(p *ReleaseStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_releaseStatement
|
|
}
|
|
|
|
func (*ReleaseStatementContext) IsReleaseStatementContext() {}
|
|
|
|
func NewReleaseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReleaseStatementContext {
|
|
var p = new(ReleaseStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_releaseStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReleaseStatementContext) RELEASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELEASE, 0)
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) SAVEPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSAVEPOINT, 0)
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReleaseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReleaseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReleaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReleaseStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReleaseStatement() (localctx IReleaseStatementContext) {
|
|
localctx = NewReleaseStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 310, MySqlParserRULE_releaseStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4333)
|
|
p.Match(MySqlParserRELEASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4334)
|
|
p.Match(MySqlParserSAVEPOINT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4335)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILockTablesContext is an interface to support dynamic dispatch.
|
|
type ILockTablesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LOCK() antlr.TerminalNode
|
|
AllLockTableElement() []ILockTableElementContext
|
|
LockTableElement(i int) ILockTableElementContext
|
|
TABLE() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WaitNowaitClause() IWaitNowaitClauseContext
|
|
|
|
// IsLockTablesContext differentiates from other interfaces.
|
|
IsLockTablesContext()
|
|
}
|
|
|
|
type LockTablesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLockTablesContext() *LockTablesContext {
|
|
var p = new(LockTablesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockTables
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLockTablesContext(p *LockTablesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockTables
|
|
}
|
|
|
|
func (*LockTablesContext) IsLockTablesContext() {}
|
|
|
|
func NewLockTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockTablesContext {
|
|
var p = new(LockTablesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lockTables
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LockTablesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LockTablesContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *LockTablesContext) AllLockTableElement() []ILockTableElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ILockTableElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ILockTableElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ILockTableElementContext); ok {
|
|
tst[i] = t.(ILockTableElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LockTablesContext) LockTableElement(i int) ILockTableElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockTableElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockTableElementContext)
|
|
}
|
|
|
|
func (s *LockTablesContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *LockTablesContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *LockTablesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *LockTablesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *LockTablesContext) WaitNowaitClause() IWaitNowaitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWaitNowaitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWaitNowaitClauseContext)
|
|
}
|
|
|
|
func (s *LockTablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LockTablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LockTablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLockTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockTablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLockTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLockTables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LockTables() (localctx ILockTablesContext) {
|
|
localctx = NewLockTablesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 312, MySqlParserRULE_lockTables)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4337)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4338)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4339)
|
|
p.LockTableElement()
|
|
}
|
|
p.SetState(4344)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4340)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4341)
|
|
p.LockTableElement()
|
|
}
|
|
|
|
p.SetState(4346)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4348)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOWAIT || _la == MySqlParserWAIT {
|
|
{
|
|
p.SetState(4347)
|
|
p.WaitNowaitClause()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUnlockTablesContext is an interface to support dynamic dispatch.
|
|
type IUnlockTablesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
UNLOCK() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
|
|
// IsUnlockTablesContext differentiates from other interfaces.
|
|
IsUnlockTablesContext()
|
|
}
|
|
|
|
type UnlockTablesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUnlockTablesContext() *UnlockTablesContext {
|
|
var p = new(UnlockTablesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unlockTables
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUnlockTablesContext(p *UnlockTablesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unlockTables
|
|
}
|
|
|
|
func (*UnlockTablesContext) IsUnlockTablesContext() {}
|
|
|
|
func NewUnlockTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlockTablesContext {
|
|
var p = new(UnlockTablesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_unlockTables
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnlockTablesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UnlockTablesContext) UNLOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNLOCK, 0)
|
|
}
|
|
|
|
func (s *UnlockTablesContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *UnlockTablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnlockTablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UnlockTablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnlockTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnlockTablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnlockTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnlockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnlockTables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UnlockTables() (localctx IUnlockTablesContext) {
|
|
localctx = NewUnlockTablesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 314, MySqlParserRULE_unlockTables)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4350)
|
|
p.Match(MySqlParserUNLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4351)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISetAutocommitStatementContext is an interface to support dynamic dispatch.
|
|
type ISetAutocommitStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetAutocommitValue returns the autocommitValue token.
|
|
GetAutocommitValue() antlr.Token
|
|
|
|
// SetAutocommitValue sets the autocommitValue token.
|
|
SetAutocommitValue(antlr.Token)
|
|
|
|
// Getter signatures
|
|
SET() antlr.TerminalNode
|
|
AUTOCOMMIT() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
ZERO_DECIMAL() antlr.TerminalNode
|
|
ONE_DECIMAL() antlr.TerminalNode
|
|
|
|
// IsSetAutocommitStatementContext differentiates from other interfaces.
|
|
IsSetAutocommitStatementContext()
|
|
}
|
|
|
|
type SetAutocommitStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
autocommitValue antlr.Token
|
|
}
|
|
|
|
func NewEmptySetAutocommitStatementContext() *SetAutocommitStatementContext {
|
|
var p = new(SetAutocommitStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setAutocommitStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySetAutocommitStatementContext(p *SetAutocommitStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setAutocommitStatement
|
|
}
|
|
|
|
func (*SetAutocommitStatementContext) IsSetAutocommitStatementContext() {}
|
|
|
|
func NewSetAutocommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetAutocommitStatementContext {
|
|
var p = new(SetAutocommitStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_setAutocommitStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SetAutocommitStatementContext) GetAutocommitValue() antlr.Token { return s.autocommitValue }
|
|
|
|
func (s *SetAutocommitStatementContext) SetAutocommitValue(v antlr.Token) { s.autocommitValue = v }
|
|
|
|
func (s *SetAutocommitStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) AUTOCOMMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTOCOMMIT, 0)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetAutocommitStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetAutocommitStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetAutocommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetAutocommitStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SetAutocommitStatement() (localctx ISetAutocommitStatementContext) {
|
|
localctx = NewSetAutocommitStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 316, MySqlParserRULE_setAutocommitStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4353)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4354)
|
|
p.Match(MySqlParserAUTOCOMMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4355)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4356)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SetAutocommitStatementContext).autocommitValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SetAutocommitStatementContext).autocommitValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISetTransactionStatementContext is an interface to support dynamic dispatch.
|
|
type ISetTransactionStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetTransactionContext returns the transactionContext token.
|
|
GetTransactionContext() antlr.Token
|
|
|
|
// SetTransactionContext sets the transactionContext token.
|
|
SetTransactionContext(antlr.Token)
|
|
|
|
// Getter signatures
|
|
SET() antlr.TerminalNode
|
|
TRANSACTION() antlr.TerminalNode
|
|
AllTransactionOption() []ITransactionOptionContext
|
|
TransactionOption(i int) ITransactionOptionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
GLOBAL() antlr.TerminalNode
|
|
SESSION() antlr.TerminalNode
|
|
|
|
// IsSetTransactionStatementContext differentiates from other interfaces.
|
|
IsSetTransactionStatementContext()
|
|
}
|
|
|
|
type SetTransactionStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
transactionContext antlr.Token
|
|
}
|
|
|
|
func NewEmptySetTransactionStatementContext() *SetTransactionStatementContext {
|
|
var p = new(SetTransactionStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setTransactionStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySetTransactionStatementContext(p *SetTransactionStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setTransactionStatement
|
|
}
|
|
|
|
func (*SetTransactionStatementContext) IsSetTransactionStatementContext() {}
|
|
|
|
func NewSetTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetTransactionStatementContext {
|
|
var p = new(SetTransactionStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_setTransactionStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SetTransactionStatementContext) GetTransactionContext() antlr.Token {
|
|
return s.transactionContext
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) SetTransactionContext(v antlr.Token) {
|
|
s.transactionContext = v
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) TRANSACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTION, 0)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) AllTransactionOption() []ITransactionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITransactionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITransactionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITransactionOptionContext); ok {
|
|
tst[i] = t.(ITransactionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) TransactionOption(i int) ITransactionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITransactionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITransactionOptionContext)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) GLOBAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL, 0)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) SESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION, 0)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetTransactionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetTransactionStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetTransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetTransactionStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SetTransactionStatement() (localctx ISetTransactionStatementContext) {
|
|
localctx = NewSetTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 318, MySqlParserRULE_setTransactionStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4358)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4360)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserGLOBAL || _la == MySqlParserSESSION {
|
|
{
|
|
p.SetState(4359)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SetTransactionStatementContext).transactionContext = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserGLOBAL || _la == MySqlParserSESSION) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SetTransactionStatementContext).transactionContext = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4362)
|
|
p.Match(MySqlParserTRANSACTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4363)
|
|
p.TransactionOption()
|
|
}
|
|
p.SetState(4368)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4364)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4365)
|
|
p.TransactionOption()
|
|
}
|
|
|
|
p.SetState(4370)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITransactionModeContext is an interface to support dynamic dispatch.
|
|
type ITransactionModeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WITH() antlr.TerminalNode
|
|
CONSISTENT() antlr.TerminalNode
|
|
SNAPSHOT() antlr.TerminalNode
|
|
READ() antlr.TerminalNode
|
|
WRITE() antlr.TerminalNode
|
|
ONLY() antlr.TerminalNode
|
|
|
|
// IsTransactionModeContext differentiates from other interfaces.
|
|
IsTransactionModeContext()
|
|
}
|
|
|
|
type TransactionModeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTransactionModeContext() *TransactionModeContext {
|
|
var p = new(TransactionModeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionMode
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTransactionModeContext(p *TransactionModeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionMode
|
|
}
|
|
|
|
func (*TransactionModeContext) IsTransactionModeContext() {}
|
|
|
|
func NewTransactionModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionModeContext {
|
|
var p = new(TransactionModeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_transactionMode
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TransactionModeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TransactionModeContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) CONSISTENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSISTENT, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) SNAPSHOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSNAPSHOT, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) WRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWRITE, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) ONLY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLY, 0)
|
|
}
|
|
|
|
func (s *TransactionModeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TransactionModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TransactionModeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTransactionMode(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionModeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTransactionMode(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTransactionMode(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TransactionMode() (localctx ITransactionModeContext) {
|
|
localctx = NewTransactionModeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 320, MySqlParserRULE_transactionMode)
|
|
p.SetState(4378)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4371)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4372)
|
|
p.Match(MySqlParserCONSISTENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4373)
|
|
p.Match(MySqlParserSNAPSHOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4374)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4375)
|
|
p.Match(MySqlParserWRITE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4376)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4377)
|
|
p.Match(MySqlParserONLY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILockTableElementContext is an interface to support dynamic dispatch.
|
|
type ILockTableElementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
TableName() ITableNameContext
|
|
LockAction() ILockActionContext
|
|
Uid() IUidContext
|
|
AS() antlr.TerminalNode
|
|
|
|
// IsLockTableElementContext differentiates from other interfaces.
|
|
IsLockTableElementContext()
|
|
}
|
|
|
|
type LockTableElementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLockTableElementContext() *LockTableElementContext {
|
|
var p = new(LockTableElementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockTableElement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLockTableElementContext(p *LockTableElementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockTableElement
|
|
}
|
|
|
|
func (*LockTableElementContext) IsLockTableElementContext() {}
|
|
|
|
func NewLockTableElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockTableElementContext {
|
|
var p = new(LockTableElementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lockTableElement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LockTableElementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LockTableElementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *LockTableElementContext) LockAction() ILockActionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILockActionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILockActionContext)
|
|
}
|
|
|
|
func (s *LockTableElementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *LockTableElementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *LockTableElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LockTableElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LockTableElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLockTableElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockTableElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLockTableElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockTableElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLockTableElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LockTableElement() (localctx ILockTableElementContext) {
|
|
localctx = NewLockTableElementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 322, MySqlParserRULE_lockTableElement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4380)
|
|
p.TableName()
|
|
}
|
|
p.SetState(4385)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513126400) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
p.SetState(4382)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(4381)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4384)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4387)
|
|
p.LockAction()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILockActionContext is an interface to support dynamic dispatch.
|
|
type ILockActionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
READ() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
WRITE() antlr.TerminalNode
|
|
LOW_PRIORITY() antlr.TerminalNode
|
|
|
|
// IsLockActionContext differentiates from other interfaces.
|
|
IsLockActionContext()
|
|
}
|
|
|
|
type LockActionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLockActionContext() *LockActionContext {
|
|
var p = new(LockActionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockAction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLockActionContext(p *LockActionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lockAction
|
|
}
|
|
|
|
func (*LockActionContext) IsLockActionContext() {}
|
|
|
|
func NewLockActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockActionContext {
|
|
var p = new(LockActionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lockAction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LockActionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LockActionContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *LockActionContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *LockActionContext) WRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWRITE, 0)
|
|
}
|
|
|
|
func (s *LockActionContext) LOW_PRIORITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOW_PRIORITY, 0)
|
|
}
|
|
|
|
func (s *LockActionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LockActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LockActionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLockAction(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockActionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLockAction(s)
|
|
}
|
|
}
|
|
|
|
func (s *LockActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLockAction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LockAction() (localctx ILockActionContext) {
|
|
localctx = NewLockActionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 324, MySqlParserRULE_lockAction)
|
|
var _la int
|
|
|
|
p.SetState(4397)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserREAD:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4389)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4391)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(4390)
|
|
p.Match(MySqlParserLOCAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserLOW_PRIORITY, MySqlParserWRITE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(4394)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLOW_PRIORITY {
|
|
{
|
|
p.SetState(4393)
|
|
p.Match(MySqlParserLOW_PRIORITY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4396)
|
|
p.Match(MySqlParserWRITE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITransactionOptionContext is an interface to support dynamic dispatch.
|
|
type ITransactionOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ISOLATION() antlr.TerminalNode
|
|
LEVEL() antlr.TerminalNode
|
|
TransactionLevel() ITransactionLevelContext
|
|
READ() antlr.TerminalNode
|
|
WRITE() antlr.TerminalNode
|
|
ONLY() antlr.TerminalNode
|
|
|
|
// IsTransactionOptionContext differentiates from other interfaces.
|
|
IsTransactionOptionContext()
|
|
}
|
|
|
|
type TransactionOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTransactionOptionContext() *TransactionOptionContext {
|
|
var p = new(TransactionOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTransactionOptionContext(p *TransactionOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionOption
|
|
}
|
|
|
|
func (*TransactionOptionContext) IsTransactionOptionContext() {}
|
|
|
|
func NewTransactionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionOptionContext {
|
|
var p = new(TransactionOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_transactionOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TransactionOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TransactionOptionContext) ISOLATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISOLATION, 0)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) LEVEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEVEL, 0)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) TransactionLevel() ITransactionLevelContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITransactionLevelContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITransactionLevelContext)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) WRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWRITE, 0)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) ONLY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLY, 0)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TransactionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TransactionOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTransactionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTransactionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTransactionOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TransactionOption() (localctx ITransactionOptionContext) {
|
|
localctx = NewTransactionOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 326, MySqlParserRULE_transactionOption)
|
|
p.SetState(4406)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 651, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4399)
|
|
p.Match(MySqlParserISOLATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4400)
|
|
p.Match(MySqlParserLEVEL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4401)
|
|
p.TransactionLevel()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4402)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4403)
|
|
p.Match(MySqlParserWRITE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4404)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4405)
|
|
p.Match(MySqlParserONLY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITransactionLevelContext is an interface to support dynamic dispatch.
|
|
type ITransactionLevelContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
REPEATABLE() antlr.TerminalNode
|
|
READ() antlr.TerminalNode
|
|
COMMITTED() antlr.TerminalNode
|
|
UNCOMMITTED() antlr.TerminalNode
|
|
SERIALIZABLE() antlr.TerminalNode
|
|
|
|
// IsTransactionLevelContext differentiates from other interfaces.
|
|
IsTransactionLevelContext()
|
|
}
|
|
|
|
type TransactionLevelContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTransactionLevelContext() *TransactionLevelContext {
|
|
var p = new(TransactionLevelContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionLevel
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTransactionLevelContext(p *TransactionLevelContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionLevel
|
|
}
|
|
|
|
func (*TransactionLevelContext) IsTransactionLevelContext() {}
|
|
|
|
func NewTransactionLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionLevelContext {
|
|
var p = new(TransactionLevelContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_transactionLevel
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TransactionLevelContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TransactionLevelContext) REPEATABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPEATABLE, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) COMMITTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMITTED, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) UNCOMMITTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNCOMMITTED, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) SERIALIZABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERIALIZABLE, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TransactionLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TransactionLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTransactionLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTransactionLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTransactionLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TransactionLevel() (localctx ITransactionLevelContext) {
|
|
localctx = NewTransactionLevelContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 328, MySqlParserRULE_transactionLevel)
|
|
p.SetState(4415)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 652, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4408)
|
|
p.Match(MySqlParserREPEATABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4409)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4410)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4411)
|
|
p.Match(MySqlParserCOMMITTED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4412)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4413)
|
|
p.Match(MySqlParserUNCOMMITTED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4414)
|
|
p.Match(MySqlParserSERIALIZABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IChangeMasterContext is an interface to support dynamic dispatch.
|
|
type IChangeMasterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CHANGE() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
AllMasterOption() []IMasterOptionContext
|
|
MasterOption(i int) IMasterOptionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
ChannelOption() IChannelOptionContext
|
|
|
|
// IsChangeMasterContext differentiates from other interfaces.
|
|
IsChangeMasterContext()
|
|
}
|
|
|
|
type ChangeMasterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyChangeMasterContext() *ChangeMasterContext {
|
|
var p = new(ChangeMasterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_changeMaster
|
|
return p
|
|
}
|
|
|
|
func InitEmptyChangeMasterContext(p *ChangeMasterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_changeMaster
|
|
}
|
|
|
|
func (*ChangeMasterContext) IsChangeMasterContext() {}
|
|
|
|
func NewChangeMasterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChangeMasterContext {
|
|
var p = new(ChangeMasterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_changeMaster
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ChangeMasterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ChangeMasterContext) CHANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANGE, 0)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) AllMasterOption() []IMasterOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IMasterOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IMasterOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IMasterOptionContext); ok {
|
|
tst[i] = t.(IMasterOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ChangeMasterContext) MasterOption(i int) IMasterOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMasterOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMasterOptionContext)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) ChannelOption() IChannelOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChannelOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChannelOptionContext)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ChangeMasterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ChangeMasterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterChangeMaster(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChangeMasterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitChangeMaster(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChangeMasterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitChangeMaster(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ChangeMaster() (localctx IChangeMasterContext) {
|
|
localctx = NewChangeMasterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 330, MySqlParserRULE_changeMaster)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4417)
|
|
p.Match(MySqlParserCHANGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4418)
|
|
p.Match(MySqlParserMASTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4419)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4420)
|
|
p.MasterOption()
|
|
}
|
|
p.SetState(4425)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4421)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4422)
|
|
p.MasterOption()
|
|
}
|
|
|
|
p.SetState(4427)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4429)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(4428)
|
|
p.ChannelOption()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IChangeReplicationFilterContext is an interface to support dynamic dispatch.
|
|
type IChangeReplicationFilterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CHANGE() antlr.TerminalNode
|
|
REPLICATION() antlr.TerminalNode
|
|
FILTER() antlr.TerminalNode
|
|
AllReplicationFilter() []IReplicationFilterContext
|
|
ReplicationFilter(i int) IReplicationFilterContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsChangeReplicationFilterContext differentiates from other interfaces.
|
|
IsChangeReplicationFilterContext()
|
|
}
|
|
|
|
type ChangeReplicationFilterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyChangeReplicationFilterContext() *ChangeReplicationFilterContext {
|
|
var p = new(ChangeReplicationFilterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_changeReplicationFilter
|
|
return p
|
|
}
|
|
|
|
func InitEmptyChangeReplicationFilterContext(p *ChangeReplicationFilterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_changeReplicationFilter
|
|
}
|
|
|
|
func (*ChangeReplicationFilterContext) IsChangeReplicationFilterContext() {}
|
|
|
|
func NewChangeReplicationFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChangeReplicationFilterContext {
|
|
var p = new(ChangeReplicationFilterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_changeReplicationFilter
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ChangeReplicationFilterContext) CHANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANGE, 0)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION, 0)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) FILTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILTER, 0)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) AllReplicationFilter() []IReplicationFilterContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IReplicationFilterContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IReplicationFilterContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IReplicationFilterContext); ok {
|
|
tst[i] = t.(IReplicationFilterContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) ReplicationFilter(i int) IReplicationFilterContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReplicationFilterContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReplicationFilterContext)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterChangeReplicationFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitChangeReplicationFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChangeReplicationFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitChangeReplicationFilter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ChangeReplicationFilter() (localctx IChangeReplicationFilterContext) {
|
|
localctx = NewChangeReplicationFilterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 332, MySqlParserRULE_changeReplicationFilter)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4431)
|
|
p.Match(MySqlParserCHANGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4432)
|
|
p.Match(MySqlParserREPLICATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4433)
|
|
p.Match(MySqlParserFILTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4434)
|
|
p.ReplicationFilter()
|
|
}
|
|
p.SetState(4439)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4435)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4436)
|
|
p.ReplicationFilter()
|
|
}
|
|
|
|
p.SetState(4441)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPurgeBinaryLogsContext is an interface to support dynamic dispatch.
|
|
type IPurgeBinaryLogsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPurgeFormat returns the purgeFormat token.
|
|
GetPurgeFormat() antlr.Token
|
|
|
|
// GetFileName returns the fileName token.
|
|
GetFileName() antlr.Token
|
|
|
|
// GetTimeValue returns the timeValue token.
|
|
GetTimeValue() antlr.Token
|
|
|
|
// SetPurgeFormat sets the purgeFormat token.
|
|
SetPurgeFormat(antlr.Token)
|
|
|
|
// SetFileName sets the fileName token.
|
|
SetFileName(antlr.Token)
|
|
|
|
// SetTimeValue sets the timeValue token.
|
|
SetTimeValue(antlr.Token)
|
|
|
|
// Getter signatures
|
|
PURGE() antlr.TerminalNode
|
|
LOGS() antlr.TerminalNode
|
|
BINARY() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
BEFORE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsPurgeBinaryLogsContext differentiates from other interfaces.
|
|
IsPurgeBinaryLogsContext()
|
|
}
|
|
|
|
type PurgeBinaryLogsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
purgeFormat antlr.Token
|
|
fileName antlr.Token
|
|
timeValue antlr.Token
|
|
}
|
|
|
|
func NewEmptyPurgeBinaryLogsContext() *PurgeBinaryLogsContext {
|
|
var p = new(PurgeBinaryLogsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_purgeBinaryLogs
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPurgeBinaryLogsContext(p *PurgeBinaryLogsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_purgeBinaryLogs
|
|
}
|
|
|
|
func (*PurgeBinaryLogsContext) IsPurgeBinaryLogsContext() {}
|
|
|
|
func NewPurgeBinaryLogsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PurgeBinaryLogsContext {
|
|
var p = new(PurgeBinaryLogsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_purgeBinaryLogs
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PurgeBinaryLogsContext) GetPurgeFormat() antlr.Token { return s.purgeFormat }
|
|
|
|
func (s *PurgeBinaryLogsContext) GetFileName() antlr.Token { return s.fileName }
|
|
|
|
func (s *PurgeBinaryLogsContext) GetTimeValue() antlr.Token { return s.timeValue }
|
|
|
|
func (s *PurgeBinaryLogsContext) SetPurgeFormat(v antlr.Token) { s.purgeFormat = v }
|
|
|
|
func (s *PurgeBinaryLogsContext) SetFileName(v antlr.Token) { s.fileName = v }
|
|
|
|
func (s *PurgeBinaryLogsContext) SetTimeValue(v antlr.Token) { s.timeValue = v }
|
|
|
|
func (s *PurgeBinaryLogsContext) PURGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPURGE, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) LOGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGS, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) BEFORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEFORE, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPurgeBinaryLogs(s)
|
|
}
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPurgeBinaryLogs(s)
|
|
}
|
|
}
|
|
|
|
func (s *PurgeBinaryLogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPurgeBinaryLogs(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PurgeBinaryLogs() (localctx IPurgeBinaryLogsContext) {
|
|
localctx = NewPurgeBinaryLogsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 334, MySqlParserRULE_purgeBinaryLogs)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4442)
|
|
p.Match(MySqlParserPURGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4443)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*PurgeBinaryLogsContext).purgeFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBINARY || _la == MySqlParserMASTER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*PurgeBinaryLogsContext).purgeFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4444)
|
|
p.Match(MySqlParserLOGS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4449)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserTO:
|
|
{
|
|
p.SetState(4445)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4446)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PurgeBinaryLogsContext).fileName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBEFORE:
|
|
{
|
|
p.SetState(4447)
|
|
p.Match(MySqlParserBEFORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4448)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PurgeBinaryLogsContext).timeValue = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IResetMasterContext is an interface to support dynamic dispatch.
|
|
type IResetMasterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RESET() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
|
|
// IsResetMasterContext differentiates from other interfaces.
|
|
IsResetMasterContext()
|
|
}
|
|
|
|
type ResetMasterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyResetMasterContext() *ResetMasterContext {
|
|
var p = new(ResetMasterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetMaster
|
|
return p
|
|
}
|
|
|
|
func InitEmptyResetMasterContext(p *ResetMasterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetMaster
|
|
}
|
|
|
|
func (*ResetMasterContext) IsResetMasterContext() {}
|
|
|
|
func NewResetMasterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetMasterContext {
|
|
var p = new(ResetMasterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_resetMaster
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ResetMasterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ResetMasterContext) RESET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESET, 0)
|
|
}
|
|
|
|
func (s *ResetMasterContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *ResetMasterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ResetMasterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ResetMasterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterResetMaster(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetMasterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitResetMaster(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetMasterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitResetMaster(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ResetMaster() (localctx IResetMasterContext) {
|
|
localctx = NewResetMasterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 336, MySqlParserRULE_resetMaster)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4451)
|
|
p.Match(MySqlParserRESET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4452)
|
|
p.Match(MySqlParserMASTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IResetSlaveContext is an interface to support dynamic dispatch.
|
|
type IResetSlaveContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RESET() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
ALL() antlr.TerminalNode
|
|
ChannelOption() IChannelOptionContext
|
|
|
|
// IsResetSlaveContext differentiates from other interfaces.
|
|
IsResetSlaveContext()
|
|
}
|
|
|
|
type ResetSlaveContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyResetSlaveContext() *ResetSlaveContext {
|
|
var p = new(ResetSlaveContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetSlave
|
|
return p
|
|
}
|
|
|
|
func InitEmptyResetSlaveContext(p *ResetSlaveContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetSlave
|
|
}
|
|
|
|
func (*ResetSlaveContext) IsResetSlaveContext() {}
|
|
|
|
func NewResetSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetSlaveContext {
|
|
var p = new(ResetSlaveContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_resetSlave
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ResetSlaveContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ResetSlaveContext) RESET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESET, 0)
|
|
}
|
|
|
|
func (s *ResetSlaveContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *ResetSlaveContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *ResetSlaveContext) ChannelOption() IChannelOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChannelOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChannelOptionContext)
|
|
}
|
|
|
|
func (s *ResetSlaveContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ResetSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ResetSlaveContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterResetSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetSlaveContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitResetSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitResetSlave(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ResetSlave() (localctx IResetSlaveContext) {
|
|
localctx = NewResetSlaveContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 338, MySqlParserRULE_resetSlave)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4454)
|
|
p.Match(MySqlParserRESET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4455)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4457)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserALL {
|
|
{
|
|
p.SetState(4456)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4460)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(4459)
|
|
p.ChannelOption()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStartSlaveContext is an interface to support dynamic dispatch.
|
|
type IStartSlaveContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
START() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
AllThreadType() []IThreadTypeContext
|
|
ThreadType(i int) IThreadTypeContext
|
|
UNTIL() antlr.TerminalNode
|
|
UntilOption() IUntilOptionContext
|
|
AllConnectionOption() []IConnectionOptionContext
|
|
ConnectionOption(i int) IConnectionOptionContext
|
|
ChannelOption() IChannelOptionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsStartSlaveContext differentiates from other interfaces.
|
|
IsStartSlaveContext()
|
|
}
|
|
|
|
type StartSlaveContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStartSlaveContext() *StartSlaveContext {
|
|
var p = new(StartSlaveContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startSlave
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStartSlaveContext(p *StartSlaveContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startSlave
|
|
}
|
|
|
|
func (*StartSlaveContext) IsStartSlaveContext() {}
|
|
|
|
func NewStartSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartSlaveContext {
|
|
var p = new(StartSlaveContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_startSlave
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StartSlaveContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StartSlaveContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *StartSlaveContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *StartSlaveContext) AllThreadType() []IThreadTypeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IThreadTypeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IThreadTypeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IThreadTypeContext); ok {
|
|
tst[i] = t.(IThreadTypeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *StartSlaveContext) ThreadType(i int) IThreadTypeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IThreadTypeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IThreadTypeContext)
|
|
}
|
|
|
|
func (s *StartSlaveContext) UNTIL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNTIL, 0)
|
|
}
|
|
|
|
func (s *StartSlaveContext) UntilOption() IUntilOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUntilOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUntilOptionContext)
|
|
}
|
|
|
|
func (s *StartSlaveContext) AllConnectionOption() []IConnectionOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IConnectionOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IConnectionOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IConnectionOptionContext); ok {
|
|
tst[i] = t.(IConnectionOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *StartSlaveContext) ConnectionOption(i int) IConnectionOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConnectionOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConnectionOptionContext)
|
|
}
|
|
|
|
func (s *StartSlaveContext) ChannelOption() IChannelOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChannelOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChannelOptionContext)
|
|
}
|
|
|
|
func (s *StartSlaveContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *StartSlaveContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *StartSlaveContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StartSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StartSlaveContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStartSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartSlaveContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStartSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStartSlave(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StartSlave() (localctx IStartSlaveContext) {
|
|
localctx = NewStartSlaveContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 340, MySqlParserRULE_startSlave)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4462)
|
|
p.Match(MySqlParserSTART)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4463)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4472)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD {
|
|
{
|
|
p.SetState(4464)
|
|
p.ThreadType()
|
|
}
|
|
p.SetState(4469)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4465)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4466)
|
|
p.ThreadType()
|
|
}
|
|
|
|
p.SetState(4471)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(4476)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUNTIL {
|
|
{
|
|
p.SetState(4474)
|
|
p.Match(MySqlParserUNTIL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4475)
|
|
p.UntilOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(4481)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDEFAULT_AUTH || _la == MySqlParserPASSWORD || _la == MySqlParserPLUGIN_DIR || _la == MySqlParserUSER {
|
|
{
|
|
p.SetState(4478)
|
|
p.ConnectionOption()
|
|
}
|
|
|
|
p.SetState(4483)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4485)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(4484)
|
|
p.ChannelOption()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStopSlaveContext is an interface to support dynamic dispatch.
|
|
type IStopSlaveContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STOP() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
AllThreadType() []IThreadTypeContext
|
|
ThreadType(i int) IThreadTypeContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsStopSlaveContext differentiates from other interfaces.
|
|
IsStopSlaveContext()
|
|
}
|
|
|
|
type StopSlaveContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStopSlaveContext() *StopSlaveContext {
|
|
var p = new(StopSlaveContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stopSlave
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStopSlaveContext(p *StopSlaveContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stopSlave
|
|
}
|
|
|
|
func (*StopSlaveContext) IsStopSlaveContext() {}
|
|
|
|
func NewStopSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StopSlaveContext {
|
|
var p = new(StopSlaveContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_stopSlave
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StopSlaveContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StopSlaveContext) STOP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTOP, 0)
|
|
}
|
|
|
|
func (s *StopSlaveContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *StopSlaveContext) AllThreadType() []IThreadTypeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IThreadTypeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IThreadTypeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IThreadTypeContext); ok {
|
|
tst[i] = t.(IThreadTypeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *StopSlaveContext) ThreadType(i int) IThreadTypeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IThreadTypeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IThreadTypeContext)
|
|
}
|
|
|
|
func (s *StopSlaveContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *StopSlaveContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *StopSlaveContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StopSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StopSlaveContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStopSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *StopSlaveContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStopSlave(s)
|
|
}
|
|
}
|
|
|
|
func (s *StopSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStopSlave(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StopSlave() (localctx IStopSlaveContext) {
|
|
localctx = NewStopSlaveContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 342, MySqlParserRULE_stopSlave)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4487)
|
|
p.Match(MySqlParserSTOP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4488)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4497)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD {
|
|
{
|
|
p.SetState(4489)
|
|
p.ThreadType()
|
|
}
|
|
p.SetState(4494)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4490)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4491)
|
|
p.ThreadType()
|
|
}
|
|
|
|
p.SetState(4496)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStartGroupReplicationContext is an interface to support dynamic dispatch.
|
|
type IStartGroupReplicationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
START() antlr.TerminalNode
|
|
GROUP_REPLICATION() antlr.TerminalNode
|
|
|
|
// IsStartGroupReplicationContext differentiates from other interfaces.
|
|
IsStartGroupReplicationContext()
|
|
}
|
|
|
|
type StartGroupReplicationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStartGroupReplicationContext() *StartGroupReplicationContext {
|
|
var p = new(StartGroupReplicationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startGroupReplication
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStartGroupReplicationContext(p *StartGroupReplicationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_startGroupReplication
|
|
}
|
|
|
|
func (*StartGroupReplicationContext) IsStartGroupReplicationContext() {}
|
|
|
|
func NewStartGroupReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartGroupReplicationContext {
|
|
var p = new(StartGroupReplicationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_startGroupReplication
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StartGroupReplicationContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) GROUP_REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_REPLICATION, 0)
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStartGroupReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStartGroupReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *StartGroupReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStartGroupReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StartGroupReplication() (localctx IStartGroupReplicationContext) {
|
|
localctx = NewStartGroupReplicationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 344, MySqlParserRULE_startGroupReplication)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4499)
|
|
p.Match(MySqlParserSTART)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4500)
|
|
p.Match(MySqlParserGROUP_REPLICATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStopGroupReplicationContext is an interface to support dynamic dispatch.
|
|
type IStopGroupReplicationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STOP() antlr.TerminalNode
|
|
GROUP_REPLICATION() antlr.TerminalNode
|
|
|
|
// IsStopGroupReplicationContext differentiates from other interfaces.
|
|
IsStopGroupReplicationContext()
|
|
}
|
|
|
|
type StopGroupReplicationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStopGroupReplicationContext() *StopGroupReplicationContext {
|
|
var p = new(StopGroupReplicationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stopGroupReplication
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStopGroupReplicationContext(p *StopGroupReplicationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stopGroupReplication
|
|
}
|
|
|
|
func (*StopGroupReplicationContext) IsStopGroupReplicationContext() {}
|
|
|
|
func NewStopGroupReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StopGroupReplicationContext {
|
|
var p = new(StopGroupReplicationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_stopGroupReplication
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StopGroupReplicationContext) STOP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTOP, 0)
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) GROUP_REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_REPLICATION, 0)
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStopGroupReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStopGroupReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *StopGroupReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStopGroupReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StopGroupReplication() (localctx IStopGroupReplicationContext) {
|
|
localctx = NewStopGroupReplicationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 346, MySqlParserRULE_stopGroupReplication)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4502)
|
|
p.Match(MySqlParserSTOP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4503)
|
|
p.Match(MySqlParserGROUP_REPLICATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IMasterOptionContext is an interface to support dynamic dispatch.
|
|
type IMasterOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsMasterOptionContext differentiates from other interfaces.
|
|
IsMasterOptionContext()
|
|
}
|
|
|
|
type MasterOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyMasterOptionContext() *MasterOptionContext {
|
|
var p = new(MasterOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_masterOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyMasterOptionContext(p *MasterOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_masterOption
|
|
}
|
|
|
|
func (*MasterOptionContext) IsMasterOptionContext() {}
|
|
|
|
func NewMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MasterOptionContext {
|
|
var p = new(MasterOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_masterOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *MasterOptionContext) CopyAll(ctx *MasterOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *MasterOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type MasterStringOptionContext struct {
|
|
MasterOptionContext
|
|
}
|
|
|
|
func NewMasterStringOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterStringOptionContext {
|
|
var p = new(MasterStringOptionContext)
|
|
|
|
InitEmptyMasterOptionContext(&p.MasterOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*MasterOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) StringMasterOption() IStringMasterOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringMasterOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringMasterOptionContext)
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterStringOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterStringOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterStringOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterStringOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MasterRealOptionContext struct {
|
|
MasterOptionContext
|
|
}
|
|
|
|
func NewMasterRealOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterRealOptionContext {
|
|
var p = new(MasterRealOptionContext)
|
|
|
|
InitEmptyMasterOptionContext(&p.MasterOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*MasterOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_HEARTBEAT_PERIOD, 0)
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) REAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterRealOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterRealOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterRealOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterRealOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MasterBoolOptionContext struct {
|
|
MasterOptionContext
|
|
boolVal antlr.Token
|
|
}
|
|
|
|
func NewMasterBoolOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterBoolOptionContext {
|
|
var p = new(MasterBoolOptionContext)
|
|
|
|
InitEmptyMasterOptionContext(&p.MasterOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*MasterOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) GetBoolVal() antlr.Token { return s.boolVal }
|
|
|
|
func (s *MasterBoolOptionContext) SetBoolVal(v antlr.Token) { s.boolVal = v }
|
|
|
|
func (s *MasterBoolOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) BoolMasterOption() IBoolMasterOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBoolMasterOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBoolMasterOptionContext)
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterBoolOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterBoolOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterBoolOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterBoolOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MasterUidListOptionContext struct {
|
|
MasterOptionContext
|
|
}
|
|
|
|
func NewMasterUidListOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterUidListOptionContext {
|
|
var p = new(MasterUidListOptionContext)
|
|
|
|
InitEmptyMasterOptionContext(&p.MasterOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*MasterOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) IGNORE_SERVER_IDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE_SERVER_IDS, 0)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterUidListOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterUidListOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterUidListOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterUidListOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MasterDecimalOptionContext struct {
|
|
MasterOptionContext
|
|
}
|
|
|
|
func NewMasterDecimalOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterDecimalOptionContext {
|
|
var p = new(MasterDecimalOptionContext)
|
|
|
|
InitEmptyMasterOptionContext(&p.MasterOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*MasterOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) DecimalMasterOption() IDecimalMasterOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalMasterOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalMasterOptionContext)
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterDecimalOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterDecimalOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterDecimalOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterDecimalOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) MasterOption() (localctx IMasterOptionContext) {
|
|
localctx = NewMasterOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 348, MySqlParserRULE_masterOption)
|
|
var _la int
|
|
|
|
p.SetState(4534)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserMASTER_BIND, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserRELAY_LOG_FILE:
|
|
localctx = NewMasterStringOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4505)
|
|
p.StringMasterOption()
|
|
}
|
|
{
|
|
p.SetState(4506)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4507)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserRELAY_LOG_POS:
|
|
localctx = NewMasterDecimalOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4509)
|
|
p.DecimalMasterOption()
|
|
}
|
|
{
|
|
p.SetState(4510)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4511)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserMASTER_SSL_VERIFY_SERVER_CERT, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_SSL:
|
|
localctx = NewMasterBoolOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4513)
|
|
p.BoolMasterOption()
|
|
}
|
|
{
|
|
p.SetState(4514)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4515)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*MasterBoolOptionContext).boolVal = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*MasterBoolOptionContext).boolVal = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserMASTER_HEARTBEAT_PERIOD:
|
|
localctx = NewMasterRealOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4517)
|
|
p.Match(MySqlParserMASTER_HEARTBEAT_PERIOD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4518)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4519)
|
|
p.Match(MySqlParserREAL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserIGNORE_SERVER_IDS:
|
|
localctx = NewMasterUidListOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(4520)
|
|
p.Match(MySqlParserIGNORE_SERVER_IDS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4521)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4522)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4531)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4523)
|
|
p.Uid()
|
|
}
|
|
p.SetState(4528)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4524)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4525)
|
|
p.Uid()
|
|
}
|
|
|
|
p.SetState(4530)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4533)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStringMasterOptionContext is an interface to support dynamic dispatch.
|
|
type IStringMasterOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MASTER_BIND() antlr.TerminalNode
|
|
MASTER_HOST() antlr.TerminalNode
|
|
MASTER_USER() antlr.TerminalNode
|
|
MASTER_PASSWORD() antlr.TerminalNode
|
|
MASTER_LOG_FILE() antlr.TerminalNode
|
|
RELAY_LOG_FILE() antlr.TerminalNode
|
|
MASTER_SSL_CA() antlr.TerminalNode
|
|
MASTER_SSL_CAPATH() antlr.TerminalNode
|
|
MASTER_SSL_CERT() antlr.TerminalNode
|
|
MASTER_SSL_CRL() antlr.TerminalNode
|
|
MASTER_SSL_CRLPATH() antlr.TerminalNode
|
|
MASTER_SSL_KEY() antlr.TerminalNode
|
|
MASTER_SSL_CIPHER() antlr.TerminalNode
|
|
MASTER_TLS_VERSION() antlr.TerminalNode
|
|
|
|
// IsStringMasterOptionContext differentiates from other interfaces.
|
|
IsStringMasterOptionContext()
|
|
}
|
|
|
|
type StringMasterOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStringMasterOptionContext() *StringMasterOptionContext {
|
|
var p = new(StringMasterOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stringMasterOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStringMasterOptionContext(p *StringMasterOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stringMasterOption
|
|
}
|
|
|
|
func (*StringMasterOptionContext) IsStringMasterOptionContext() {}
|
|
|
|
func NewStringMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringMasterOptionContext {
|
|
var p = new(StringMasterOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_stringMasterOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StringMasterOptionContext) MASTER_BIND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_BIND, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_HOST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_HOST, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_USER, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_PASSWORD, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) RELAY_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CA, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CAPATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CAPATH, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CERT, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CRL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CRL, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CRLPATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CRLPATH, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_KEY, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_SSL_CIPHER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CIPHER, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) MASTER_TLS_VERSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_TLS_VERSION, 0)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStringMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStringMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStringMasterOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StringMasterOption() (localctx IStringMasterOptionContext) {
|
|
localctx = NewStringMasterOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 350, MySqlParserRULE_stringMasterOption)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4536)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMASTER_BIND || ((int64((_la-482)) & ^0x3f) == 0 && ((int64(1)<<(_la-482))&65419) != 0) || _la == MySqlParserRELAY_LOG_FILE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDecimalMasterOptionContext is an interface to support dynamic dispatch.
|
|
type IDecimalMasterOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MASTER_PORT() antlr.TerminalNode
|
|
MASTER_CONNECT_RETRY() antlr.TerminalNode
|
|
MASTER_RETRY_COUNT() antlr.TerminalNode
|
|
MASTER_DELAY() antlr.TerminalNode
|
|
MASTER_LOG_POS() antlr.TerminalNode
|
|
RELAY_LOG_POS() antlr.TerminalNode
|
|
|
|
// IsDecimalMasterOptionContext differentiates from other interfaces.
|
|
IsDecimalMasterOptionContext()
|
|
}
|
|
|
|
type DecimalMasterOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDecimalMasterOptionContext() *DecimalMasterOptionContext {
|
|
var p = new(DecimalMasterOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_decimalMasterOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDecimalMasterOptionContext(p *DecimalMasterOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_decimalMasterOption
|
|
}
|
|
|
|
func (*DecimalMasterOptionContext) IsDecimalMasterOptionContext() {}
|
|
|
|
func NewDecimalMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalMasterOptionContext {
|
|
var p = new(DecimalMasterOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_decimalMasterOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DecimalMasterOptionContext) MASTER_PORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_PORT, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) MASTER_CONNECT_RETRY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_CONNECT_RETRY, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) MASTER_RETRY_COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_RETRY_COUNT, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) MASTER_DELAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_DELAY, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) MASTER_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) RELAY_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDecimalMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDecimalMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *DecimalMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDecimalMasterOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DecimalMasterOption() (localctx IDecimalMasterOptionContext) {
|
|
localctx = NewDecimalMasterOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 352, MySqlParserRULE_decimalMasterOption)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4538)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-479)) & ^0x3f) == 0 && ((int64(1)<<(_la-479))&419) != 0) || _la == MySqlParserRELAY_LOG_POS) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBoolMasterOptionContext is an interface to support dynamic dispatch.
|
|
type IBoolMasterOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MASTER_AUTO_POSITION() antlr.TerminalNode
|
|
MASTER_SSL() antlr.TerminalNode
|
|
MASTER_SSL_VERIFY_SERVER_CERT() antlr.TerminalNode
|
|
|
|
// IsBoolMasterOptionContext differentiates from other interfaces.
|
|
IsBoolMasterOptionContext()
|
|
}
|
|
|
|
type BoolMasterOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBoolMasterOptionContext() *BoolMasterOptionContext {
|
|
var p = new(BoolMasterOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_boolMasterOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBoolMasterOptionContext(p *BoolMasterOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_boolMasterOption
|
|
}
|
|
|
|
func (*BoolMasterOptionContext) IsBoolMasterOptionContext() {}
|
|
|
|
func NewBoolMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoolMasterOptionContext {
|
|
var p = new(BoolMasterOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_boolMasterOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BoolMasterOptionContext) MASTER_AUTO_POSITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_AUTO_POSITION, 0)
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) MASTER_SSL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL, 0)
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) MASTER_SSL_VERIFY_SERVER_CERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_VERIFY_SERVER_CERT, 0)
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBoolMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBoolMasterOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *BoolMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBoolMasterOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BoolMasterOption() (localctx IBoolMasterOptionContext) {
|
|
localctx = NewBoolMasterOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 354, MySqlParserRULE_boolMasterOption)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4540)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMASTER_SSL_VERIFY_SERVER_CERT || _la == MySqlParserMASTER_AUTO_POSITION || _la == MySqlParserMASTER_SSL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IChannelOptionContext is an interface to support dynamic dispatch.
|
|
type IChannelOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FOR() antlr.TerminalNode
|
|
CHANNEL() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsChannelOptionContext differentiates from other interfaces.
|
|
IsChannelOptionContext()
|
|
}
|
|
|
|
type ChannelOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyChannelOptionContext() *ChannelOptionContext {
|
|
var p = new(ChannelOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_channelOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyChannelOptionContext(p *ChannelOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_channelOption
|
|
}
|
|
|
|
func (*ChannelOptionContext) IsChannelOptionContext() {}
|
|
|
|
func NewChannelOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChannelOptionContext {
|
|
var p = new(ChannelOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_channelOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ChannelOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ChannelOptionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *ChannelOptionContext) CHANNEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANNEL, 0)
|
|
}
|
|
|
|
func (s *ChannelOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ChannelOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ChannelOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ChannelOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterChannelOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChannelOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitChannelOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChannelOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitChannelOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ChannelOption() (localctx IChannelOptionContext) {
|
|
localctx = NewChannelOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 356, MySqlParserRULE_channelOption)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4542)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4543)
|
|
p.Match(MySqlParserCHANNEL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4544)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReplicationFilterContext is an interface to support dynamic dispatch.
|
|
type IReplicationFilterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsReplicationFilterContext differentiates from other interfaces.
|
|
IsReplicationFilterContext()
|
|
}
|
|
|
|
type ReplicationFilterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyReplicationFilterContext() *ReplicationFilterContext {
|
|
var p = new(ReplicationFilterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replicationFilter
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReplicationFilterContext(p *ReplicationFilterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_replicationFilter
|
|
}
|
|
|
|
func (*ReplicationFilterContext) IsReplicationFilterContext() {}
|
|
|
|
func NewReplicationFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationFilterContext {
|
|
var p = new(ReplicationFilterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_replicationFilter
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReplicationFilterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReplicationFilterContext) CopyAll(ctx *ReplicationFilterContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ReplicationFilterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReplicationFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type WildIgnoreTableReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewWildIgnoreTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WildIgnoreTableReplicationContext {
|
|
var p = new(WildIgnoreTableReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_WILD_IGNORE_TABLE, 0)
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) SimpleStrings() ISimpleStringsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleStringsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleStringsContext)
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWildIgnoreTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWildIgnoreTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *WildIgnoreTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWildIgnoreTableReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DoTableReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewDoTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoTableReplicationContext {
|
|
var p = new(DoTableReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) REPLICATE_DO_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_DO_TABLE, 0)
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDoTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDoTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDoTableReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IgnoreTableReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewIgnoreTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IgnoreTableReplicationContext {
|
|
var p = new(IgnoreTableReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) REPLICATE_IGNORE_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_IGNORE_TABLE, 0)
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIgnoreTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIgnoreTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *IgnoreTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIgnoreTableReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RewriteDbReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewRewriteDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RewriteDbReplicationContext {
|
|
var p = new(RewriteDbReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) REPLICATE_REWRITE_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_REWRITE_DB, 0)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) AllTablePair() []ITablePairContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITablePairContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITablePairContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITablePairContext); ok {
|
|
tst[i] = t.(ITablePairContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) TablePair(i int) ITablePairContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablePairContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablePairContext)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRewriteDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRewriteDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *RewriteDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRewriteDbReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DoDbReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewDoDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoDbReplicationContext {
|
|
var p = new(DoDbReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) REPLICATE_DO_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_DO_DB, 0)
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDoDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDoDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *DoDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDoDbReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IgnoreDbReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewIgnoreDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IgnoreDbReplicationContext {
|
|
var p = new(IgnoreDbReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) REPLICATE_IGNORE_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_IGNORE_DB, 0)
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIgnoreDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIgnoreDbReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *IgnoreDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIgnoreDbReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type WildDoTableReplicationContext struct {
|
|
ReplicationFilterContext
|
|
}
|
|
|
|
func NewWildDoTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WildDoTableReplicationContext {
|
|
var p = new(WildDoTableReplicationContext)
|
|
|
|
InitEmptyReplicationFilterContext(&p.ReplicationFilterContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ReplicationFilterContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) REPLICATE_WILD_DO_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_WILD_DO_TABLE, 0)
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) SimpleStrings() ISimpleStringsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleStringsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleStringsContext)
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWildDoTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWildDoTableReplication(s)
|
|
}
|
|
}
|
|
|
|
func (s *WildDoTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWildDoTableReplication(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReplicationFilter() (localctx IReplicationFilterContext) {
|
|
localctx = NewReplicationFilterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 358, MySqlParserRULE_replicationFilter)
|
|
var _la int
|
|
|
|
p.SetState(4595)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserREPLICATE_DO_DB:
|
|
localctx = NewDoDbReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4546)
|
|
p.Match(MySqlParserREPLICATE_DO_DB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4547)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4548)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4549)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(4550)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_IGNORE_DB:
|
|
localctx = NewIgnoreDbReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4552)
|
|
p.Match(MySqlParserREPLICATE_IGNORE_DB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4553)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4554)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4555)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(4556)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_DO_TABLE:
|
|
localctx = NewDoTableReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4558)
|
|
p.Match(MySqlParserREPLICATE_DO_TABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4559)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4560)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4561)
|
|
p.Tables()
|
|
}
|
|
{
|
|
p.SetState(4562)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_IGNORE_TABLE:
|
|
localctx = NewIgnoreTableReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4564)
|
|
p.Match(MySqlParserREPLICATE_IGNORE_TABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4565)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4566)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4567)
|
|
p.Tables()
|
|
}
|
|
{
|
|
p.SetState(4568)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_WILD_DO_TABLE:
|
|
localctx = NewWildDoTableReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(4570)
|
|
p.Match(MySqlParserREPLICATE_WILD_DO_TABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4571)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4572)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4573)
|
|
p.SimpleStrings()
|
|
}
|
|
{
|
|
p.SetState(4574)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_WILD_IGNORE_TABLE:
|
|
localctx = NewWildIgnoreTableReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(4576)
|
|
p.Match(MySqlParserREPLICATE_WILD_IGNORE_TABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4577)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4578)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4579)
|
|
p.SimpleStrings()
|
|
}
|
|
{
|
|
p.SetState(4580)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLICATE_REWRITE_DB:
|
|
localctx = NewRewriteDbReplicationContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(4582)
|
|
p.Match(MySqlParserREPLICATE_REWRITE_DB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4583)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4584)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4585)
|
|
p.TablePair()
|
|
}
|
|
p.SetState(4590)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4586)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4587)
|
|
p.TablePair()
|
|
}
|
|
|
|
p.SetState(4592)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(4593)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITablePairContext is an interface to support dynamic dispatch.
|
|
type ITablePairContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFirstTable returns the firstTable rule contexts.
|
|
GetFirstTable() ITableNameContext
|
|
|
|
// GetSecondTable returns the secondTable rule contexts.
|
|
GetSecondTable() ITableNameContext
|
|
|
|
// SetFirstTable sets the firstTable rule contexts.
|
|
SetFirstTable(ITableNameContext)
|
|
|
|
// SetSecondTable sets the secondTable rule contexts.
|
|
SetSecondTable(ITableNameContext)
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
COMMA() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllTableName() []ITableNameContext
|
|
TableName(i int) ITableNameContext
|
|
|
|
// IsTablePairContext differentiates from other interfaces.
|
|
IsTablePairContext()
|
|
}
|
|
|
|
type TablePairContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
firstTable ITableNameContext
|
|
secondTable ITableNameContext
|
|
}
|
|
|
|
func NewEmptyTablePairContext() *TablePairContext {
|
|
var p = new(TablePairContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tablePair
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTablePairContext(p *TablePairContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tablePair
|
|
}
|
|
|
|
func (*TablePairContext) IsTablePairContext() {}
|
|
|
|
func NewTablePairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablePairContext {
|
|
var p = new(TablePairContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tablePair
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TablePairContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TablePairContext) GetFirstTable() ITableNameContext { return s.firstTable }
|
|
|
|
func (s *TablePairContext) GetSecondTable() ITableNameContext { return s.secondTable }
|
|
|
|
func (s *TablePairContext) SetFirstTable(v ITableNameContext) { s.firstTable = v }
|
|
|
|
func (s *TablePairContext) SetSecondTable(v ITableNameContext) { s.secondTable = v }
|
|
|
|
func (s *TablePairContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TablePairContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *TablePairContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TablePairContext) AllTableName() []ITableNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableNameContext); ok {
|
|
tst[i] = t.(ITableNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TablePairContext) TableName(i int) ITableNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *TablePairContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TablePairContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TablePairContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTablePair(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablePairContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTablePair(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablePairContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTablePair(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TablePair() (localctx ITablePairContext) {
|
|
localctx = NewTablePairContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 360, MySqlParserRULE_tablePair)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4597)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4598)
|
|
|
|
var _x = p.TableName()
|
|
|
|
localctx.(*TablePairContext).firstTable = _x
|
|
}
|
|
{
|
|
p.SetState(4599)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4600)
|
|
|
|
var _x = p.TableName()
|
|
|
|
localctx.(*TablePairContext).secondTable = _x
|
|
}
|
|
{
|
|
p.SetState(4601)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IThreadTypeContext is an interface to support dynamic dispatch.
|
|
type IThreadTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
IO_THREAD() antlr.TerminalNode
|
|
SQL_THREAD() antlr.TerminalNode
|
|
|
|
// IsThreadTypeContext differentiates from other interfaces.
|
|
IsThreadTypeContext()
|
|
}
|
|
|
|
type ThreadTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyThreadTypeContext() *ThreadTypeContext {
|
|
var p = new(ThreadTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_threadType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyThreadTypeContext(p *ThreadTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_threadType
|
|
}
|
|
|
|
func (*ThreadTypeContext) IsThreadTypeContext() {}
|
|
|
|
func NewThreadTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThreadTypeContext {
|
|
var p = new(ThreadTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_threadType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ThreadTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ThreadTypeContext) IO_THREAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIO_THREAD, 0)
|
|
}
|
|
|
|
func (s *ThreadTypeContext) SQL_THREAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_THREAD, 0)
|
|
}
|
|
|
|
func (s *ThreadTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ThreadTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ThreadTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterThreadType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ThreadTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitThreadType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ThreadTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitThreadType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ThreadType() (localctx IThreadTypeContext) {
|
|
localctx = NewThreadTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 362, MySqlParserRULE_threadType)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4603)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUntilOptionContext is an interface to support dynamic dispatch.
|
|
type IUntilOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsUntilOptionContext differentiates from other interfaces.
|
|
IsUntilOptionContext()
|
|
}
|
|
|
|
type UntilOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUntilOptionContext() *UntilOptionContext {
|
|
var p = new(UntilOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_untilOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUntilOptionContext(p *UntilOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_untilOption
|
|
}
|
|
|
|
func (*UntilOptionContext) IsUntilOptionContext() {}
|
|
|
|
func NewUntilOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UntilOptionContext {
|
|
var p = new(UntilOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_untilOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UntilOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UntilOptionContext) CopyAll(ctx *UntilOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *UntilOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UntilOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type GtidsUntilOptionContext struct {
|
|
UntilOptionContext
|
|
gtids antlr.Token
|
|
}
|
|
|
|
func NewGtidsUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GtidsUntilOptionContext {
|
|
var p = new(GtidsUntilOptionContext)
|
|
|
|
InitEmptyUntilOptionContext(&p.UntilOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UntilOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) GetGtids() antlr.Token { return s.gtids }
|
|
|
|
func (s *GtidsUntilOptionContext) SetGtids(v antlr.Token) { s.gtids = v }
|
|
|
|
func (s *GtidsUntilOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) GtuidSet() IGtuidSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IGtuidSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IGtuidSetContext)
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) SQL_BEFORE_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_BEFORE_GTIDS, 0)
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) SQL_AFTER_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_AFTER_GTIDS, 0)
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGtidsUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGtidsUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *GtidsUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGtidsUntilOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SqlGapsUntilOptionContext struct {
|
|
UntilOptionContext
|
|
}
|
|
|
|
func NewSqlGapsUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SqlGapsUntilOptionContext {
|
|
var p = new(SqlGapsUntilOptionContext)
|
|
|
|
InitEmptyUntilOptionContext(&p.UntilOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UntilOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SqlGapsUntilOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SqlGapsUntilOptionContext) SQL_AFTER_MTS_GAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_AFTER_MTS_GAPS, 0)
|
|
}
|
|
|
|
func (s *SqlGapsUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSqlGapsUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlGapsUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSqlGapsUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SqlGapsUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSqlGapsUntilOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MasterLogUntilOptionContext struct {
|
|
UntilOptionContext
|
|
}
|
|
|
|
func NewMasterLogUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterLogUntilOptionContext {
|
|
var p = new(MasterLogUntilOptionContext)
|
|
|
|
InitEmptyUntilOptionContext(&p.UntilOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UntilOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) MASTER_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) MASTER_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMasterLogUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMasterLogUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *MasterLogUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMasterLogUntilOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RelayLogUntilOptionContext struct {
|
|
UntilOptionContext
|
|
}
|
|
|
|
func NewRelayLogUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelayLogUntilOptionContext {
|
|
var p = new(RelayLogUntilOptionContext)
|
|
|
|
InitEmptyUntilOptionContext(&p.UntilOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UntilOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) RELAY_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) RELAY_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRelayLogUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRelayLogUntilOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RelayLogUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRelayLogUntilOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UntilOption() (localctx IUntilOptionContext) {
|
|
localctx = NewUntilOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 364, MySqlParserRULE_untilOption)
|
|
var _la int
|
|
|
|
p.SetState(4623)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_BEFORE_GTIDS:
|
|
localctx = NewGtidsUntilOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4605)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*GtidsUntilOptionContext).gtids = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSQL_AFTER_GTIDS || _la == MySqlParserSQL_BEFORE_GTIDS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*GtidsUntilOptionContext).gtids = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4606)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4607)
|
|
p.GtuidSet()
|
|
}
|
|
|
|
case MySqlParserMASTER_LOG_FILE:
|
|
localctx = NewMasterLogUntilOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4608)
|
|
p.Match(MySqlParserMASTER_LOG_FILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4609)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4610)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4611)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4612)
|
|
p.Match(MySqlParserMASTER_LOG_POS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4613)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4614)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserRELAY_LOG_FILE:
|
|
localctx = NewRelayLogUntilOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4615)
|
|
p.Match(MySqlParserRELAY_LOG_FILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4616)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4617)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4618)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4619)
|
|
p.Match(MySqlParserRELAY_LOG_POS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4620)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4621)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserSQL_AFTER_MTS_GAPS:
|
|
localctx = NewSqlGapsUntilOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4622)
|
|
p.Match(MySqlParserSQL_AFTER_MTS_GAPS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IConnectionOptionContext is an interface to support dynamic dispatch.
|
|
type IConnectionOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsConnectionOptionContext differentiates from other interfaces.
|
|
IsConnectionOptionContext()
|
|
}
|
|
|
|
type ConnectionOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyConnectionOptionContext() *ConnectionOptionContext {
|
|
var p = new(ConnectionOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_connectionOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyConnectionOptionContext(p *ConnectionOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_connectionOption
|
|
}
|
|
|
|
func (*ConnectionOptionContext) IsConnectionOptionContext() {}
|
|
|
|
func NewConnectionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConnectionOptionContext {
|
|
var p = new(ConnectionOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_connectionOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConnectionOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ConnectionOptionContext) CopyAll(ctx *ConnectionOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ConnectionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConnectionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PluginDirConnectionOptionContext struct {
|
|
ConnectionOptionContext
|
|
conOptPluginDir antlr.Token
|
|
}
|
|
|
|
func NewPluginDirConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PluginDirConnectionOptionContext {
|
|
var p = new(PluginDirConnectionOptionContext)
|
|
|
|
InitEmptyConnectionOptionContext(&p.ConnectionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ConnectionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) GetConOptPluginDir() antlr.Token { return s.conOptPluginDir }
|
|
|
|
func (s *PluginDirConnectionOptionContext) SetConOptPluginDir(v antlr.Token) { s.conOptPluginDir = v }
|
|
|
|
func (s *PluginDirConnectionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) PLUGIN_DIR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGIN_DIR, 0)
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPluginDirConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPluginDirConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PluginDirConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPluginDirConnectionOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type UserConnectionOptionContext struct {
|
|
ConnectionOptionContext
|
|
conOptUser antlr.Token
|
|
}
|
|
|
|
func NewUserConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UserConnectionOptionContext {
|
|
var p = new(UserConnectionOptionContext)
|
|
|
|
InitEmptyConnectionOptionContext(&p.ConnectionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ConnectionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) GetConOptUser() antlr.Token { return s.conOptUser }
|
|
|
|
func (s *UserConnectionOptionContext) SetConOptUser(v antlr.Token) { s.conOptUser = v }
|
|
|
|
func (s *UserConnectionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserConnectionOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DefaultAuthConnectionOptionContext struct {
|
|
ConnectionOptionContext
|
|
conOptDefAuth antlr.Token
|
|
}
|
|
|
|
func NewDefaultAuthConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefaultAuthConnectionOptionContext {
|
|
var p = new(DefaultAuthConnectionOptionContext)
|
|
|
|
InitEmptyConnectionOptionContext(&p.ConnectionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ConnectionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) GetConOptDefAuth() antlr.Token { return s.conOptDefAuth }
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) SetConOptDefAuth(v antlr.Token) { s.conOptDefAuth = v }
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) DEFAULT_AUTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT_AUTH, 0)
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefaultAuthConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefaultAuthConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultAuthConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefaultAuthConnectionOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PasswordConnectionOptionContext struct {
|
|
ConnectionOptionContext
|
|
conOptPassword antlr.Token
|
|
}
|
|
|
|
func NewPasswordConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordConnectionOptionContext {
|
|
var p = new(PasswordConnectionOptionContext)
|
|
|
|
InitEmptyConnectionOptionContext(&p.ConnectionOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ConnectionOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) GetConOptPassword() antlr.Token { return s.conOptPassword }
|
|
|
|
func (s *PasswordConnectionOptionContext) SetConOptPassword(v antlr.Token) { s.conOptPassword = v }
|
|
|
|
func (s *PasswordConnectionOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPasswordConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPasswordConnectionOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPasswordConnectionOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ConnectionOption() (localctx IConnectionOptionContext) {
|
|
localctx = NewConnectionOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 366, MySqlParserRULE_connectionOption)
|
|
p.SetState(4637)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserUSER:
|
|
localctx = NewUserConnectionOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4625)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4626)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4627)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*UserConnectionOptionContext).conOptUser = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPASSWORD:
|
|
localctx = NewPasswordConnectionOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4628)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4629)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4630)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PasswordConnectionOptionContext).conOptPassword = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDEFAULT_AUTH:
|
|
localctx = NewDefaultAuthConnectionOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4631)
|
|
p.Match(MySqlParserDEFAULT_AUTH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4632)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4633)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*DefaultAuthConnectionOptionContext).conOptDefAuth = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPLUGIN_DIR:
|
|
localctx = NewPluginDirConnectionOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4634)
|
|
p.Match(MySqlParserPLUGIN_DIR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4635)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4636)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PluginDirConnectionOptionContext).conOptPluginDir = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IGtuidSetContext is an interface to support dynamic dispatch.
|
|
type IGtuidSetContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllUuidSet() []IUuidSetContext
|
|
UuidSet(i int) IUuidSetContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsGtuidSetContext differentiates from other interfaces.
|
|
IsGtuidSetContext()
|
|
}
|
|
|
|
type GtuidSetContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyGtuidSetContext() *GtuidSetContext {
|
|
var p = new(GtuidSetContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_gtuidSet
|
|
return p
|
|
}
|
|
|
|
func InitEmptyGtuidSetContext(p *GtuidSetContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_gtuidSet
|
|
}
|
|
|
|
func (*GtuidSetContext) IsGtuidSetContext() {}
|
|
|
|
func NewGtuidSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GtuidSetContext {
|
|
var p = new(GtuidSetContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_gtuidSet
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GtuidSetContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *GtuidSetContext) AllUuidSet() []IUuidSetContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUuidSetContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUuidSetContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUuidSetContext); ok {
|
|
tst[i] = t.(IUuidSetContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GtuidSetContext) UuidSet(i int) IUuidSetContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUuidSetContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUuidSetContext)
|
|
}
|
|
|
|
func (s *GtuidSetContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *GtuidSetContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *GtuidSetContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *GtuidSetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GtuidSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *GtuidSetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGtuidSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *GtuidSetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGtuidSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *GtuidSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGtuidSet(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) GtuidSet() (localctx IGtuidSetContext) {
|
|
localctx = NewGtuidSetContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 368, MySqlParserRULE_gtuidSet)
|
|
var _la int
|
|
|
|
p.SetState(4648)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4639)
|
|
p.UuidSet()
|
|
}
|
|
p.SetState(4644)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4640)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4641)
|
|
p.UuidSet()
|
|
}
|
|
|
|
p.SetState(4646)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case MySqlParserSTRING_LITERAL:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4647)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaStartTransactionContext is an interface to support dynamic dispatch.
|
|
type IXaStartTransactionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetXaStart returns the xaStart token.
|
|
GetXaStart() antlr.Token
|
|
|
|
// GetXaAction returns the xaAction token.
|
|
GetXaAction() antlr.Token
|
|
|
|
// SetXaStart sets the xaStart token.
|
|
SetXaStart(antlr.Token)
|
|
|
|
// SetXaAction sets the xaAction token.
|
|
SetXaAction(antlr.Token)
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
START() antlr.TerminalNode
|
|
BEGIN() antlr.TerminalNode
|
|
JOIN() antlr.TerminalNode
|
|
RESUME() antlr.TerminalNode
|
|
|
|
// IsXaStartTransactionContext differentiates from other interfaces.
|
|
IsXaStartTransactionContext()
|
|
}
|
|
|
|
type XaStartTransactionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
xaStart antlr.Token
|
|
xaAction antlr.Token
|
|
}
|
|
|
|
func NewEmptyXaStartTransactionContext() *XaStartTransactionContext {
|
|
var p = new(XaStartTransactionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaStartTransaction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaStartTransactionContext(p *XaStartTransactionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaStartTransaction
|
|
}
|
|
|
|
func (*XaStartTransactionContext) IsXaStartTransactionContext() {}
|
|
|
|
func NewXaStartTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaStartTransactionContext {
|
|
var p = new(XaStartTransactionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaStartTransaction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaStartTransactionContext) GetXaStart() antlr.Token { return s.xaStart }
|
|
|
|
func (s *XaStartTransactionContext) GetXaAction() antlr.Token { return s.xaAction }
|
|
|
|
func (s *XaStartTransactionContext) SetXaStart(v antlr.Token) { s.xaStart = v }
|
|
|
|
func (s *XaStartTransactionContext) SetXaAction(v antlr.Token) { s.xaAction = v }
|
|
|
|
func (s *XaStartTransactionContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) BEGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEGIN, 0)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) JOIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJOIN, 0)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) RESUME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESUME, 0)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaStartTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaStartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaStartTransaction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaStartTransaction() (localctx IXaStartTransactionContext) {
|
|
localctx = NewXaStartTransactionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 370, MySqlParserRULE_xaStartTransaction)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4650)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4651)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*XaStartTransactionContext).xaStart = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBEGIN || _la == MySqlParserSTART) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*XaStartTransactionContext).xaStart = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4652)
|
|
p.Xid()
|
|
}
|
|
p.SetState(4654)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserJOIN || _la == MySqlParserRESUME {
|
|
{
|
|
p.SetState(4653)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*XaStartTransactionContext).xaAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserJOIN || _la == MySqlParserRESUME) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*XaStartTransactionContext).xaAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaEndTransactionContext is an interface to support dynamic dispatch.
|
|
type IXaEndTransactionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
SUSPEND() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
MIGRATE() antlr.TerminalNode
|
|
|
|
// IsXaEndTransactionContext differentiates from other interfaces.
|
|
IsXaEndTransactionContext()
|
|
}
|
|
|
|
type XaEndTransactionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXaEndTransactionContext() *XaEndTransactionContext {
|
|
var p = new(XaEndTransactionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaEndTransaction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaEndTransactionContext(p *XaEndTransactionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaEndTransaction
|
|
}
|
|
|
|
func (*XaEndTransactionContext) IsXaEndTransactionContext() {}
|
|
|
|
func NewXaEndTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaEndTransactionContext {
|
|
var p = new(XaEndTransactionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaEndTransaction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaEndTransactionContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) SUSPEND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUSPEND, 0)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) MIGRATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIGRATE, 0)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaEndTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaEndTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaEndTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaEndTransaction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaEndTransaction() (localctx IXaEndTransactionContext) {
|
|
localctx = NewXaEndTransactionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 372, MySqlParserRULE_xaEndTransaction)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4656)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4657)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4658)
|
|
p.Xid()
|
|
}
|
|
p.SetState(4664)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSUSPEND {
|
|
{
|
|
p.SetState(4659)
|
|
p.Match(MySqlParserSUSPEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4662)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(4660)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4661)
|
|
p.Match(MySqlParserMIGRATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaPrepareStatementContext is an interface to support dynamic dispatch.
|
|
type IXaPrepareStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
PREPARE() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
|
|
// IsXaPrepareStatementContext differentiates from other interfaces.
|
|
IsXaPrepareStatementContext()
|
|
}
|
|
|
|
type XaPrepareStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXaPrepareStatementContext() *XaPrepareStatementContext {
|
|
var p = new(XaPrepareStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaPrepareStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaPrepareStatementContext(p *XaPrepareStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaPrepareStatement
|
|
}
|
|
|
|
func (*XaPrepareStatementContext) IsXaPrepareStatementContext() {}
|
|
|
|
func NewXaPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaPrepareStatementContext {
|
|
var p = new(XaPrepareStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaPrepareStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaPrepareStatementContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) PREPARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREPARE, 0)
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaPrepareStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaPrepareStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaPrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaPrepareStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaPrepareStatement() (localctx IXaPrepareStatementContext) {
|
|
localctx = NewXaPrepareStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 374, MySqlParserRULE_xaPrepareStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4666)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4667)
|
|
p.Match(MySqlParserPREPARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4668)
|
|
p.Xid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaCommitWorkContext is an interface to support dynamic dispatch.
|
|
type IXaCommitWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
COMMIT() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
ONE() antlr.TerminalNode
|
|
PHASE() antlr.TerminalNode
|
|
|
|
// IsXaCommitWorkContext differentiates from other interfaces.
|
|
IsXaCommitWorkContext()
|
|
}
|
|
|
|
type XaCommitWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXaCommitWorkContext() *XaCommitWorkContext {
|
|
var p = new(XaCommitWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaCommitWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaCommitWorkContext(p *XaCommitWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaCommitWork
|
|
}
|
|
|
|
func (*XaCommitWorkContext) IsXaCommitWorkContext() {}
|
|
|
|
func NewXaCommitWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaCommitWorkContext {
|
|
var p = new(XaCommitWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaCommitWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaCommitWorkContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) COMMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMIT, 0)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) ONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE, 0)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) PHASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPHASE, 0)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaCommitWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaCommitWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaCommitWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaCommitWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaCommitWork() (localctx IXaCommitWorkContext) {
|
|
localctx = NewXaCommitWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 376, MySqlParserRULE_xaCommitWork)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4670)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4671)
|
|
p.Match(MySqlParserCOMMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4672)
|
|
p.Xid()
|
|
}
|
|
p.SetState(4675)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserONE {
|
|
{
|
|
p.SetState(4673)
|
|
p.Match(MySqlParserONE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4674)
|
|
p.Match(MySqlParserPHASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaRollbackWorkContext is an interface to support dynamic dispatch.
|
|
type IXaRollbackWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
ROLLBACK() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
|
|
// IsXaRollbackWorkContext differentiates from other interfaces.
|
|
IsXaRollbackWorkContext()
|
|
}
|
|
|
|
type XaRollbackWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXaRollbackWorkContext() *XaRollbackWorkContext {
|
|
var p = new(XaRollbackWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaRollbackWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaRollbackWorkContext(p *XaRollbackWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaRollbackWork
|
|
}
|
|
|
|
func (*XaRollbackWorkContext) IsXaRollbackWorkContext() {}
|
|
|
|
func NewXaRollbackWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaRollbackWorkContext {
|
|
var p = new(XaRollbackWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaRollbackWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaRollbackWorkContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) ROLLBACK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLBACK, 0)
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaRollbackWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaRollbackWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaRollbackWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaRollbackWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaRollbackWork() (localctx IXaRollbackWorkContext) {
|
|
localctx = NewXaRollbackWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 378, MySqlParserRULE_xaRollbackWork)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4677)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4678)
|
|
p.Match(MySqlParserROLLBACK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4679)
|
|
p.Xid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXaRecoverWorkContext is an interface to support dynamic dispatch.
|
|
type IXaRecoverWorkContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
XA() antlr.TerminalNode
|
|
RECOVER() antlr.TerminalNode
|
|
CONVERT() antlr.TerminalNode
|
|
Xid() IXidContext
|
|
|
|
// IsXaRecoverWorkContext differentiates from other interfaces.
|
|
IsXaRecoverWorkContext()
|
|
}
|
|
|
|
type XaRecoverWorkContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXaRecoverWorkContext() *XaRecoverWorkContext {
|
|
var p = new(XaRecoverWorkContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaRecoverWork
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXaRecoverWorkContext(p *XaRecoverWorkContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xaRecoverWork
|
|
}
|
|
|
|
func (*XaRecoverWorkContext) IsXaRecoverWorkContext() {}
|
|
|
|
func NewXaRecoverWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaRecoverWorkContext {
|
|
var p = new(XaRecoverWorkContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xaRecoverWork
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XaRecoverWorkContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) RECOVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRECOVER, 0)
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) CONVERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONVERT, 0)
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) Xid() IXidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXidContext)
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXaRecoverWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXaRecoverWork(s)
|
|
}
|
|
}
|
|
|
|
func (s *XaRecoverWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXaRecoverWork(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XaRecoverWork() (localctx IXaRecoverWorkContext) {
|
|
localctx = NewXaRecoverWorkContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 380, MySqlParserRULE_xaRecoverWork)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4681)
|
|
p.Match(MySqlParserXA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4682)
|
|
p.Match(MySqlParserRECOVER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4685)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCONVERT {
|
|
{
|
|
p.SetState(4683)
|
|
p.Match(MySqlParserCONVERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4684)
|
|
p.Xid()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPrepareStatementContext is an interface to support dynamic dispatch.
|
|
type IPrepareStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetQuery returns the query token.
|
|
GetQuery() antlr.Token
|
|
|
|
// GetVariable returns the variable token.
|
|
GetVariable() antlr.Token
|
|
|
|
// SetQuery sets the query token.
|
|
SetQuery(antlr.Token)
|
|
|
|
// SetVariable sets the variable token.
|
|
SetVariable(antlr.Token)
|
|
|
|
// Getter signatures
|
|
PREPARE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
FROM() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
LOCAL_ID() antlr.TerminalNode
|
|
|
|
// IsPrepareStatementContext differentiates from other interfaces.
|
|
IsPrepareStatementContext()
|
|
}
|
|
|
|
type PrepareStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
query antlr.Token
|
|
variable antlr.Token
|
|
}
|
|
|
|
func NewEmptyPrepareStatementContext() *PrepareStatementContext {
|
|
var p = new(PrepareStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_prepareStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPrepareStatementContext(p *PrepareStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_prepareStatement
|
|
}
|
|
|
|
func (*PrepareStatementContext) IsPrepareStatementContext() {}
|
|
|
|
func NewPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrepareStatementContext {
|
|
var p = new(PrepareStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_prepareStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrepareStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PrepareStatementContext) GetQuery() antlr.Token { return s.query }
|
|
|
|
func (s *PrepareStatementContext) GetVariable() antlr.Token { return s.variable }
|
|
|
|
func (s *PrepareStatementContext) SetQuery(v antlr.Token) { s.query = v }
|
|
|
|
func (s *PrepareStatementContext) SetVariable(v antlr.Token) { s.variable = v }
|
|
|
|
func (s *PrepareStatementContext) PREPARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREPARE, 0)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PrepareStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrepareStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrepareStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrepareStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrepareStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PrepareStatement() (localctx IPrepareStatementContext) {
|
|
localctx = NewPrepareStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 382, MySqlParserRULE_prepareStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4687)
|
|
p.Match(MySqlParserPREPARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4688)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4689)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4692)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(4690)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*PrepareStatementContext).query = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCAL_ID:
|
|
{
|
|
p.SetState(4691)
|
|
|
|
var _m = p.Match(MySqlParserLOCAL_ID)
|
|
|
|
localctx.(*PrepareStatementContext).variable = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExecuteStatementContext is an interface to support dynamic dispatch.
|
|
type IExecuteStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EXECUTE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
USING() antlr.TerminalNode
|
|
UserVariables() IUserVariablesContext
|
|
|
|
// IsExecuteStatementContext differentiates from other interfaces.
|
|
IsExecuteStatementContext()
|
|
}
|
|
|
|
type ExecuteStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExecuteStatementContext() *ExecuteStatementContext {
|
|
var p = new(ExecuteStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_executeStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExecuteStatementContext(p *ExecuteStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_executeStatement
|
|
}
|
|
|
|
func (*ExecuteStatementContext) IsExecuteStatementContext() {}
|
|
|
|
func NewExecuteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecuteStatementContext {
|
|
var p = new(ExecuteStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_executeStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExecuteStatementContext) EXECUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXECUTE, 0)
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) UserVariables() IUserVariablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserVariablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserVariablesContext)
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExecuteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExecuteStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExecuteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExecuteStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ExecuteStatement() (localctx IExecuteStatementContext) {
|
|
localctx = NewExecuteStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 384, MySqlParserRULE_executeStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4694)
|
|
p.Match(MySqlParserEXECUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4695)
|
|
p.Uid()
|
|
}
|
|
p.SetState(4698)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(4696)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4697)
|
|
p.UserVariables()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeallocatePrepareContext is an interface to support dynamic dispatch.
|
|
type IDeallocatePrepareContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetDropFormat returns the dropFormat token.
|
|
GetDropFormat() antlr.Token
|
|
|
|
// SetDropFormat sets the dropFormat token.
|
|
SetDropFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
PREPARE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
DEALLOCATE() antlr.TerminalNode
|
|
DROP() antlr.TerminalNode
|
|
|
|
// IsDeallocatePrepareContext differentiates from other interfaces.
|
|
IsDeallocatePrepareContext()
|
|
}
|
|
|
|
type DeallocatePrepareContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
dropFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyDeallocatePrepareContext() *DeallocatePrepareContext {
|
|
var p = new(DeallocatePrepareContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_deallocatePrepare
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeallocatePrepareContext(p *DeallocatePrepareContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_deallocatePrepare
|
|
}
|
|
|
|
func (*DeallocatePrepareContext) IsDeallocatePrepareContext() {}
|
|
|
|
func NewDeallocatePrepareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeallocatePrepareContext {
|
|
var p = new(DeallocatePrepareContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_deallocatePrepare
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeallocatePrepareContext) GetDropFormat() antlr.Token { return s.dropFormat }
|
|
|
|
func (s *DeallocatePrepareContext) SetDropFormat(v antlr.Token) { s.dropFormat = v }
|
|
|
|
func (s *DeallocatePrepareContext) PREPARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREPARE, 0)
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) DEALLOCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEALLOCATE, 0)
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeallocatePrepare(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeallocatePrepare(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeallocatePrepareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeallocatePrepare(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeallocatePrepare() (localctx IDeallocatePrepareContext) {
|
|
localctx = NewDeallocatePrepareContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 386, MySqlParserRULE_deallocatePrepare)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4700)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DeallocatePrepareContext).dropFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDROP || _la == MySqlParserDEALLOCATE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DeallocatePrepareContext).dropFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4701)
|
|
p.Match(MySqlParserPREPARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4702)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRoutineBodyContext is an interface to support dynamic dispatch.
|
|
type IRoutineBodyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BlockStatement() IBlockStatementContext
|
|
SqlStatement() ISqlStatementContext
|
|
|
|
// IsRoutineBodyContext differentiates from other interfaces.
|
|
IsRoutineBodyContext()
|
|
}
|
|
|
|
type RoutineBodyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRoutineBodyContext() *RoutineBodyContext {
|
|
var p = new(RoutineBodyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_routineBody
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRoutineBodyContext(p *RoutineBodyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_routineBody
|
|
}
|
|
|
|
func (*RoutineBodyContext) IsRoutineBodyContext() {}
|
|
|
|
func NewRoutineBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineBodyContext {
|
|
var p = new(RoutineBodyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_routineBody
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoutineBodyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RoutineBodyContext) BlockStatement() IBlockStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBlockStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBlockStatementContext)
|
|
}
|
|
|
|
func (s *RoutineBodyContext) SqlStatement() ISqlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISqlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISqlStatementContext)
|
|
}
|
|
|
|
func (s *RoutineBodyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoutineBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RoutineBodyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoutineBody(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineBodyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoutineBody(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoutineBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoutineBody(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RoutineBody() (localctx IRoutineBodyContext) {
|
|
localctx = NewRoutineBodyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 388, MySqlParserRULE_routineBody)
|
|
p.SetState(4706)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 682, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4704)
|
|
p.BlockStatement()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4705)
|
|
p.SqlStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBlockStatementContext is an interface to support dynamic dispatch.
|
|
type IBlockStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BEGIN() antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
COLON_SYMB() antlr.TerminalNode
|
|
AllDeclareVariable() []IDeclareVariableContext
|
|
DeclareVariable(i int) IDeclareVariableContext
|
|
AllSEMI() []antlr.TerminalNode
|
|
SEMI(i int) antlr.TerminalNode
|
|
AllDeclareCondition() []IDeclareConditionContext
|
|
DeclareCondition(i int) IDeclareConditionContext
|
|
AllDeclareCursor() []IDeclareCursorContext
|
|
DeclareCursor(i int) IDeclareCursorContext
|
|
AllDeclareHandler() []IDeclareHandlerContext
|
|
DeclareHandler(i int) IDeclareHandlerContext
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsBlockStatementContext differentiates from other interfaces.
|
|
IsBlockStatementContext()
|
|
}
|
|
|
|
type BlockStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBlockStatementContext() *BlockStatementContext {
|
|
var p = new(BlockStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_blockStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBlockStatementContext(p *BlockStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_blockStatement
|
|
}
|
|
|
|
func (*BlockStatementContext) IsBlockStatementContext() {}
|
|
|
|
func NewBlockStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockStatementContext {
|
|
var p = new(BlockStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_blockStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BlockStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BlockStatementContext) BEGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEGIN, 0)
|
|
}
|
|
|
|
func (s *BlockStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) COLON_SYMB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLON_SYMB, 0)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllDeclareVariable() []IDeclareVariableContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDeclareVariableContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDeclareVariableContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDeclareVariableContext); ok {
|
|
tst[i] = t.(IDeclareVariableContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) DeclareVariable(i int) IDeclareVariableContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeclareVariableContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeclareVariableContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllSEMI() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSEMI)
|
|
}
|
|
|
|
func (s *BlockStatementContext) SEMI(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEMI, i)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllDeclareCondition() []IDeclareConditionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDeclareConditionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDeclareConditionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDeclareConditionContext); ok {
|
|
tst[i] = t.(IDeclareConditionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) DeclareCondition(i int) IDeclareConditionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeclareConditionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeclareConditionContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllDeclareCursor() []IDeclareCursorContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDeclareCursorContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDeclareCursorContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDeclareCursorContext); ok {
|
|
tst[i] = t.(IDeclareCursorContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) DeclareCursor(i int) IDeclareCursorContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeclareCursorContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeclareCursorContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllDeclareHandler() []IDeclareHandlerContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDeclareHandlerContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDeclareHandlerContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDeclareHandlerContext); ok {
|
|
tst[i] = t.(IDeclareHandlerContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) DeclareHandler(i int) IDeclareHandlerContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeclareHandlerContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeclareHandlerContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BlockStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *BlockStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BlockStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BlockStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBlockStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *BlockStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBlockStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *BlockStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBlockStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BlockStatement() (localctx IBlockStatementContext) {
|
|
localctx = NewBlockStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 390, MySqlParserRULE_blockStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4711)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4708)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4709)
|
|
p.Match(MySqlParserCOLON_SYMB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4713)
|
|
p.Match(MySqlParserBEGIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4719)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4714)
|
|
p.DeclareVariable()
|
|
}
|
|
{
|
|
p.SetState(4715)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4721)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4727)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 685, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4722)
|
|
p.DeclareCondition()
|
|
}
|
|
{
|
|
p.SetState(4723)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4729)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 685, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4735)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4730)
|
|
p.DeclareCursor()
|
|
}
|
|
{
|
|
p.SetState(4731)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(4737)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4743)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserDECLARE {
|
|
{
|
|
p.SetState(4738)
|
|
p.DeclareHandler()
|
|
}
|
|
{
|
|
p.SetState(4739)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(4745)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4749)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(4746)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
}
|
|
p.SetState(4751)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4752)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4754)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4753)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICaseStatementContext is an interface to support dynamic dispatch.
|
|
type ICaseStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllCASE() []antlr.TerminalNode
|
|
CASE(i int) antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
Expression() IExpressionContext
|
|
AllCaseAlternative() []ICaseAlternativeContext
|
|
CaseAlternative(i int) ICaseAlternativeContext
|
|
ELSE() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsCaseStatementContext differentiates from other interfaces.
|
|
IsCaseStatementContext()
|
|
}
|
|
|
|
type CaseStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCaseStatementContext() *CaseStatementContext {
|
|
var p = new(CaseStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCaseStatementContext(p *CaseStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseStatement
|
|
}
|
|
|
|
func (*CaseStatementContext) IsCaseStatementContext() {}
|
|
|
|
func NewCaseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseStatementContext {
|
|
var p = new(CaseStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_caseStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CaseStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CaseStatementContext) AllCASE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCASE)
|
|
}
|
|
|
|
func (s *CaseStatementContext) CASE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASE, i)
|
|
}
|
|
|
|
func (s *CaseStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *CaseStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CaseStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *CaseStatementContext) AllCaseAlternative() []ICaseAlternativeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICaseAlternativeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICaseAlternativeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICaseAlternativeContext); ok {
|
|
tst[i] = t.(ICaseAlternativeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseStatementContext) CaseAlternative(i int) ICaseAlternativeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICaseAlternativeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICaseAlternativeContext)
|
|
}
|
|
|
|
func (s *CaseStatementContext) ELSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELSE, 0)
|
|
}
|
|
|
|
func (s *CaseStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *CaseStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CaseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CaseStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCaseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCaseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCaseStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CaseStatement() (localctx ICaseStatementContext) {
|
|
localctx = NewCaseStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 392, MySqlParserRULE_caseStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4756)
|
|
p.Match(MySqlParserCASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4759)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4757)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(4758)
|
|
p.expression(0)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(4762)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserWHEN {
|
|
{
|
|
p.SetState(4761)
|
|
p.CaseAlternative()
|
|
}
|
|
|
|
p.SetState(4764)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4772)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserELSE {
|
|
{
|
|
p.SetState(4766)
|
|
p.Match(MySqlParserELSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4768)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4767)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4770)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 692, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4774)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4775)
|
|
p.Match(MySqlParserCASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIfStatementContext is an interface to support dynamic dispatch.
|
|
type IIfStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Get_procedureSqlStatement returns the _procedureSqlStatement rule contexts.
|
|
Get_procedureSqlStatement() IProcedureSqlStatementContext
|
|
|
|
// Set_procedureSqlStatement sets the _procedureSqlStatement rule contexts.
|
|
Set_procedureSqlStatement(IProcedureSqlStatementContext)
|
|
|
|
// GetThenStatements returns the thenStatements rule context list.
|
|
GetThenStatements() []IProcedureSqlStatementContext
|
|
|
|
// GetElseStatements returns the elseStatements rule context list.
|
|
GetElseStatements() []IProcedureSqlStatementContext
|
|
|
|
// SetThenStatements sets the thenStatements rule context list.
|
|
SetThenStatements([]IProcedureSqlStatementContext)
|
|
|
|
// SetElseStatements sets the elseStatements rule context list.
|
|
SetElseStatements([]IProcedureSqlStatementContext)
|
|
|
|
// Getter signatures
|
|
AllIF() []antlr.TerminalNode
|
|
IF(i int) antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
THEN() antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
AllElifAlternative() []IElifAlternativeContext
|
|
ElifAlternative(i int) IElifAlternativeContext
|
|
ELSE() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsIfStatementContext differentiates from other interfaces.
|
|
IsIfStatementContext()
|
|
}
|
|
|
|
type IfStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
_procedureSqlStatement IProcedureSqlStatementContext
|
|
thenStatements []IProcedureSqlStatementContext
|
|
elseStatements []IProcedureSqlStatementContext
|
|
}
|
|
|
|
func NewEmptyIfStatementContext() *IfStatementContext {
|
|
var p = new(IfStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIfStatementContext(p *IfStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifStatement
|
|
}
|
|
|
|
func (*IfStatementContext) IsIfStatementContext() {}
|
|
|
|
func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext {
|
|
var p = new(IfStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_ifStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IfStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IfStatementContext) Get_procedureSqlStatement() IProcedureSqlStatementContext {
|
|
return s._procedureSqlStatement
|
|
}
|
|
|
|
func (s *IfStatementContext) Set_procedureSqlStatement(v IProcedureSqlStatementContext) {
|
|
s._procedureSqlStatement = v
|
|
}
|
|
|
|
func (s *IfStatementContext) GetThenStatements() []IProcedureSqlStatementContext {
|
|
return s.thenStatements
|
|
}
|
|
|
|
func (s *IfStatementContext) GetElseStatements() []IProcedureSqlStatementContext {
|
|
return s.elseStatements
|
|
}
|
|
|
|
func (s *IfStatementContext) SetThenStatements(v []IProcedureSqlStatementContext) {
|
|
s.thenStatements = v
|
|
}
|
|
|
|
func (s *IfStatementContext) SetElseStatements(v []IProcedureSqlStatementContext) {
|
|
s.elseStatements = v
|
|
}
|
|
|
|
func (s *IfStatementContext) AllIF() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserIF)
|
|
}
|
|
|
|
func (s *IfStatementContext) IF(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIF, i)
|
|
}
|
|
|
|
func (s *IfStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *IfStatementContext) THEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHEN, 0)
|
|
}
|
|
|
|
func (s *IfStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *IfStatementContext) AllElifAlternative() []IElifAlternativeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IElifAlternativeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IElifAlternativeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IElifAlternativeContext); ok {
|
|
tst[i] = t.(IElifAlternativeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *IfStatementContext) ElifAlternative(i int) IElifAlternativeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IElifAlternativeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IElifAlternativeContext)
|
|
}
|
|
|
|
func (s *IfStatementContext) ELSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELSE, 0)
|
|
}
|
|
|
|
func (s *IfStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *IfStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *IfStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IfStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IfStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIfStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIfStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIfStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IfStatement() (localctx IIfStatementContext) {
|
|
localctx = NewIfStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 394, MySqlParserRULE_ifStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4777)
|
|
p.Match(MySqlParserIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4778)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(4779)
|
|
p.Match(MySqlParserTHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4781)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4780)
|
|
|
|
var _x = p.ProcedureSqlStatement()
|
|
|
|
localctx.(*IfStatementContext)._procedureSqlStatement = _x
|
|
}
|
|
localctx.(*IfStatementContext).thenStatements = append(localctx.(*IfStatementContext).thenStatements, localctx.(*IfStatementContext)._procedureSqlStatement)
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4783)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 694, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4788)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserELSEIF {
|
|
{
|
|
p.SetState(4785)
|
|
p.ElifAlternative()
|
|
}
|
|
|
|
p.SetState(4790)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4797)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserELSE {
|
|
{
|
|
p.SetState(4791)
|
|
p.Match(MySqlParserELSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4793)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4792)
|
|
|
|
var _x = p.ProcedureSqlStatement()
|
|
|
|
localctx.(*IfStatementContext)._procedureSqlStatement = _x
|
|
}
|
|
localctx.(*IfStatementContext).elseStatements = append(localctx.(*IfStatementContext).elseStatements, localctx.(*IfStatementContext)._procedureSqlStatement)
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4795)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4799)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4800)
|
|
p.Match(MySqlParserIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIterateStatementContext is an interface to support dynamic dispatch.
|
|
type IIterateStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ITERATE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsIterateStatementContext differentiates from other interfaces.
|
|
IsIterateStatementContext()
|
|
}
|
|
|
|
type IterateStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIterateStatementContext() *IterateStatementContext {
|
|
var p = new(IterateStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_iterateStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIterateStatementContext(p *IterateStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_iterateStatement
|
|
}
|
|
|
|
func (*IterateStatementContext) IsIterateStatementContext() {}
|
|
|
|
func NewIterateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterateStatementContext {
|
|
var p = new(IterateStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_iterateStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IterateStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IterateStatementContext) ITERATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserITERATE, 0)
|
|
}
|
|
|
|
func (s *IterateStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *IterateStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IterateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IterateStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIterateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *IterateStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIterateStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *IterateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIterateStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IterateStatement() (localctx IIterateStatementContext) {
|
|
localctx = NewIterateStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 396, MySqlParserRULE_iterateStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4802)
|
|
p.Match(MySqlParserITERATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4803)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILeaveStatementContext is an interface to support dynamic dispatch.
|
|
type ILeaveStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LEAVE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsLeaveStatementContext differentiates from other interfaces.
|
|
IsLeaveStatementContext()
|
|
}
|
|
|
|
type LeaveStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLeaveStatementContext() *LeaveStatementContext {
|
|
var p = new(LeaveStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_leaveStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLeaveStatementContext(p *LeaveStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_leaveStatement
|
|
}
|
|
|
|
func (*LeaveStatementContext) IsLeaveStatementContext() {}
|
|
|
|
func NewLeaveStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LeaveStatementContext {
|
|
var p = new(LeaveStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_leaveStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LeaveStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LeaveStatementContext) LEAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAVE, 0)
|
|
}
|
|
|
|
func (s *LeaveStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *LeaveStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LeaveStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LeaveStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLeaveStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LeaveStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLeaveStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LeaveStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLeaveStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LeaveStatement() (localctx ILeaveStatementContext) {
|
|
localctx = NewLeaveStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 398, MySqlParserRULE_leaveStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4805)
|
|
p.Match(MySqlParserLEAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4806)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILoopStatementContext is an interface to support dynamic dispatch.
|
|
type ILoopStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllLOOP() []antlr.TerminalNode
|
|
LOOP(i int) antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
COLON_SYMB() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsLoopStatementContext differentiates from other interfaces.
|
|
IsLoopStatementContext()
|
|
}
|
|
|
|
type LoopStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLoopStatementContext() *LoopStatementContext {
|
|
var p = new(LoopStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loopStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLoopStatementContext(p *LoopStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loopStatement
|
|
}
|
|
|
|
func (*LoopStatementContext) IsLoopStatementContext() {}
|
|
|
|
func NewLoopStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopStatementContext {
|
|
var p = new(LoopStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_loopStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LoopStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LoopStatementContext) AllLOOP() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLOOP)
|
|
}
|
|
|
|
func (s *LoopStatementContext) LOOP(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOOP, i)
|
|
}
|
|
|
|
func (s *LoopStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *LoopStatementContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoopStatementContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *LoopStatementContext) COLON_SYMB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLON_SYMB, 0)
|
|
}
|
|
|
|
func (s *LoopStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoopStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *LoopStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LoopStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LoopStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLoopStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoopStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLoopStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoopStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLoopStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LoopStatement() (localctx ILoopStatementContext) {
|
|
localctx = NewLoopStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 400, MySqlParserRULE_loopStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4811)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4808)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4809)
|
|
p.Match(MySqlParserCOLON_SYMB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4813)
|
|
p.Match(MySqlParserLOOP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4815)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4814)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4817)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 699, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4819)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4820)
|
|
p.Match(MySqlParserLOOP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4822)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4821)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRepeatStatementContext is an interface to support dynamic dispatch.
|
|
type IRepeatStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllREPEAT() []antlr.TerminalNode
|
|
REPEAT(i int) antlr.TerminalNode
|
|
UNTIL() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
END() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
COLON_SYMB() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsRepeatStatementContext differentiates from other interfaces.
|
|
IsRepeatStatementContext()
|
|
}
|
|
|
|
type RepeatStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRepeatStatementContext() *RepeatStatementContext {
|
|
var p = new(RepeatStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_repeatStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRepeatStatementContext(p *RepeatStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_repeatStatement
|
|
}
|
|
|
|
func (*RepeatStatementContext) IsRepeatStatementContext() {}
|
|
|
|
func NewRepeatStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepeatStatementContext {
|
|
var p = new(RepeatStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_repeatStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RepeatStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RepeatStatementContext) AllREPEAT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserREPEAT)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) REPEAT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPEAT, i)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) UNTIL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNTIL, 0)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RepeatStatementContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) COLON_SYMB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLON_SYMB, 0)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RepeatStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RepeatStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RepeatStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRepeatStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *RepeatStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRepeatStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *RepeatStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRepeatStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RepeatStatement() (localctx IRepeatStatementContext) {
|
|
localctx = NewRepeatStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 402, MySqlParserRULE_repeatStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4827)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 701, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4824)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4825)
|
|
p.Match(MySqlParserCOLON_SYMB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4829)
|
|
p.Match(MySqlParserREPEAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4831)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4830)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4833)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 702, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4835)
|
|
p.Match(MySqlParserUNTIL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4836)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(4837)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4838)
|
|
p.Match(MySqlParserREPEAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4840)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4839)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IReturnStatementContext is an interface to support dynamic dispatch.
|
|
type IReturnStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RETURN() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsReturnStatementContext differentiates from other interfaces.
|
|
IsReturnStatementContext()
|
|
}
|
|
|
|
type ReturnStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyReturnStatementContext() *ReturnStatementContext {
|
|
var p = new(ReturnStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_returnStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyReturnStatementContext(p *ReturnStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_returnStatement
|
|
}
|
|
|
|
func (*ReturnStatementContext) IsReturnStatementContext() {}
|
|
|
|
func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext {
|
|
var p = new(ReturnStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_returnStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ReturnStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ReturnStatementContext) RETURN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURN, 0)
|
|
}
|
|
|
|
func (s *ReturnStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ReturnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ReturnStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterReturnStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitReturnStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ReturnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitReturnStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ReturnStatement() (localctx IReturnStatementContext) {
|
|
localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 404, MySqlParserRULE_returnStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4842)
|
|
p.Match(MySqlParserRETURN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4843)
|
|
p.expression(0)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWhileStatementContext is an interface to support dynamic dispatch.
|
|
type IWhileStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllWHILE() []antlr.TerminalNode
|
|
WHILE(i int) antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
DO() antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
COLON_SYMB() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsWhileStatementContext differentiates from other interfaces.
|
|
IsWhileStatementContext()
|
|
}
|
|
|
|
type WhileStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWhileStatementContext() *WhileStatementContext {
|
|
var p = new(WhileStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_whileStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWhileStatementContext(p *WhileStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_whileStatement
|
|
}
|
|
|
|
func (*WhileStatementContext) IsWhileStatementContext() {}
|
|
|
|
func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext {
|
|
var p = new(WhileStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_whileStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WhileStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WhileStatementContext) AllWHILE() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserWHILE)
|
|
}
|
|
|
|
func (s *WhileStatementContext) WHILE(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHILE, i)
|
|
}
|
|
|
|
func (s *WhileStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *WhileStatementContext) DO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDO, 0)
|
|
}
|
|
|
|
func (s *WhileStatementContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *WhileStatementContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WhileStatementContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *WhileStatementContext) COLON_SYMB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLON_SYMB, 0)
|
|
}
|
|
|
|
func (s *WhileStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WhileStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWhileStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWhileStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WhileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWhileStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WhileStatement() (localctx IWhileStatementContext) {
|
|
localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 406, MySqlParserRULE_whileStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4848)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4845)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4846)
|
|
p.Match(MySqlParserCOLON_SYMB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4850)
|
|
p.Match(MySqlParserWHILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4851)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(4852)
|
|
p.Match(MySqlParserDO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4854)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4853)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4856)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4858)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4859)
|
|
p.Match(MySqlParserWHILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4861)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&8627683329) != 0) {
|
|
{
|
|
p.SetState(4860)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICursorStatementContext is an interface to support dynamic dispatch.
|
|
type ICursorStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsCursorStatementContext differentiates from other interfaces.
|
|
IsCursorStatementContext()
|
|
}
|
|
|
|
type CursorStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCursorStatementContext() *CursorStatementContext {
|
|
var p = new(CursorStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cursorStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCursorStatementContext(p *CursorStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cursorStatement
|
|
}
|
|
|
|
func (*CursorStatementContext) IsCursorStatementContext() {}
|
|
|
|
func NewCursorStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CursorStatementContext {
|
|
var p = new(CursorStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_cursorStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CursorStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CursorStatementContext) CopyAll(ctx *CursorStatementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *CursorStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CursorStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type CloseCursorContext struct {
|
|
CursorStatementContext
|
|
}
|
|
|
|
func NewCloseCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CloseCursorContext {
|
|
var p = new(CloseCursorContext)
|
|
|
|
InitEmptyCursorStatementContext(&p.CursorStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CursorStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CloseCursorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CloseCursorContext) CLOSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLOSE, 0)
|
|
}
|
|
|
|
func (s *CloseCursorContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CloseCursorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCloseCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *CloseCursorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCloseCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *CloseCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCloseCursor(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type OpenCursorContext struct {
|
|
CursorStatementContext
|
|
}
|
|
|
|
func NewOpenCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OpenCursorContext {
|
|
var p = new(OpenCursorContext)
|
|
|
|
InitEmptyCursorStatementContext(&p.CursorStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CursorStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OpenCursorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OpenCursorContext) OPEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPEN, 0)
|
|
}
|
|
|
|
func (s *OpenCursorContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *OpenCursorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOpenCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *OpenCursorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOpenCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *OpenCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOpenCursor(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type FetchCursorContext struct {
|
|
CursorStatementContext
|
|
}
|
|
|
|
func NewFetchCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FetchCursorContext {
|
|
var p = new(FetchCursorContext)
|
|
|
|
InitEmptyCursorStatementContext(&p.CursorStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CursorStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FetchCursorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FetchCursorContext) FETCH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFETCH, 0)
|
|
}
|
|
|
|
func (s *FetchCursorContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *FetchCursorContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *FetchCursorContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *FetchCursorContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *FetchCursorContext) NEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEXT, 0)
|
|
}
|
|
|
|
func (s *FetchCursorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFetchCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *FetchCursorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFetchCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *FetchCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFetchCursor(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CursorStatement() (localctx ICursorStatementContext) {
|
|
localctx = NewCursorStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 408, MySqlParserRULE_cursorStatement)
|
|
var _la int
|
|
|
|
p.SetState(4878)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCLOSE:
|
|
localctx = NewCloseCursorContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4863)
|
|
p.Match(MySqlParserCLOSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4864)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserFETCH:
|
|
localctx = NewFetchCursorContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4865)
|
|
p.Match(MySqlParserFETCH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4870)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 708, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(4867)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNEXT {
|
|
{
|
|
p.SetState(4866)
|
|
p.Match(MySqlParserNEXT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4869)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4872)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4873)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4874)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserOPEN:
|
|
localctx = NewOpenCursorContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4876)
|
|
p.Match(MySqlParserOPEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4877)
|
|
p.Uid()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeclareVariableContext is an interface to support dynamic dispatch.
|
|
type IDeclareVariableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DECLARE() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
DataType() IDataTypeContext
|
|
DEFAULT() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsDeclareVariableContext differentiates from other interfaces.
|
|
IsDeclareVariableContext()
|
|
}
|
|
|
|
type DeclareVariableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDeclareVariableContext() *DeclareVariableContext {
|
|
var p = new(DeclareVariableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareVariable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeclareVariableContext(p *DeclareVariableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareVariable
|
|
}
|
|
|
|
func (*DeclareVariableContext) IsDeclareVariableContext() {}
|
|
|
|
func NewDeclareVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareVariableContext {
|
|
var p = new(DeclareVariableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_declareVariable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeclareVariableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeclareVariableContext) DECLARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECLARE, 0)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) DataType() IDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeContext)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeclareVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeclareVariableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeclareVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareVariableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeclareVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeclareVariable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeclareVariable() (localctx IDeclareVariableContext) {
|
|
localctx = NewDeclareVariableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 410, MySqlParserRULE_declareVariable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4880)
|
|
p.Match(MySqlParserDECLARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4881)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(4882)
|
|
p.DataType()
|
|
}
|
|
p.SetState(4885)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(4883)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4884)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeclareConditionContext is an interface to support dynamic dispatch.
|
|
type IDeclareConditionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DECLARE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
CONDITION() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
SQLSTATE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
VALUE() antlr.TerminalNode
|
|
|
|
// IsDeclareConditionContext differentiates from other interfaces.
|
|
IsDeclareConditionContext()
|
|
}
|
|
|
|
type DeclareConditionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDeclareConditionContext() *DeclareConditionContext {
|
|
var p = new(DeclareConditionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareCondition
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeclareConditionContext(p *DeclareConditionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareCondition
|
|
}
|
|
|
|
func (*DeclareConditionContext) IsDeclareConditionContext() {}
|
|
|
|
func NewDeclareConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareConditionContext {
|
|
var p = new(DeclareConditionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_declareCondition
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeclareConditionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeclareConditionContext) DECLARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECLARE, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) CONDITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONDITION, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLSTATE, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeclareConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeclareConditionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeclareCondition(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareConditionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeclareCondition(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeclareCondition(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeclareCondition() (localctx IDeclareConditionContext) {
|
|
localctx = NewDeclareConditionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 412, MySqlParserRULE_declareCondition)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4887)
|
|
p.Match(MySqlParserDECLARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4888)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4889)
|
|
p.Match(MySqlParserCONDITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4890)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4897)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(4891)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserSQLSTATE:
|
|
{
|
|
p.SetState(4892)
|
|
p.Match(MySqlParserSQLSTATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4894)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVALUE {
|
|
{
|
|
p.SetState(4893)
|
|
p.Match(MySqlParserVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4896)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeclareCursorContext is an interface to support dynamic dispatch.
|
|
type IDeclareCursorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DECLARE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
CURSOR() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
SelectStatement() ISelectStatementContext
|
|
|
|
// IsDeclareCursorContext differentiates from other interfaces.
|
|
IsDeclareCursorContext()
|
|
}
|
|
|
|
type DeclareCursorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDeclareCursorContext() *DeclareCursorContext {
|
|
var p = new(DeclareCursorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareCursor
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeclareCursorContext(p *DeclareCursorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareCursor
|
|
}
|
|
|
|
func (*DeclareCursorContext) IsDeclareCursorContext() {}
|
|
|
|
func NewDeclareCursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareCursorContext {
|
|
var p = new(DeclareCursorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_declareCursor
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeclareCursorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeclareCursorContext) DECLARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECLARE, 0)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) CURSOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURSOR, 0)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeclareCursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeclareCursorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeclareCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareCursorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeclareCursor(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeclareCursor(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeclareCursor() (localctx IDeclareCursorContext) {
|
|
localctx = NewDeclareCursorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 414, MySqlParserRULE_declareCursor)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4899)
|
|
p.Match(MySqlParserDECLARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4900)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(4901)
|
|
p.Match(MySqlParserCURSOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4902)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4903)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDeclareHandlerContext is an interface to support dynamic dispatch.
|
|
type IDeclareHandlerContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetHandlerAction returns the handlerAction token.
|
|
GetHandlerAction() antlr.Token
|
|
|
|
// SetHandlerAction sets the handlerAction token.
|
|
SetHandlerAction(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DECLARE() antlr.TerminalNode
|
|
HANDLER() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
AllHandlerConditionValue() []IHandlerConditionValueContext
|
|
HandlerConditionValue(i int) IHandlerConditionValueContext
|
|
RoutineBody() IRoutineBodyContext
|
|
CONTINUE() antlr.TerminalNode
|
|
EXIT() antlr.TerminalNode
|
|
UNDO() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsDeclareHandlerContext differentiates from other interfaces.
|
|
IsDeclareHandlerContext()
|
|
}
|
|
|
|
type DeclareHandlerContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
handlerAction antlr.Token
|
|
}
|
|
|
|
func NewEmptyDeclareHandlerContext() *DeclareHandlerContext {
|
|
var p = new(DeclareHandlerContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareHandler
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDeclareHandlerContext(p *DeclareHandlerContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_declareHandler
|
|
}
|
|
|
|
func (*DeclareHandlerContext) IsDeclareHandlerContext() {}
|
|
|
|
func NewDeclareHandlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareHandlerContext {
|
|
var p = new(DeclareHandlerContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_declareHandler
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DeclareHandlerContext) GetHandlerAction() antlr.Token { return s.handlerAction }
|
|
|
|
func (s *DeclareHandlerContext) SetHandlerAction(v antlr.Token) { s.handlerAction = v }
|
|
|
|
func (s *DeclareHandlerContext) DECLARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECLARE, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) AllHandlerConditionValue() []IHandlerConditionValueContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IHandlerConditionValueContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IHandlerConditionValueContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IHandlerConditionValueContext); ok {
|
|
tst[i] = t.(IHandlerConditionValueContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) HandlerConditionValue(i int) IHandlerConditionValueContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHandlerConditionValueContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHandlerConditionValueContext)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) RoutineBody() IRoutineBodyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoutineBodyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoutineBodyContext)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) CONTINUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTINUE, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) EXIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXIT, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) UNDO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDO, 0)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDeclareHandler(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDeclareHandler(s)
|
|
}
|
|
}
|
|
|
|
func (s *DeclareHandlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDeclareHandler(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DeclareHandler() (localctx IDeclareHandlerContext) {
|
|
localctx = NewDeclareHandlerContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 416, MySqlParserRULE_declareHandler)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4905)
|
|
p.Match(MySqlParserDECLARE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4906)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DeclareHandlerContext).handlerAction = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCONTINUE || _la == MySqlParserEXIT || _la == MySqlParserUNDO) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DeclareHandlerContext).handlerAction = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4907)
|
|
p.Match(MySqlParserHANDLER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4908)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4909)
|
|
p.HandlerConditionValue()
|
|
}
|
|
p.SetState(4914)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4910)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4911)
|
|
p.HandlerConditionValue()
|
|
}
|
|
|
|
p.SetState(4916)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(4917)
|
|
p.RoutineBody()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHandlerConditionValueContext is an interface to support dynamic dispatch.
|
|
type IHandlerConditionValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsHandlerConditionValueContext differentiates from other interfaces.
|
|
IsHandlerConditionValueContext()
|
|
}
|
|
|
|
type HandlerConditionValueContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHandlerConditionValueContext() *HandlerConditionValueContext {
|
|
var p = new(HandlerConditionValueContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerConditionValue
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHandlerConditionValueContext(p *HandlerConditionValueContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_handlerConditionValue
|
|
}
|
|
|
|
func (*HandlerConditionValueContext) IsHandlerConditionValueContext() {}
|
|
|
|
func NewHandlerConditionValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerConditionValueContext {
|
|
var p = new(HandlerConditionValueContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_handlerConditionValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HandlerConditionValueContext) CopyAll(ctx *HandlerConditionValueContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *HandlerConditionValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type HandlerConditionWarningContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionWarningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionWarningContext {
|
|
var p = new(HandlerConditionWarningContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionWarningContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionWarningContext) SQLWARNING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLWARNING, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionWarningContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionWarning(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionWarningContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionWarning(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionWarningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionWarning(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HandlerConditionCodeContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionCodeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionCodeContext {
|
|
var p = new(HandlerConditionCodeContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionCodeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionCodeContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *HandlerConditionCodeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionCode(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionCodeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionCode(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionCodeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionCode(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HandlerConditionNotfoundContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionNotfoundContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionNotfoundContext {
|
|
var p = new(HandlerConditionNotfoundContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) FOUND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOUND, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionNotfound(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionNotfound(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionNotfoundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionNotfound(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HandlerConditionStateContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionStateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionStateContext {
|
|
var p = new(HandlerConditionStateContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLSTATE, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionState(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionState(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionStateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionState(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HandlerConditionExceptionContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionExceptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionExceptionContext {
|
|
var p = new(HandlerConditionExceptionContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionExceptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionExceptionContext) SQLEXCEPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLEXCEPTION, 0)
|
|
}
|
|
|
|
func (s *HandlerConditionExceptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionException(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionExceptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionException(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionExceptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionException(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HandlerConditionNameContext struct {
|
|
HandlerConditionValueContext
|
|
}
|
|
|
|
func NewHandlerConditionNameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionNameContext {
|
|
var p = new(HandlerConditionNameContext)
|
|
|
|
InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*HandlerConditionValueContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HandlerConditionNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HandlerConditionNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *HandlerConditionNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHandlerConditionName(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHandlerConditionName(s)
|
|
}
|
|
}
|
|
|
|
func (s *HandlerConditionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHandlerConditionName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HandlerConditionValue() (localctx IHandlerConditionValueContext) {
|
|
localctx = NewHandlerConditionValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 418, MySqlParserRULE_handlerConditionValue)
|
|
var _la int
|
|
|
|
p.SetState(4930)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
localctx = NewHandlerConditionCodeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4919)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserSQLSTATE:
|
|
localctx = NewHandlerConditionStateContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4920)
|
|
p.Match(MySqlParserSQLSTATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4922)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVALUE {
|
|
{
|
|
p.SetState(4921)
|
|
p.Match(MySqlParserVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4924)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
localctx = NewHandlerConditionNameContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(4925)
|
|
p.Uid()
|
|
}
|
|
|
|
case MySqlParserSQLWARNING:
|
|
localctx = NewHandlerConditionWarningContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(4926)
|
|
p.Match(MySqlParserSQLWARNING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserNOT:
|
|
localctx = NewHandlerConditionNotfoundContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(4927)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4928)
|
|
p.Match(MySqlParserFOUND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSQLEXCEPTION:
|
|
localctx = NewHandlerConditionExceptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(4929)
|
|
p.Match(MySqlParserSQLEXCEPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IProcedureSqlStatementContext is an interface to support dynamic dispatch.
|
|
type IProcedureSqlStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SEMI() antlr.TerminalNode
|
|
CompoundStatement() ICompoundStatementContext
|
|
SqlStatement() ISqlStatementContext
|
|
|
|
// IsProcedureSqlStatementContext differentiates from other interfaces.
|
|
IsProcedureSqlStatementContext()
|
|
}
|
|
|
|
type ProcedureSqlStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyProcedureSqlStatementContext() *ProcedureSqlStatementContext {
|
|
var p = new(ProcedureSqlStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_procedureSqlStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyProcedureSqlStatementContext(p *ProcedureSqlStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_procedureSqlStatement
|
|
}
|
|
|
|
func (*ProcedureSqlStatementContext) IsProcedureSqlStatementContext() {}
|
|
|
|
func NewProcedureSqlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProcedureSqlStatementContext {
|
|
var p = new(ProcedureSqlStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_procedureSqlStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ProcedureSqlStatementContext) SEMI() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEMI, 0)
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) CompoundStatement() ICompoundStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICompoundStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICompoundStatementContext)
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) SqlStatement() ISqlStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISqlStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISqlStatementContext)
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterProcedureSqlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitProcedureSqlStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ProcedureSqlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitProcedureSqlStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ProcedureSqlStatement() (localctx IProcedureSqlStatementContext) {
|
|
localctx = NewProcedureSqlStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 420, MySqlParserRULE_procedureSqlStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(4934)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(4932)
|
|
p.CompoundStatement()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(4933)
|
|
p.SqlStatement()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4936)
|
|
p.Match(MySqlParserSEMI)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICaseAlternativeContext is an interface to support dynamic dispatch.
|
|
type ICaseAlternativeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WHEN() antlr.TerminalNode
|
|
THEN() antlr.TerminalNode
|
|
Constant() IConstantContext
|
|
Expression() IExpressionContext
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsCaseAlternativeContext differentiates from other interfaces.
|
|
IsCaseAlternativeContext()
|
|
}
|
|
|
|
type CaseAlternativeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCaseAlternativeContext() *CaseAlternativeContext {
|
|
var p = new(CaseAlternativeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseAlternative
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCaseAlternativeContext(p *CaseAlternativeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseAlternative
|
|
}
|
|
|
|
func (*CaseAlternativeContext) IsCaseAlternativeContext() {}
|
|
|
|
func NewCaseAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseAlternativeContext {
|
|
var p = new(CaseAlternativeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_caseAlternative
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CaseAlternativeContext) WHEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHEN, 0)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) THEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHEN, 0)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) Constant() IConstantContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCaseAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCaseAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCaseAlternative(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CaseAlternative() (localctx ICaseAlternativeContext) {
|
|
localctx = NewCaseAlternativeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 422, MySqlParserRULE_caseAlternative)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4938)
|
|
p.Match(MySqlParserWHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4941)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(4939)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(4940)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(4943)
|
|
p.Match(MySqlParserTHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4945)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4944)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4947)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 718, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IElifAlternativeContext is an interface to support dynamic dispatch.
|
|
type IElifAlternativeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ELSEIF() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
THEN() antlr.TerminalNode
|
|
AllProcedureSqlStatement() []IProcedureSqlStatementContext
|
|
ProcedureSqlStatement(i int) IProcedureSqlStatementContext
|
|
|
|
// IsElifAlternativeContext differentiates from other interfaces.
|
|
IsElifAlternativeContext()
|
|
}
|
|
|
|
type ElifAlternativeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyElifAlternativeContext() *ElifAlternativeContext {
|
|
var p = new(ElifAlternativeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_elifAlternative
|
|
return p
|
|
}
|
|
|
|
func InitEmptyElifAlternativeContext(p *ElifAlternativeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_elifAlternative
|
|
}
|
|
|
|
func (*ElifAlternativeContext) IsElifAlternativeContext() {}
|
|
|
|
func NewElifAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElifAlternativeContext {
|
|
var p = new(ElifAlternativeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_elifAlternative
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ElifAlternativeContext) ELSEIF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELSEIF, 0)
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) THEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHEN, 0)
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IProcedureSqlStatementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
tst[i] = t.(IProcedureSqlStatementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IProcedureSqlStatementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IProcedureSqlStatementContext)
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterElifAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitElifAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *ElifAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitElifAlternative(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ElifAlternative() (localctx IElifAlternativeContext) {
|
|
localctx = NewElifAlternativeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 424, MySqlParserRULE_elifAlternative)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4949)
|
|
p.Match(MySqlParserELSEIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4950)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(4951)
|
|
p.Match(MySqlParserTHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4953)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(4952)
|
|
p.ProcedureSqlStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(4955)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAlterUserContext is an interface to support dynamic dispatch.
|
|
type IAlterUserContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsAlterUserContext differentiates from other interfaces.
|
|
IsAlterUserContext()
|
|
}
|
|
|
|
type AlterUserContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAlterUserContext() *AlterUserContext {
|
|
var p = new(AlterUserContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterUser
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAlterUserContext(p *AlterUserContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_alterUser
|
|
}
|
|
|
|
func (*AlterUserContext) IsAlterUserContext() {}
|
|
|
|
func NewAlterUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterUserContext {
|
|
var p = new(AlterUserContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_alterUser
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterUserContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AlterUserContext) CopyAll(ctx *AlterUserContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *AlterUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type AlterUserMysqlV80Context struct {
|
|
AlterUserContext
|
|
tlsNone antlr.Token
|
|
}
|
|
|
|
func NewAlterUserMysqlV80Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUserMysqlV80Context {
|
|
var p = new(AlterUserMysqlV80Context)
|
|
|
|
InitEmptyAlterUserContext(&p.AlterUserContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterUserContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) GetTlsNone() antlr.Token { return s.tlsNone }
|
|
|
|
func (s *AlterUserMysqlV80Context) SetTlsNone(v antlr.Token) { s.tlsNone = v }
|
|
|
|
func (s *AlterUserMysqlV80Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllUserAuthOption() []IUserAuthOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserAuthOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserAuthOptionContext); ok {
|
|
tst[i] = t.(IUserAuthOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) UserAuthOption(i int) IUserAuthOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserAuthOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) REQUIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREQUIRE, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllUserPasswordOption() []IUserPasswordOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserPasswordOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
tst[i] = t.(IUserPasswordOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) UserPasswordOption(i int) IUserPasswordOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserPasswordOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllUserLockOption() []IUserLockOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserLockOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserLockOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserLockOptionContext); ok {
|
|
tst[i] = t.(IUserLockOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) UserLockOption(i int) IUserLockOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserLockOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserLockOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllTlsOption() []ITlsOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITlsOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITlsOptionContext); ok {
|
|
tst[i] = t.(ITlsOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) TlsOption(i int) ITlsOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITlsOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllUserResourceOption() []IUserResourceOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserResourceOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserResourceOptionContext); ok {
|
|
tst[i] = t.(IUserResourceOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) UserResourceOption(i int) IUserResourceOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserResourceOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AllAND() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserAND)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) AND(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, i)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) RoleOption() IRoleOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleOptionContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterUserMysqlV80(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterUserMysqlV80(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUserMysqlV80Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterUserMysqlV80(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AlterUserMysqlV56Context struct {
|
|
AlterUserContext
|
|
}
|
|
|
|
func NewAlterUserMysqlV56Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUserMysqlV56Context {
|
|
var p = new(AlterUserMysqlV56Context)
|
|
|
|
InitEmptyAlterUserContext(&p.AlterUserContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AlterUserContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) AllUserSpecification() []IUserSpecificationContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserSpecificationContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserSpecificationContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserSpecificationContext); ok {
|
|
tst[i] = t.(IUserSpecificationContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) UserSpecification(i int) IUserSpecificationContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserSpecificationContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserSpecificationContext)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAlterUserMysqlV56(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAlterUserMysqlV56(s)
|
|
}
|
|
}
|
|
|
|
func (s *AlterUserMysqlV56Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAlterUserMysqlV56(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AlterUser() (localctx IAlterUserContext) {
|
|
localctx = NewAlterUserContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 426, MySqlParserRULE_alterUser)
|
|
var _la int
|
|
|
|
p.SetState(5030)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 734, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewAlterUserMysqlV56Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(4957)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4958)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4959)
|
|
p.UserSpecification()
|
|
}
|
|
p.SetState(4964)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4960)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4961)
|
|
p.UserSpecification()
|
|
}
|
|
|
|
p.SetState(4966)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewAlterUserMysqlV80Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(4967)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4968)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4970)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIF {
|
|
{
|
|
p.SetState(4969)
|
|
p.IfExists()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4972)
|
|
p.UserAuthOption()
|
|
}
|
|
p.SetState(4977)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(4973)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(4974)
|
|
p.UserAuthOption()
|
|
}
|
|
|
|
p.SetState(4979)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(4994)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserREQUIRE {
|
|
{
|
|
p.SetState(4980)
|
|
p.Match(MySqlParserREQUIRE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4992)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNONE:
|
|
{
|
|
p.SetState(4981)
|
|
|
|
var _m = p.Match(MySqlParserNONE)
|
|
|
|
localctx.(*AlterUserMysqlV80Context).tlsNone = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509:
|
|
{
|
|
p.SetState(4982)
|
|
p.TlsOption()
|
|
}
|
|
p.SetState(4989)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 {
|
|
p.SetState(4984)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAND {
|
|
{
|
|
p.SetState(4983)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(4986)
|
|
p.TlsOption()
|
|
}
|
|
|
|
p.SetState(4991)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(5002)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(4996)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(4998)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = ((int64((_la-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&51) != 0) {
|
|
{
|
|
p.SetState(4997)
|
|
p.UserResourceOption()
|
|
}
|
|
|
|
p.SetState(5000)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5008)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserACCOUNT || _la == MySqlParserFAILED_LOGIN_ATTEMPTS || _la == MySqlParserPASSWORD || _la == MySqlParserPASSWORD_LOCK_TIME {
|
|
p.SetState(5006)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME:
|
|
{
|
|
p.SetState(5004)
|
|
p.UserPasswordOption()
|
|
}
|
|
|
|
case MySqlParserACCOUNT:
|
|
{
|
|
p.SetState(5005)
|
|
p.UserLockOption()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5010)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5015)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCOMMENT:
|
|
{
|
|
p.SetState(5011)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5012)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserATTRIBUTE:
|
|
{
|
|
p.SetState(5013)
|
|
p.Match(MySqlParserATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5014)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewAlterUserMysqlV80Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5017)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5018)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5020)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 732, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5019)
|
|
p.IfExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5024)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5022)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5023)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5026)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5027)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5028)
|
|
p.RoleOption()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateUserContext is an interface to support dynamic dispatch.
|
|
type ICreateUserContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsCreateUserContext differentiates from other interfaces.
|
|
IsCreateUserContext()
|
|
}
|
|
|
|
type CreateUserContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCreateUserContext() *CreateUserContext {
|
|
var p = new(CreateUserContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createUser
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateUserContext(p *CreateUserContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createUser
|
|
}
|
|
|
|
func (*CreateUserContext) IsCreateUserContext() {}
|
|
|
|
func NewCreateUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateUserContext {
|
|
var p = new(CreateUserContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createUser
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateUserContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateUserContext) CopyAll(ctx *CreateUserContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *CreateUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type CreateUserMysqlV56Context struct {
|
|
CreateUserContext
|
|
}
|
|
|
|
func NewCreateUserMysqlV56Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserMysqlV56Context {
|
|
var p = new(CreateUserMysqlV56Context)
|
|
|
|
InitEmptyCreateUserContext(&p.CreateUserContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateUserContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) AllUserAuthOption() []IUserAuthOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserAuthOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserAuthOptionContext); ok {
|
|
tst[i] = t.(IUserAuthOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) UserAuthOption(i int) IUserAuthOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserAuthOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateUserMysqlV56(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateUserMysqlV56(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUserMysqlV56Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateUserMysqlV56(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CreateUserMysqlV80Context struct {
|
|
CreateUserContext
|
|
tlsNone antlr.Token
|
|
}
|
|
|
|
func NewCreateUserMysqlV80Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserMysqlV80Context {
|
|
var p = new(CreateUserMysqlV80Context)
|
|
|
|
InitEmptyCreateUserContext(&p.CreateUserContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*CreateUserContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) GetTlsNone() antlr.Token { return s.tlsNone }
|
|
|
|
func (s *CreateUserMysqlV80Context) SetTlsNone(v antlr.Token) { s.tlsNone = v }
|
|
|
|
func (s *CreateUserMysqlV80Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllUserAuthOption() []IUserAuthOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserAuthOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserAuthOptionContext); ok {
|
|
tst[i] = t.(IUserAuthOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) UserAuthOption(i int) IUserAuthOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserAuthOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) RoleOption() IRoleOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) REQUIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREQUIRE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllUserPasswordOption() []IUserPasswordOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserPasswordOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
tst[i] = t.(IUserPasswordOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) UserPasswordOption(i int) IUserPasswordOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserPasswordOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllUserLockOption() []IUserLockOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserLockOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserLockOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserLockOptionContext); ok {
|
|
tst[i] = t.(IUserLockOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) UserLockOption(i int) IUserLockOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserLockOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserLockOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllTlsOption() []ITlsOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITlsOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITlsOptionContext); ok {
|
|
tst[i] = t.(ITlsOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) TlsOption(i int) ITlsOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITlsOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllUserResourceOption() []IUserResourceOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserResourceOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserResourceOptionContext); ok {
|
|
tst[i] = t.(IUserResourceOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) UserResourceOption(i int) IUserResourceOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserResourceOptionContext)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AllAND() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserAND)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) AND(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, i)
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateUserMysqlV80(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateUserMysqlV80(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUserMysqlV80Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateUserMysqlV80(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateUser() (localctx ICreateUserContext) {
|
|
localctx = NewCreateUserContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 428, MySqlParserRULE_createUser)
|
|
var _la int
|
|
|
|
p.SetState(5097)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 748, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewCreateUserMysqlV56Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5032)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5033)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5034)
|
|
p.UserAuthOption()
|
|
}
|
|
p.SetState(5039)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5035)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5036)
|
|
p.UserAuthOption()
|
|
}
|
|
|
|
p.SetState(5041)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewCreateUserMysqlV80Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5042)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5043)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5045)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIF {
|
|
{
|
|
p.SetState(5044)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5047)
|
|
p.UserAuthOption()
|
|
}
|
|
p.SetState(5052)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5048)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5049)
|
|
p.UserAuthOption()
|
|
}
|
|
|
|
p.SetState(5054)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5058)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT {
|
|
{
|
|
p.SetState(5055)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5056)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5057)
|
|
p.RoleOption()
|
|
}
|
|
|
|
}
|
|
p.SetState(5074)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserREQUIRE {
|
|
{
|
|
p.SetState(5060)
|
|
p.Match(MySqlParserREQUIRE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5072)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNONE:
|
|
{
|
|
p.SetState(5061)
|
|
|
|
var _m = p.Match(MySqlParserNONE)
|
|
|
|
localctx.(*CreateUserMysqlV80Context).tlsNone = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509:
|
|
{
|
|
p.SetState(5062)
|
|
p.TlsOption()
|
|
}
|
|
p.SetState(5069)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 {
|
|
p.SetState(5064)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAND {
|
|
{
|
|
p.SetState(5063)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5066)
|
|
p.TlsOption()
|
|
}
|
|
|
|
p.SetState(5071)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(5082)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 744, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5076)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5078)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = ((int64((_la-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&51) != 0) {
|
|
{
|
|
p.SetState(5077)
|
|
p.UserResourceOption()
|
|
}
|
|
|
|
p.SetState(5080)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5088)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserACCOUNT || _la == MySqlParserFAILED_LOGIN_ATTEMPTS || _la == MySqlParserPASSWORD || _la == MySqlParserPASSWORD_LOCK_TIME {
|
|
p.SetState(5086)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME:
|
|
{
|
|
p.SetState(5084)
|
|
p.UserPasswordOption()
|
|
}
|
|
|
|
case MySqlParserACCOUNT:
|
|
{
|
|
p.SetState(5085)
|
|
p.UserLockOption()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5090)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5095)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCOMMENT:
|
|
{
|
|
p.SetState(5091)
|
|
p.Match(MySqlParserCOMMENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5092)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserATTRIBUTE:
|
|
{
|
|
p.SetState(5093)
|
|
p.Match(MySqlParserATTRIBUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5094)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDropUserContext is an interface to support dynamic dispatch.
|
|
type IDropUserContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DROP() antlr.TerminalNode
|
|
USER() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
IfExists() IIfExistsContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsDropUserContext differentiates from other interfaces.
|
|
IsDropUserContext()
|
|
}
|
|
|
|
type DropUserContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDropUserContext() *DropUserContext {
|
|
var p = new(DropUserContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropUser
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDropUserContext(p *DropUserContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dropUser
|
|
}
|
|
|
|
func (*DropUserContext) IsDropUserContext() {}
|
|
|
|
func NewDropUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropUserContext {
|
|
var p = new(DropUserContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dropUser
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DropUserContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DropUserContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *DropUserContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *DropUserContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DropUserContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *DropUserContext) IfExists() IIfExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfExistsContext)
|
|
}
|
|
|
|
func (s *DropUserContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DropUserContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DropUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DropUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DropUserContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDropUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropUserContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDropUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *DropUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDropUser(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DropUser() (localctx IDropUserContext) {
|
|
localctx = NewDropUserContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 430, MySqlParserRULE_dropUser)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5099)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5100)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5102)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIF {
|
|
{
|
|
p.SetState(5101)
|
|
p.IfExists()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5104)
|
|
p.UserName()
|
|
}
|
|
p.SetState(5109)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5105)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5106)
|
|
p.UserName()
|
|
}
|
|
|
|
p.SetState(5111)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IGrantStatementContext is an interface to support dynamic dispatch.
|
|
type IGrantStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetPrivilegeObject returns the privilegeObject token.
|
|
GetPrivilegeObject() antlr.Token
|
|
|
|
// GetTlsNone returns the tlsNone token.
|
|
GetTlsNone() antlr.Token
|
|
|
|
// SetPrivilegeObject sets the privilegeObject token.
|
|
SetPrivilegeObject(antlr.Token)
|
|
|
|
// SetTlsNone sets the tlsNone token.
|
|
SetTlsNone(antlr.Token)
|
|
|
|
// Getter signatures
|
|
AllGRANT() []antlr.TerminalNode
|
|
GRANT(i int) antlr.TerminalNode
|
|
AllPrivelegeClause() []IPrivelegeClauseContext
|
|
PrivelegeClause(i int) IPrivelegeClauseContext
|
|
ON() antlr.TerminalNode
|
|
PrivilegeLevel() IPrivilegeLevelContext
|
|
TO() antlr.TerminalNode
|
|
AllUserAuthOption() []IUserAuthOptionContext
|
|
UserAuthOption(i int) IUserAuthOptionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
REQUIRE() antlr.TerminalNode
|
|
AllWITH() []antlr.TerminalNode
|
|
WITH(i int) antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
ROLE() antlr.TerminalNode
|
|
RoleOption() IRoleOptionContext
|
|
TABLE() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
PROCEDURE() antlr.TerminalNode
|
|
AllTlsOption() []ITlsOptionContext
|
|
TlsOption(i int) ITlsOptionContext
|
|
NONE() antlr.TerminalNode
|
|
AllOPTION() []antlr.TerminalNode
|
|
OPTION(i int) antlr.TerminalNode
|
|
AllUserResourceOption() []IUserResourceOptionContext
|
|
UserResourceOption(i int) IUserResourceOptionContext
|
|
AllAND() []antlr.TerminalNode
|
|
AND(i int) antlr.TerminalNode
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
ADMIN() antlr.TerminalNode
|
|
|
|
// IsGrantStatementContext differentiates from other interfaces.
|
|
IsGrantStatementContext()
|
|
}
|
|
|
|
type GrantStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
privilegeObject antlr.Token
|
|
tlsNone antlr.Token
|
|
}
|
|
|
|
func NewEmptyGrantStatementContext() *GrantStatementContext {
|
|
var p = new(GrantStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_grantStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyGrantStatementContext(p *GrantStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_grantStatement
|
|
}
|
|
|
|
func (*GrantStatementContext) IsGrantStatementContext() {}
|
|
|
|
func NewGrantStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantStatementContext {
|
|
var p = new(GrantStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_grantStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GrantStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *GrantStatementContext) GetPrivilegeObject() antlr.Token { return s.privilegeObject }
|
|
|
|
func (s *GrantStatementContext) GetTlsNone() antlr.Token { return s.tlsNone }
|
|
|
|
func (s *GrantStatementContext) SetPrivilegeObject(v antlr.Token) { s.privilegeObject = v }
|
|
|
|
func (s *GrantStatementContext) SetTlsNone(v antlr.Token) { s.tlsNone = v }
|
|
|
|
func (s *GrantStatementContext) AllGRANT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserGRANT)
|
|
}
|
|
|
|
func (s *GrantStatementContext) GRANT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANT, i)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllPrivelegeClause() []IPrivelegeClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPrivelegeClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
tst[i] = t.(IPrivelegeClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) PrivelegeClause(i int) IPrivelegeClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivelegeClauseContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) PrivilegeLevel() IPrivilegeLevelContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivilegeLevelContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivilegeLevelContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllUserAuthOption() []IUserAuthOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserAuthOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserAuthOptionContext); ok {
|
|
tst[i] = t.(IUserAuthOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) UserAuthOption(i int) IUserAuthOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserAuthOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserAuthOptionContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *GrantStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *GrantStatementContext) REQUIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREQUIRE, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllWITH() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserWITH)
|
|
}
|
|
|
|
func (s *GrantStatementContext) WITH(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, i)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) RoleOption() IRoleOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRoleOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRoleOptionContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllTlsOption() []ITlsOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITlsOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITlsOptionContext); ok {
|
|
tst[i] = t.(ITlsOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) TlsOption(i int) ITlsOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITlsOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITlsOptionContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllOPTION() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserOPTION)
|
|
}
|
|
|
|
func (s *GrantStatementContext) OPTION(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, i)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllUserResourceOption() []IUserResourceOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserResourceOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserResourceOptionContext); ok {
|
|
tst[i] = t.(IUserResourceOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) UserResourceOption(i int) IUserResourceOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserResourceOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserResourceOptionContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllAND() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserAND)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AND(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, i)
|
|
}
|
|
|
|
func (s *GrantStatementContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantStatementContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *GrantStatementContext) ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADMIN, 0)
|
|
}
|
|
|
|
func (s *GrantStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GrantStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *GrantStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGrantStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *GrantStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGrantStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *GrantStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGrantStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) GrantStatement() (localctx IGrantStatementContext) {
|
|
localctx = NewGrantStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 432, MySqlParserRULE_grantStatement)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(5205)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 769, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5112)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5113)
|
|
p.PrivelegeClause()
|
|
}
|
|
p.SetState(5118)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5114)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5115)
|
|
p.PrivelegeClause()
|
|
}
|
|
|
|
p.SetState(5120)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(5121)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5123)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 752, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5122)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*GrantStatementContext).privilegeObject = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPROCEDURE || _la == MySqlParserTABLE || _la == MySqlParserFUNCTION) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*GrantStatementContext).privilegeObject = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5125)
|
|
p.PrivilegeLevel()
|
|
}
|
|
{
|
|
p.SetState(5126)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5127)
|
|
p.UserAuthOption()
|
|
}
|
|
p.SetState(5132)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5128)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5129)
|
|
p.UserAuthOption()
|
|
}
|
|
|
|
p.SetState(5134)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5149)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserREQUIRE {
|
|
{
|
|
p.SetState(5135)
|
|
p.Match(MySqlParserREQUIRE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5147)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserNONE:
|
|
{
|
|
p.SetState(5136)
|
|
|
|
var _m = p.Match(MySqlParserNONE)
|
|
|
|
localctx.(*GrantStatementContext).tlsNone = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509:
|
|
{
|
|
p.SetState(5137)
|
|
p.TlsOption()
|
|
}
|
|
p.SetState(5144)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 {
|
|
p.SetState(5139)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAND {
|
|
{
|
|
p.SetState(5138)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5141)
|
|
p.TlsOption()
|
|
}
|
|
|
|
p.SetState(5146)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(5160)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 760, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5151)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5157)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
p.SetState(5155)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserGRANT:
|
|
{
|
|
p.SetState(5152)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5153)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS:
|
|
{
|
|
p.SetState(5154)
|
|
p.UserResourceOption()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(5159)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5168)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(5162)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5163)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5164)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5165)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5166)
|
|
p.RoleOption()
|
|
}
|
|
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5170)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5173)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 762, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5171)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5172)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(5182)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5175)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5178)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 763, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5176)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5177)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5184)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(5185)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5188)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 765, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5186)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5187)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(5197)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5190)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5193)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 766, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5191)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5192)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5199)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5203)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 768, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5200)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5201)
|
|
p.Match(MySqlParserADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5202)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRoleOptionContext is an interface to support dynamic dispatch.
|
|
type IRoleOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DEFAULT() antlr.TerminalNode
|
|
NONE() antlr.TerminalNode
|
|
ALL() antlr.TerminalNode
|
|
EXCEPT() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsRoleOptionContext differentiates from other interfaces.
|
|
IsRoleOptionContext()
|
|
}
|
|
|
|
type RoleOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRoleOptionContext() *RoleOptionContext {
|
|
var p = new(RoleOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_roleOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRoleOptionContext(p *RoleOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_roleOption
|
|
}
|
|
|
|
func (*RoleOptionContext) IsRoleOptionContext() {}
|
|
|
|
func NewRoleOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleOptionContext {
|
|
var p = new(RoleOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_roleOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoleOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RoleOptionContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *RoleOptionContext) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *RoleOptionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *RoleOptionContext) EXCEPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCEPT, 0)
|
|
}
|
|
|
|
func (s *RoleOptionContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RoleOptionContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RoleOptionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RoleOptionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RoleOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoleOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RoleOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoleOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoleOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoleOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RoleOption() (localctx IRoleOptionContext) {
|
|
localctx = NewRoleOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 434, MySqlParserRULE_roleOption)
|
|
var _la int
|
|
|
|
p.SetState(5229)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 773, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5207)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5208)
|
|
p.Match(MySqlParserNONE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5209)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5219)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEXCEPT {
|
|
{
|
|
p.SetState(5210)
|
|
p.Match(MySqlParserEXCEPT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5211)
|
|
p.UserName()
|
|
}
|
|
p.SetState(5216)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5212)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5213)
|
|
p.UserName()
|
|
}
|
|
|
|
p.SetState(5218)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5221)
|
|
p.UserName()
|
|
}
|
|
p.SetState(5226)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5222)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5223)
|
|
p.UserName()
|
|
}
|
|
|
|
p.SetState(5228)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IGrantProxyContext is an interface to support dynamic dispatch.
|
|
type IGrantProxyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFromFirst returns the fromFirst rule contexts.
|
|
GetFromFirst() IUserNameContext
|
|
|
|
// GetToFirst returns the toFirst rule contexts.
|
|
GetToFirst() IUserNameContext
|
|
|
|
// Get_userName returns the _userName rule contexts.
|
|
Get_userName() IUserNameContext
|
|
|
|
// SetFromFirst sets the fromFirst rule contexts.
|
|
SetFromFirst(IUserNameContext)
|
|
|
|
// SetToFirst sets the toFirst rule contexts.
|
|
SetToFirst(IUserNameContext)
|
|
|
|
// Set_userName sets the _userName rule contexts.
|
|
Set_userName(IUserNameContext)
|
|
|
|
// GetToOther returns the toOther rule context list.
|
|
GetToOther() []IUserNameContext
|
|
|
|
// SetToOther sets the toOther rule context list.
|
|
SetToOther([]IUserNameContext)
|
|
|
|
// Getter signatures
|
|
AllGRANT() []antlr.TerminalNode
|
|
GRANT(i int) antlr.TerminalNode
|
|
PROXY() antlr.TerminalNode
|
|
ON() antlr.TerminalNode
|
|
TO() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WITH() antlr.TerminalNode
|
|
OPTION() antlr.TerminalNode
|
|
|
|
// IsGrantProxyContext differentiates from other interfaces.
|
|
IsGrantProxyContext()
|
|
}
|
|
|
|
type GrantProxyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
fromFirst IUserNameContext
|
|
toFirst IUserNameContext
|
|
_userName IUserNameContext
|
|
toOther []IUserNameContext
|
|
}
|
|
|
|
func NewEmptyGrantProxyContext() *GrantProxyContext {
|
|
var p = new(GrantProxyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_grantProxy
|
|
return p
|
|
}
|
|
|
|
func InitEmptyGrantProxyContext(p *GrantProxyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_grantProxy
|
|
}
|
|
|
|
func (*GrantProxyContext) IsGrantProxyContext() {}
|
|
|
|
func NewGrantProxyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantProxyContext {
|
|
var p = new(GrantProxyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_grantProxy
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GrantProxyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *GrantProxyContext) GetFromFirst() IUserNameContext { return s.fromFirst }
|
|
|
|
func (s *GrantProxyContext) GetToFirst() IUserNameContext { return s.toFirst }
|
|
|
|
func (s *GrantProxyContext) Get_userName() IUserNameContext { return s._userName }
|
|
|
|
func (s *GrantProxyContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v }
|
|
|
|
func (s *GrantProxyContext) SetToFirst(v IUserNameContext) { s.toFirst = v }
|
|
|
|
func (s *GrantProxyContext) Set_userName(v IUserNameContext) { s._userName = v }
|
|
|
|
func (s *GrantProxyContext) GetToOther() []IUserNameContext { return s.toOther }
|
|
|
|
func (s *GrantProxyContext) SetToOther(v []IUserNameContext) { s.toOther = v }
|
|
|
|
func (s *GrantProxyContext) AllGRANT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserGRANT)
|
|
}
|
|
|
|
func (s *GrantProxyContext) GRANT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANT, i)
|
|
}
|
|
|
|
func (s *GrantProxyContext) PROXY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROXY, 0)
|
|
}
|
|
|
|
func (s *GrantProxyContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *GrantProxyContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *GrantProxyContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *GrantProxyContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *GrantProxyContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *GrantProxyContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *GrantProxyContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *GrantProxyContext) OPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, 0)
|
|
}
|
|
|
|
func (s *GrantProxyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GrantProxyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *GrantProxyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGrantProxy(s)
|
|
}
|
|
}
|
|
|
|
func (s *GrantProxyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGrantProxy(s)
|
|
}
|
|
}
|
|
|
|
func (s *GrantProxyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGrantProxy(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) GrantProxy() (localctx IGrantProxyContext) {
|
|
localctx = NewGrantProxyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 436, MySqlParserRULE_grantProxy)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5231)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5232)
|
|
p.Match(MySqlParserPROXY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5233)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5234)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*GrantProxyContext).fromFirst = _x
|
|
}
|
|
{
|
|
p.SetState(5235)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5236)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*GrantProxyContext).toFirst = _x
|
|
}
|
|
p.SetState(5241)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5237)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5238)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*GrantProxyContext)._userName = _x
|
|
}
|
|
localctx.(*GrantProxyContext).toOther = append(localctx.(*GrantProxyContext).toOther, localctx.(*GrantProxyContext)._userName)
|
|
|
|
p.SetState(5243)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5247)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 775, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5244)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5245)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5246)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRenameUserContext is an interface to support dynamic dispatch.
|
|
type IRenameUserContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RENAME() antlr.TerminalNode
|
|
USER() antlr.TerminalNode
|
|
AllRenameUserClause() []IRenameUserClauseContext
|
|
RenameUserClause(i int) IRenameUserClauseContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsRenameUserContext differentiates from other interfaces.
|
|
IsRenameUserContext()
|
|
}
|
|
|
|
type RenameUserContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRenameUserContext() *RenameUserContext {
|
|
var p = new(RenameUserContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameUser
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRenameUserContext(p *RenameUserContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameUser
|
|
}
|
|
|
|
func (*RenameUserContext) IsRenameUserContext() {}
|
|
|
|
func NewRenameUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameUserContext {
|
|
var p = new(RenameUserContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_renameUser
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RenameUserContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RenameUserContext) RENAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRENAME, 0)
|
|
}
|
|
|
|
func (s *RenameUserContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *RenameUserContext) AllRenameUserClause() []IRenameUserClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRenameUserClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRenameUserClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRenameUserClauseContext); ok {
|
|
tst[i] = t.(IRenameUserClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RenameUserContext) RenameUserClause(i int) IRenameUserClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRenameUserClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRenameUserClauseContext)
|
|
}
|
|
|
|
func (s *RenameUserContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RenameUserContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RenameUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RenameUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RenameUserContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRenameUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameUserContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRenameUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRenameUser(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RenameUser() (localctx IRenameUserContext) {
|
|
localctx = NewRenameUserContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 438, MySqlParserRULE_renameUser)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5249)
|
|
p.Match(MySqlParserRENAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5250)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5251)
|
|
p.RenameUserClause()
|
|
}
|
|
p.SetState(5256)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5252)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5253)
|
|
p.RenameUserClause()
|
|
}
|
|
|
|
p.SetState(5258)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRevokeStatementContext is an interface to support dynamic dispatch.
|
|
type IRevokeStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsRevokeStatementContext differentiates from other interfaces.
|
|
IsRevokeStatementContext()
|
|
}
|
|
|
|
type RevokeStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRevokeStatementContext() *RevokeStatementContext {
|
|
var p = new(RevokeStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_revokeStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRevokeStatementContext(p *RevokeStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_revokeStatement
|
|
}
|
|
|
|
func (*RevokeStatementContext) IsRevokeStatementContext() {}
|
|
|
|
func NewRevokeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeStatementContext {
|
|
var p = new(RevokeStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_revokeStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RevokeStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RevokeStatementContext) CopyAll(ctx *RevokeStatementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *RevokeStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RevokeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type DetailRevokeContext struct {
|
|
RevokeStatementContext
|
|
privilegeObject antlr.Token
|
|
}
|
|
|
|
func NewDetailRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DetailRevokeContext {
|
|
var p = new(DetailRevokeContext)
|
|
|
|
InitEmptyRevokeStatementContext(&p.RevokeStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RevokeStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DetailRevokeContext) GetPrivilegeObject() antlr.Token { return s.privilegeObject }
|
|
|
|
func (s *DetailRevokeContext) SetPrivilegeObject(v antlr.Token) { s.privilegeObject = v }
|
|
|
|
func (s *DetailRevokeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DetailRevokeContext) REVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVOKE, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) AllPrivelegeClause() []IPrivelegeClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPrivelegeClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
tst[i] = t.(IPrivelegeClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DetailRevokeContext) PrivelegeClause(i int) IPrivelegeClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivelegeClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivelegeClauseContext)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) PrivilegeLevel() IPrivilegeLevelContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivilegeLevelContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivilegeLevelContext)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DetailRevokeContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *DetailRevokeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDetailRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *DetailRevokeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDetailRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *DetailRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDetailRevoke(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RoleRevokeContext struct {
|
|
RevokeStatementContext
|
|
}
|
|
|
|
func NewRoleRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoleRevokeContext {
|
|
var p = new(RoleRevokeContext)
|
|
|
|
InitEmptyRevokeStatementContext(&p.RevokeStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RevokeStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoleRevokeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoleRevokeContext) REVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVOKE, 0)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RoleRevokeContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RoleRevokeContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RoleRevokeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoleRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleRevokeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoleRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoleRevoke(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShortRevokeContext struct {
|
|
RevokeStatementContext
|
|
}
|
|
|
|
func NewShortRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShortRevokeContext {
|
|
var p = new(ShortRevokeContext)
|
|
|
|
InitEmptyRevokeStatementContext(&p.RevokeStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*RevokeStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShortRevokeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShortRevokeContext) REVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVOKE, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) GRANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANT, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) OPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ShortRevokeContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) PRIVILEGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIVILEGES, 0)
|
|
}
|
|
|
|
func (s *ShortRevokeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShortRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShortRevokeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShortRevoke(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShortRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShortRevoke(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RevokeStatement() (localctx IRevokeStatementContext) {
|
|
localctx = NewRevokeStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 440, MySqlParserRULE_revokeStatement)
|
|
var _la int
|
|
|
|
p.SetState(5329)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewDetailRevokeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5259)
|
|
p.Match(MySqlParserREVOKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5260)
|
|
p.PrivelegeClause()
|
|
}
|
|
p.SetState(5265)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5261)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5262)
|
|
p.PrivelegeClause()
|
|
}
|
|
|
|
p.SetState(5267)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(5268)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5270)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5269)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DetailRevokeContext).privilegeObject = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPROCEDURE || _la == MySqlParserTABLE || _la == MySqlParserFUNCTION) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DetailRevokeContext).privilegeObject = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5272)
|
|
p.PrivilegeLevel()
|
|
}
|
|
{
|
|
p.SetState(5273)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5274)
|
|
p.UserName()
|
|
}
|
|
p.SetState(5279)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5275)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5276)
|
|
p.UserName()
|
|
}
|
|
|
|
p.SetState(5281)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewShortRevokeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5282)
|
|
p.Match(MySqlParserREVOKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5283)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5285)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPRIVILEGES {
|
|
{
|
|
p.SetState(5284)
|
|
p.Match(MySqlParserPRIVILEGES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5287)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5288)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5289)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5290)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5291)
|
|
p.UserName()
|
|
}
|
|
p.SetState(5296)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5292)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5293)
|
|
p.UserName()
|
|
}
|
|
|
|
p.SetState(5298)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewRoleRevokeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5299)
|
|
p.Match(MySqlParserREVOKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5302)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 782, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5300)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5301)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(5311)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5304)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5307)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 783, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5305)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5306)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5313)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(5314)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5317)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 785, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5315)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5316)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(5326)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5319)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5322)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 786, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5320)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5321)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5328)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRevokeProxyContext is an interface to support dynamic dispatch.
|
|
type IRevokeProxyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOnUser returns the onUser rule contexts.
|
|
GetOnUser() IUserNameContext
|
|
|
|
// GetFromFirst returns the fromFirst rule contexts.
|
|
GetFromFirst() IUserNameContext
|
|
|
|
// Get_userName returns the _userName rule contexts.
|
|
Get_userName() IUserNameContext
|
|
|
|
// SetOnUser sets the onUser rule contexts.
|
|
SetOnUser(IUserNameContext)
|
|
|
|
// SetFromFirst sets the fromFirst rule contexts.
|
|
SetFromFirst(IUserNameContext)
|
|
|
|
// Set_userName sets the _userName rule contexts.
|
|
Set_userName(IUserNameContext)
|
|
|
|
// GetFromOther returns the fromOther rule context list.
|
|
GetFromOther() []IUserNameContext
|
|
|
|
// SetFromOther sets the fromOther rule context list.
|
|
SetFromOther([]IUserNameContext)
|
|
|
|
// Getter signatures
|
|
REVOKE() antlr.TerminalNode
|
|
PROXY() antlr.TerminalNode
|
|
ON() antlr.TerminalNode
|
|
FROM() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsRevokeProxyContext differentiates from other interfaces.
|
|
IsRevokeProxyContext()
|
|
}
|
|
|
|
type RevokeProxyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
onUser IUserNameContext
|
|
fromFirst IUserNameContext
|
|
_userName IUserNameContext
|
|
fromOther []IUserNameContext
|
|
}
|
|
|
|
func NewEmptyRevokeProxyContext() *RevokeProxyContext {
|
|
var p = new(RevokeProxyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_revokeProxy
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRevokeProxyContext(p *RevokeProxyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_revokeProxy
|
|
}
|
|
|
|
func (*RevokeProxyContext) IsRevokeProxyContext() {}
|
|
|
|
func NewRevokeProxyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeProxyContext {
|
|
var p = new(RevokeProxyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_revokeProxy
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RevokeProxyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RevokeProxyContext) GetOnUser() IUserNameContext { return s.onUser }
|
|
|
|
func (s *RevokeProxyContext) GetFromFirst() IUserNameContext { return s.fromFirst }
|
|
|
|
func (s *RevokeProxyContext) Get_userName() IUserNameContext { return s._userName }
|
|
|
|
func (s *RevokeProxyContext) SetOnUser(v IUserNameContext) { s.onUser = v }
|
|
|
|
func (s *RevokeProxyContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v }
|
|
|
|
func (s *RevokeProxyContext) Set_userName(v IUserNameContext) { s._userName = v }
|
|
|
|
func (s *RevokeProxyContext) GetFromOther() []IUserNameContext { return s.fromOther }
|
|
|
|
func (s *RevokeProxyContext) SetFromOther(v []IUserNameContext) { s.fromOther = v }
|
|
|
|
func (s *RevokeProxyContext) REVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVOKE, 0)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) PROXY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROXY, 0)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RevokeProxyContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RevokeProxyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RevokeProxyContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRevokeProxy(s)
|
|
}
|
|
}
|
|
|
|
func (s *RevokeProxyContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRevokeProxy(s)
|
|
}
|
|
}
|
|
|
|
func (s *RevokeProxyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRevokeProxy(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RevokeProxy() (localctx IRevokeProxyContext) {
|
|
localctx = NewRevokeProxyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 442, MySqlParserRULE_revokeProxy)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5331)
|
|
p.Match(MySqlParserREVOKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5332)
|
|
p.Match(MySqlParserPROXY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5333)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5334)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*RevokeProxyContext).onUser = _x
|
|
}
|
|
{
|
|
p.SetState(5335)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5336)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*RevokeProxyContext).fromFirst = _x
|
|
}
|
|
p.SetState(5341)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5337)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5338)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*RevokeProxyContext)._userName = _x
|
|
}
|
|
localctx.(*RevokeProxyContext).fromOther = append(localctx.(*RevokeProxyContext).fromOther, localctx.(*RevokeProxyContext)._userName)
|
|
|
|
p.SetState(5343)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISetPasswordStatementContext is an interface to support dynamic dispatch.
|
|
type ISetPasswordStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SET() antlr.TerminalNode
|
|
PASSWORD() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
PasswordFunctionClause() IPasswordFunctionClauseContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
UserName() IUserNameContext
|
|
|
|
// IsSetPasswordStatementContext differentiates from other interfaces.
|
|
IsSetPasswordStatementContext()
|
|
}
|
|
|
|
type SetPasswordStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySetPasswordStatementContext() *SetPasswordStatementContext {
|
|
var p = new(SetPasswordStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setPasswordStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySetPasswordStatementContext(p *SetPasswordStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setPasswordStatement
|
|
}
|
|
|
|
func (*SetPasswordStatementContext) IsSetPasswordStatementContext() {}
|
|
|
|
func NewSetPasswordStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetPasswordStatementContext {
|
|
var p = new(SetPasswordStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_setPasswordStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SetPasswordStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) PasswordFunctionClause() IPasswordFunctionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPasswordFunctionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPasswordFunctionClauseContext)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetPasswordStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetPasswordStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetPasswordStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetPasswordStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SetPasswordStatement() (localctx ISetPasswordStatementContext) {
|
|
localctx = NewSetPasswordStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 444, MySqlParserRULE_setPasswordStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5344)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5345)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5348)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(5346)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5347)
|
|
p.UserName()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5350)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5353)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserOLD_PASSWORD, MySqlParserPASSWORD:
|
|
{
|
|
p.SetState(5351)
|
|
p.PasswordFunctionClause()
|
|
}
|
|
|
|
case MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(5352)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserSpecificationContext is an interface to support dynamic dispatch.
|
|
type IUserSpecificationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
UserName() IUserNameContext
|
|
UserPasswordOption() IUserPasswordOptionContext
|
|
|
|
// IsUserSpecificationContext differentiates from other interfaces.
|
|
IsUserSpecificationContext()
|
|
}
|
|
|
|
type UserSpecificationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUserSpecificationContext() *UserSpecificationContext {
|
|
var p = new(UserSpecificationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userSpecification
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserSpecificationContext(p *UserSpecificationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userSpecification
|
|
}
|
|
|
|
func (*UserSpecificationContext) IsUserSpecificationContext() {}
|
|
|
|
func NewUserSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserSpecificationContext {
|
|
var p = new(UserSpecificationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userSpecification
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserSpecificationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserSpecificationContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *UserSpecificationContext) UserPasswordOption() IUserPasswordOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserPasswordOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserPasswordOptionContext)
|
|
}
|
|
|
|
func (s *UserSpecificationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserSpecificationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserSpecification(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserSpecificationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserSpecification(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserSpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserSpecification(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserSpecification() (localctx IUserSpecificationContext) {
|
|
localctx = NewUserSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 446, MySqlParserRULE_userSpecification)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5355)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5356)
|
|
p.UserPasswordOption()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserAuthOptionContext is an interface to support dynamic dispatch.
|
|
type IUserAuthOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsUserAuthOptionContext differentiates from other interfaces.
|
|
IsUserAuthOptionContext()
|
|
}
|
|
|
|
type UserAuthOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUserAuthOptionContext() *UserAuthOptionContext {
|
|
var p = new(UserAuthOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userAuthOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserAuthOptionContext(p *UserAuthOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userAuthOption
|
|
}
|
|
|
|
func (*UserAuthOptionContext) IsUserAuthOptionContext() {}
|
|
|
|
func NewUserAuthOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserAuthOptionContext {
|
|
var p = new(UserAuthOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userAuthOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserAuthOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserAuthOptionContext) CopyAll(ctx *UserAuthOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *UserAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserAuthOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SimpleAuthOptionContext struct {
|
|
UserAuthOptionContext
|
|
}
|
|
|
|
func NewSimpleAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleAuthOptionContext {
|
|
var p = new(SimpleAuthOptionContext)
|
|
|
|
InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UserAuthOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleAuthOptionContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *SimpleAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleAuthOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ModuleAuthOptionContext struct {
|
|
UserAuthOptionContext
|
|
}
|
|
|
|
func NewModuleAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModuleAuthOptionContext {
|
|
var p = new(ModuleAuthOptionContext)
|
|
|
|
InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UserAuthOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) AuthenticationRule() IAuthenticationRuleContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthenticationRuleContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthenticationRuleContext)
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterModuleAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitModuleAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ModuleAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitModuleAuthOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RandomAuthOptionContext struct {
|
|
UserAuthOptionContext
|
|
}
|
|
|
|
func NewRandomAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RandomAuthOptionContext {
|
|
var p = new(RandomAuthOptionContext)
|
|
|
|
InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UserAuthOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) RANDOM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANDOM, 0)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) AuthOptionClause() IAuthOptionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthOptionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthOptionClauseContext)
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRandomAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRandomAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *RandomAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRandomAuthOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type StringAuthOptionContext struct {
|
|
UserAuthOptionContext
|
|
}
|
|
|
|
func NewStringAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringAuthOptionContext {
|
|
var p = new(StringAuthOptionContext)
|
|
|
|
InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UserAuthOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) AuthOptionClause() IAuthOptionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthOptionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthOptionClauseContext)
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStringAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStringAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStringAuthOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type HashAuthOptionContext struct {
|
|
UserAuthOptionContext
|
|
hashed antlr.Token
|
|
}
|
|
|
|
func NewHashAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HashAuthOptionContext {
|
|
var p = new(HashAuthOptionContext)
|
|
|
|
InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*UserAuthOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) GetHashed() antlr.Token { return s.hashed }
|
|
|
|
func (s *HashAuthOptionContext) SetHashed(v antlr.Token) { s.hashed = v }
|
|
|
|
func (s *HashAuthOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHashAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHashAuthOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *HashAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHashAuthOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserAuthOption() (localctx IUserAuthOptionContext) {
|
|
localctx = NewUserAuthOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 448, MySqlParserRULE_userAuthOption)
|
|
p.SetState(5383)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewHashAuthOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5358)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5359)
|
|
p.Match(MySqlParserIDENTIFIED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5360)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5361)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5362)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*HashAuthOptionContext).hashed = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewRandomAuthOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5364)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5365)
|
|
p.Match(MySqlParserIDENTIFIED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5366)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5367)
|
|
p.Match(MySqlParserRANDOM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5368)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5369)
|
|
p.AuthOptionClause()
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewStringAuthOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5371)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5372)
|
|
p.Match(MySqlParserIDENTIFIED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5373)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5374)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5375)
|
|
p.AuthOptionClause()
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewModuleAuthOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5377)
|
|
p.UserName()
|
|
}
|
|
{
|
|
p.SetState(5378)
|
|
p.Match(MySqlParserIDENTIFIED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5379)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5380)
|
|
p.AuthenticationRule()
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewSimpleAuthOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5382)
|
|
p.UserName()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAuthOptionClauseContext is an interface to support dynamic dispatch.
|
|
type IAuthOptionClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
REPLACE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
RETAIN() antlr.TerminalNode
|
|
CURRENT() antlr.TerminalNode
|
|
PASSWORD() antlr.TerminalNode
|
|
|
|
// IsAuthOptionClauseContext differentiates from other interfaces.
|
|
IsAuthOptionClauseContext()
|
|
}
|
|
|
|
type AuthOptionClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAuthOptionClauseContext() *AuthOptionClauseContext {
|
|
var p = new(AuthOptionClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authOptionClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAuthOptionClauseContext(p *AuthOptionClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authOptionClause
|
|
}
|
|
|
|
func (*AuthOptionClauseContext) IsAuthOptionClauseContext() {}
|
|
|
|
func NewAuthOptionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthOptionClauseContext {
|
|
var p = new(AuthOptionClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_authOptionClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AuthOptionClauseContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) RETAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETAIN, 0)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) CURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT, 0)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAuthOptionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAuthOptionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *AuthOptionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAuthOptionClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AuthOptionClause() (localctx IAuthOptionClauseContext) {
|
|
localctx = NewAuthOptionClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 450, MySqlParserRULE_authOptionClause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(5387)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5385)
|
|
p.Match(MySqlParserREPLACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5386)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5392)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserRETAIN {
|
|
{
|
|
p.SetState(5389)
|
|
p.Match(MySqlParserRETAIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5390)
|
|
p.Match(MySqlParserCURRENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5391)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAuthenticationRuleContext is an interface to support dynamic dispatch.
|
|
type IAuthenticationRuleContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsAuthenticationRuleContext differentiates from other interfaces.
|
|
IsAuthenticationRuleContext()
|
|
}
|
|
|
|
type AuthenticationRuleContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAuthenticationRuleContext() *AuthenticationRuleContext {
|
|
var p = new(AuthenticationRuleContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authenticationRule
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAuthenticationRuleContext(p *AuthenticationRuleContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authenticationRule
|
|
}
|
|
|
|
func (*AuthenticationRuleContext) IsAuthenticationRuleContext() {}
|
|
|
|
func NewAuthenticationRuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthenticationRuleContext {
|
|
var p = new(AuthenticationRuleContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_authenticationRule
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AuthenticationRuleContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AuthenticationRuleContext) CopyAll(ctx *AuthenticationRuleContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *AuthenticationRuleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AuthenticationRuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PasswordModuleOptionContext struct {
|
|
AuthenticationRuleContext
|
|
}
|
|
|
|
func NewPasswordModuleOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordModuleOptionContext {
|
|
var p = new(PasswordModuleOptionContext)
|
|
|
|
InitEmptyAuthenticationRuleContext(&p.AuthenticationRuleContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AuthenticationRuleContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) AuthPlugin() IAuthPluginContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthPluginContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthPluginContext)
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) PasswordFunctionClause() IPasswordFunctionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPasswordFunctionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPasswordFunctionClauseContext)
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPasswordModuleOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPasswordModuleOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordModuleOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPasswordModuleOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ModuleContext struct {
|
|
AuthenticationRuleContext
|
|
}
|
|
|
|
func NewModuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModuleContext {
|
|
var p = new(ModuleContext)
|
|
|
|
InitEmptyAuthenticationRuleContext(&p.AuthenticationRuleContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*AuthenticationRuleContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ModuleContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ModuleContext) AuthPlugin() IAuthPluginContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthPluginContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthPluginContext)
|
|
}
|
|
|
|
func (s *ModuleContext) AuthOptionClause() IAuthOptionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAuthOptionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAuthOptionClauseContext)
|
|
}
|
|
|
|
func (s *ModuleContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) RANDOM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANDOM, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *ModuleContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterModule(s)
|
|
}
|
|
}
|
|
|
|
func (s *ModuleContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitModule(s)
|
|
}
|
|
}
|
|
|
|
func (s *ModuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitModule(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AuthenticationRule() (localctx IAuthenticationRuleContext) {
|
|
localctx = NewAuthenticationRuleContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 452, MySqlParserRULE_authenticationRule)
|
|
var _la int
|
|
|
|
p.SetState(5408)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewModuleContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5394)
|
|
p.AuthPlugin()
|
|
}
|
|
p.SetState(5402)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5395)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserAS || _la == MySqlParserBY || _la == MySqlParserUSING) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(5399)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(5396)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserRANDOM:
|
|
{
|
|
p.SetState(5397)
|
|
p.Match(MySqlParserRANDOM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5398)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5401)
|
|
p.AuthOptionClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewPasswordModuleOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5404)
|
|
p.AuthPlugin()
|
|
}
|
|
{
|
|
p.SetState(5405)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5406)
|
|
p.PasswordFunctionClause()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITlsOptionContext is an interface to support dynamic dispatch.
|
|
type ITlsOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SSL() antlr.TerminalNode
|
|
X509() antlr.TerminalNode
|
|
CIPHER() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
ISSUER() antlr.TerminalNode
|
|
SUBJECT() antlr.TerminalNode
|
|
|
|
// IsTlsOptionContext differentiates from other interfaces.
|
|
IsTlsOptionContext()
|
|
}
|
|
|
|
type TlsOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTlsOptionContext() *TlsOptionContext {
|
|
var p = new(TlsOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tlsOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTlsOptionContext(p *TlsOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tlsOption
|
|
}
|
|
|
|
func (*TlsOptionContext) IsTlsOptionContext() {}
|
|
|
|
func NewTlsOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TlsOptionContext {
|
|
var p = new(TlsOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tlsOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TlsOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TlsOptionContext) SSL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSSL, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) X509() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserX509, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) CIPHER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCIPHER, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) ISSUER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISSUER, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) SUBJECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBJECT, 0)
|
|
}
|
|
|
|
func (s *TlsOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TlsOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TlsOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTlsOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TlsOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTlsOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TlsOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTlsOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TlsOption() (localctx ITlsOptionContext) {
|
|
localctx = NewTlsOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 454, MySqlParserRULE_tlsOption)
|
|
p.SetState(5418)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSSL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5410)
|
|
p.Match(MySqlParserSSL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserX509:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5411)
|
|
p.Match(MySqlParserX509)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCIPHER:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5412)
|
|
p.Match(MySqlParserCIPHER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5413)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserISSUER:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5414)
|
|
p.Match(MySqlParserISSUER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5415)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSUBJECT:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5416)
|
|
p.Match(MySqlParserSUBJECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5417)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserResourceOptionContext is an interface to support dynamic dispatch.
|
|
type IUserResourceOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MAX_QUERIES_PER_HOUR() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
MAX_UPDATES_PER_HOUR() antlr.TerminalNode
|
|
MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode
|
|
MAX_USER_CONNECTIONS() antlr.TerminalNode
|
|
|
|
// IsUserResourceOptionContext differentiates from other interfaces.
|
|
IsUserResourceOptionContext()
|
|
}
|
|
|
|
type UserResourceOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUserResourceOptionContext() *UserResourceOptionContext {
|
|
var p = new(UserResourceOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userResourceOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserResourceOptionContext(p *UserResourceOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userResourceOption
|
|
}
|
|
|
|
func (*UserResourceOptionContext) IsUserResourceOptionContext() {}
|
|
|
|
func NewUserResourceOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserResourceOptionContext {
|
|
var p = new(UserResourceOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userResourceOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserResourceOptionContext) MAX_QUERIES_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_QUERIES_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) MAX_UPDATES_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_UPDATES_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_CONNECTIONS_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) MAX_USER_CONNECTIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_USER_CONNECTIONS, 0)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserResourceOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserResourceOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserResourceOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserResourceOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserResourceOption() (localctx IUserResourceOptionContext) {
|
|
localctx = NewUserResourceOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 456, MySqlParserRULE_userResourceOption)
|
|
p.SetState(5428)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserMAX_QUERIES_PER_HOUR:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5420)
|
|
p.Match(MySqlParserMAX_QUERIES_PER_HOUR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5421)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserMAX_UPDATES_PER_HOUR:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5422)
|
|
p.Match(MySqlParserMAX_UPDATES_PER_HOUR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5423)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserMAX_CONNECTIONS_PER_HOUR:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5424)
|
|
p.Match(MySqlParserMAX_CONNECTIONS_PER_HOUR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5425)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserMAX_USER_CONNECTIONS:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5426)
|
|
p.Match(MySqlParserMAX_USER_CONNECTIONS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5427)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserPasswordOptionContext is an interface to support dynamic dispatch.
|
|
type IUserPasswordOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetExpireType returns the expireType token.
|
|
GetExpireType() antlr.Token
|
|
|
|
// SetExpireType sets the expireType token.
|
|
SetExpireType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
PASSWORD() antlr.TerminalNode
|
|
EXPIRE() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
DAY() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
NEVER() antlr.TerminalNode
|
|
INTERVAL() antlr.TerminalNode
|
|
HISTORY() antlr.TerminalNode
|
|
REUSE() antlr.TerminalNode
|
|
REQUIRE() antlr.TerminalNode
|
|
CURRENT() antlr.TerminalNode
|
|
OPTIONAL() antlr.TerminalNode
|
|
FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode
|
|
PASSWORD_LOCK_TIME() antlr.TerminalNode
|
|
UNBOUNDED() antlr.TerminalNode
|
|
|
|
// IsUserPasswordOptionContext differentiates from other interfaces.
|
|
IsUserPasswordOptionContext()
|
|
}
|
|
|
|
type UserPasswordOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
expireType antlr.Token
|
|
}
|
|
|
|
func NewEmptyUserPasswordOptionContext() *UserPasswordOptionContext {
|
|
var p = new(UserPasswordOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userPasswordOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserPasswordOptionContext(p *UserPasswordOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userPasswordOption
|
|
}
|
|
|
|
func (*UserPasswordOptionContext) IsUserPasswordOptionContext() {}
|
|
|
|
func NewUserPasswordOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserPasswordOptionContext {
|
|
var p = new(UserPasswordOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userPasswordOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserPasswordOptionContext) GetExpireType() antlr.Token { return s.expireType }
|
|
|
|
func (s *UserPasswordOptionContext) SetExpireType(v antlr.Token) { s.expireType = v }
|
|
|
|
func (s *UserPasswordOptionContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) EXPIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPIRE, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) DAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) NEVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEVER, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) INTERVAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERVAL, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) HISTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHISTORY, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) REUSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREUSE, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) REQUIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREQUIRE, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) CURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) OPTIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONAL, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAILED_LOGIN_ATTEMPTS, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) PASSWORD_LOCK_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD_LOCK_TIME, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) UNBOUNDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNBOUNDED, 0)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserPasswordOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserPasswordOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserPasswordOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserPasswordOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserPasswordOption() (localctx IUserPasswordOptionContext) {
|
|
localctx = NewUserPasswordOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 458, MySqlParserRULE_userPasswordOption)
|
|
var _la int
|
|
|
|
p.SetState(5468)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5430)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5431)
|
|
p.Match(MySqlParserEXPIRE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5438)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(5432)
|
|
|
|
var _m = p.Match(MySqlParserDEFAULT)
|
|
|
|
localctx.(*UserPasswordOptionContext).expireType = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserNEVER:
|
|
{
|
|
p.SetState(5433)
|
|
|
|
var _m = p.Match(MySqlParserNEVER)
|
|
|
|
localctx.(*UserPasswordOptionContext).expireType = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserINTERVAL:
|
|
{
|
|
p.SetState(5434)
|
|
|
|
var _m = p.Match(MySqlParserINTERVAL)
|
|
|
|
localctx.(*UserPasswordOptionContext).expireType = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5435)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(5436)
|
|
p.Match(MySqlParserDAY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserATTRIBUTE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserACCOUNT, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5440)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5441)
|
|
p.Match(MySqlParserHISTORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5444)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(5442)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(5443)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5446)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5447)
|
|
p.Match(MySqlParserREUSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5448)
|
|
p.Match(MySqlParserINTERVAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5453)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(5449)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(5450)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(5451)
|
|
p.Match(MySqlParserDAY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5455)
|
|
p.Match(MySqlParserPASSWORD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5456)
|
|
p.Match(MySqlParserREQUIRE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5457)
|
|
p.Match(MySqlParserCURRENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5459)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT || _la == MySqlParserOPTIONAL {
|
|
{
|
|
p.SetState(5458)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDEFAULT || _la == MySqlParserOPTIONAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5461)
|
|
p.Match(MySqlParserFAILED_LOGIN_ATTEMPTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5462)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5463)
|
|
p.Match(MySqlParserPASSWORD_LOCK_TIME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5466)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(5464)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserUNBOUNDED:
|
|
{
|
|
p.SetState(5465)
|
|
p.Match(MySqlParserUNBOUNDED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserLockOptionContext is an interface to support dynamic dispatch.
|
|
type IUserLockOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetLockType returns the lockType token.
|
|
GetLockType() antlr.Token
|
|
|
|
// SetLockType sets the lockType token.
|
|
SetLockType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ACCOUNT() antlr.TerminalNode
|
|
LOCK() antlr.TerminalNode
|
|
UNLOCK() antlr.TerminalNode
|
|
|
|
// IsUserLockOptionContext differentiates from other interfaces.
|
|
IsUserLockOptionContext()
|
|
}
|
|
|
|
type UserLockOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
lockType antlr.Token
|
|
}
|
|
|
|
func NewEmptyUserLockOptionContext() *UserLockOptionContext {
|
|
var p = new(UserLockOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userLockOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserLockOptionContext(p *UserLockOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userLockOption
|
|
}
|
|
|
|
func (*UserLockOptionContext) IsUserLockOptionContext() {}
|
|
|
|
func NewUserLockOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserLockOptionContext {
|
|
var p = new(UserLockOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userLockOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserLockOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserLockOptionContext) GetLockType() antlr.Token { return s.lockType }
|
|
|
|
func (s *UserLockOptionContext) SetLockType(v antlr.Token) { s.lockType = v }
|
|
|
|
func (s *UserLockOptionContext) ACCOUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserACCOUNT, 0)
|
|
}
|
|
|
|
func (s *UserLockOptionContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *UserLockOptionContext) UNLOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNLOCK, 0)
|
|
}
|
|
|
|
func (s *UserLockOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserLockOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserLockOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserLockOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserLockOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserLockOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserLockOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserLockOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserLockOption() (localctx IUserLockOptionContext) {
|
|
localctx = NewUserLockOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 460, MySqlParserRULE_userLockOption)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5470)
|
|
p.Match(MySqlParserACCOUNT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5471)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UserLockOptionContext).lockType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLOCK || _la == MySqlParserUNLOCK) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UserLockOptionContext).lockType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPrivelegeClauseContext is an interface to support dynamic dispatch.
|
|
type IPrivelegeClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Privilege() IPrivilegeContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsPrivelegeClauseContext differentiates from other interfaces.
|
|
IsPrivelegeClauseContext()
|
|
}
|
|
|
|
type PrivelegeClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPrivelegeClauseContext() *PrivelegeClauseContext {
|
|
var p = new(PrivelegeClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privelegeClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPrivelegeClauseContext(p *PrivelegeClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privelegeClause
|
|
}
|
|
|
|
func (*PrivelegeClauseContext) IsPrivelegeClauseContext() {}
|
|
|
|
func NewPrivelegeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivelegeClauseContext {
|
|
var p = new(PrivelegeClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_privelegeClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PrivelegeClauseContext) Privilege() IPrivilegeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivilegeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivilegeContext)
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrivelegeClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrivelegeClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivelegeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrivelegeClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PrivelegeClause() (localctx IPrivelegeClauseContext) {
|
|
localctx = NewPrivelegeClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 462, MySqlParserRULE_privelegeClause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5473)
|
|
p.Privilege()
|
|
}
|
|
p.SetState(5478)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(5474)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5475)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(5476)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPrivilegeContext is an interface to support dynamic dispatch.
|
|
type IPrivilegeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALL() antlr.TerminalNode
|
|
PRIVILEGES() antlr.TerminalNode
|
|
ALTER() antlr.TerminalNode
|
|
ROUTINE() antlr.TerminalNode
|
|
CREATE() antlr.TerminalNode
|
|
TEMPORARY() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
VIEW() antlr.TerminalNode
|
|
USER() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
ROLE() antlr.TerminalNode
|
|
DELETE() antlr.TerminalNode
|
|
DROP() antlr.TerminalNode
|
|
EVENT() antlr.TerminalNode
|
|
EXECUTE() antlr.TerminalNode
|
|
FILE() antlr.TerminalNode
|
|
GRANT() antlr.TerminalNode
|
|
OPTION() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
INSERT() antlr.TerminalNode
|
|
LOCK() antlr.TerminalNode
|
|
PROCESS() antlr.TerminalNode
|
|
PROXY() antlr.TerminalNode
|
|
REFERENCES() antlr.TerminalNode
|
|
RELOAD() antlr.TerminalNode
|
|
REPLICATION() antlr.TerminalNode
|
|
CLIENT() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
SELECT() antlr.TerminalNode
|
|
SHOW() antlr.TerminalNode
|
|
DATABASES() antlr.TerminalNode
|
|
SHUTDOWN() antlr.TerminalNode
|
|
SUPER() antlr.TerminalNode
|
|
TRIGGER() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
USAGE() antlr.TerminalNode
|
|
APPLICATION_PASSWORD_ADMIN() antlr.TerminalNode
|
|
AUDIT_ABORT_EXEMPT() antlr.TerminalNode
|
|
AUDIT_ADMIN() antlr.TerminalNode
|
|
AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode
|
|
BACKUP_ADMIN() antlr.TerminalNode
|
|
BINLOG_ADMIN() antlr.TerminalNode
|
|
BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode
|
|
CLONE_ADMIN() antlr.TerminalNode
|
|
CONNECTION_ADMIN() antlr.TerminalNode
|
|
ENCRYPTION_KEY_ADMIN() antlr.TerminalNode
|
|
FIREWALL_ADMIN() antlr.TerminalNode
|
|
FIREWALL_EXEMPT() antlr.TerminalNode
|
|
FIREWALL_USER() antlr.TerminalNode
|
|
FLUSH_OPTIMIZER_COSTS() antlr.TerminalNode
|
|
FLUSH_STATUS() antlr.TerminalNode
|
|
FLUSH_TABLES() antlr.TerminalNode
|
|
FLUSH_USER_RESOURCES() antlr.TerminalNode
|
|
GROUP_REPLICATION_ADMIN() antlr.TerminalNode
|
|
INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode
|
|
INNODB_REDO_LOG_ENABLE() antlr.TerminalNode
|
|
NDB_STORED_USER() antlr.TerminalNode
|
|
PASSWORDLESS_USER_ADMIN() antlr.TerminalNode
|
|
PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode
|
|
REPLICATION_APPLIER() antlr.TerminalNode
|
|
REPLICATION_SLAVE_ADMIN() antlr.TerminalNode
|
|
RESOURCE_GROUP_ADMIN() antlr.TerminalNode
|
|
RESOURCE_GROUP_USER() antlr.TerminalNode
|
|
ROLE_ADMIN() antlr.TerminalNode
|
|
SERVICE_CONNECTION_ADMIN() antlr.TerminalNode
|
|
SESSION_VARIABLES_ADMIN() antlr.TerminalNode
|
|
SET_USER_ID() antlr.TerminalNode
|
|
SKIP_QUERY_REWRITE() antlr.TerminalNode
|
|
SHOW_ROUTINE() antlr.TerminalNode
|
|
SYSTEM_USER() antlr.TerminalNode
|
|
SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode
|
|
TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode
|
|
TP_CONNECTION_ADMIN() antlr.TerminalNode
|
|
VERSION_TOKEN_ADMIN() antlr.TerminalNode
|
|
XA_RECOVER_ADMIN() antlr.TerminalNode
|
|
LOAD() antlr.TerminalNode
|
|
FROM() antlr.TerminalNode
|
|
S3() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
INVOKE() antlr.TerminalNode
|
|
LAMBDA() antlr.TerminalNode
|
|
|
|
// IsPrivilegeContext differentiates from other interfaces.
|
|
IsPrivilegeContext()
|
|
}
|
|
|
|
type PrivilegeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPrivilegeContext() *PrivilegeContext {
|
|
var p = new(PrivilegeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilege
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPrivilegeContext(p *PrivilegeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilege
|
|
}
|
|
|
|
func (*PrivilegeContext) IsPrivilegeContext() {}
|
|
|
|
func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext {
|
|
var p = new(PrivilegeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_privilege
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PrivilegeContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) PRIVILEGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIVILEGES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) ALTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALTER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) ROUTINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROUTINE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) DELETE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELETE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) EXECUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXECUTE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) GRANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) OPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTION, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) PROCESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCESS, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) PROXY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROXY, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) REFERENCES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREFERENCES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) RELOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELOAD, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) CLIENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLIENT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SELECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSELECT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) DATABASES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SHUTDOWN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHUTDOWN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SUPER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUPER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TRIGGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) USAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSAGE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) APPLICATION_PASSWORD_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAPPLICATION_PASSWORD_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) AUDIT_ABORT_EXEMPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUDIT_ABORT_EXEMPT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) AUDIT_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUDIT_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTHENTICATION_POLICY_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) BACKUP_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBACKUP_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) BINLOG_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG_ENCRYPTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) CLONE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLONE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) CONNECTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) ENCRYPTION_KEY_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION_KEY_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FIREWALL_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FIREWALL_EXEMPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_EXEMPT, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FIREWALL_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_USER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FLUSH_OPTIMIZER_COSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH_OPTIMIZER_COSTS, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FLUSH_STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH_STATUS, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FLUSH_TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH_TABLES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FLUSH_USER_RESOURCES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH_USER_RESOURCES, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) GROUP_REPLICATION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_REPLICATION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNODB_REDO_LOG_ARCHIVE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INNODB_REDO_LOG_ENABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNODB_REDO_LOG_ENABLE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) NDB_STORED_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNDB_STORED_USER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) PASSWORDLESS_USER_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORDLESS_USER_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERSIST_RO_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) REPLICATION_APPLIER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION_APPLIER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) REPLICATION_SLAVE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION_SLAVE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) RESOURCE_GROUP_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESOURCE_GROUP_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) RESOURCE_GROUP_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESOURCE_GROUP_USER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) ROLE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SERVICE_CONNECTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERVICE_CONNECTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SET_USER_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET_USER_ID, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SKIP_QUERY_REWRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSKIP_QUERY_REWRITE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SHOW_ROUTINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW_ROUTINE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SYSTEM_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSYSTEM_USER, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSYSTEM_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_ENCRYPTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) TP_CONNECTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTP_CONNECTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) VERSION_TOKEN_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVERSION_TOKEN_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) XA_RECOVER_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA_RECOVER_ADMIN, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) LOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOAD, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) S3() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserS3, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) INVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKE, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) LAMBDA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAMBDA, 0)
|
|
}
|
|
|
|
func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrivilege(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrivilege(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrivilege(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Privilege() (localctx IPrivilegeContext) {
|
|
localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 464, MySqlParserRULE_privilege)
|
|
var _la int
|
|
|
|
p.SetState(5573)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 811, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5480)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5482)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPRIVILEGES {
|
|
{
|
|
p.SetState(5481)
|
|
p.Match(MySqlParserPRIVILEGES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5484)
|
|
p.Match(MySqlParserALTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5486)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserROUTINE {
|
|
{
|
|
p.SetState(5485)
|
|
p.Match(MySqlParserROUTINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5488)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5496)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserTEMPORARY:
|
|
{
|
|
p.SetState(5489)
|
|
p.Match(MySqlParserTEMPORARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5490)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserROUTINE:
|
|
{
|
|
p.SetState(5491)
|
|
p.Match(MySqlParserROUTINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserVIEW:
|
|
{
|
|
p.SetState(5492)
|
|
p.Match(MySqlParserVIEW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUSER:
|
|
{
|
|
p.SetState(5493)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTABLESPACE:
|
|
{
|
|
p.SetState(5494)
|
|
p.Match(MySqlParserTABLESPACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserROLE:
|
|
{
|
|
p.SetState(5495)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserON, MySqlParserLR_BRACKET, MySqlParserCOMMA:
|
|
|
|
default:
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5498)
|
|
p.Match(MySqlParserDELETE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5499)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5501)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserROLE {
|
|
{
|
|
p.SetState(5500)
|
|
p.Match(MySqlParserROLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5503)
|
|
p.Match(MySqlParserEVENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(5504)
|
|
p.Match(MySqlParserEXECUTE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(5505)
|
|
p.Match(MySqlParserFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(5506)
|
|
p.Match(MySqlParserGRANT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5507)
|
|
p.Match(MySqlParserOPTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(5508)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 11:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(5509)
|
|
p.Match(MySqlParserINSERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(5510)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5511)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 13:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(5512)
|
|
p.Match(MySqlParserPROCESS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 14:
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(5513)
|
|
p.Match(MySqlParserPROXY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 15:
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(5514)
|
|
p.Match(MySqlParserREFERENCES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 16:
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(5515)
|
|
p.Match(MySqlParserRELOAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 17:
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(5516)
|
|
p.Match(MySqlParserREPLICATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5517)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCLIENT || _la == MySqlParserSLAVE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 18:
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(5518)
|
|
p.Match(MySqlParserSELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 19:
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(5519)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5520)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASES || _la == MySqlParserVIEW) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 20:
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(5521)
|
|
p.Match(MySqlParserSHUTDOWN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 21:
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(5522)
|
|
p.Match(MySqlParserSUPER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 22:
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(5523)
|
|
p.Match(MySqlParserTRIGGER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 23:
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(5524)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 24:
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(5525)
|
|
p.Match(MySqlParserUSAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 25:
|
|
p.EnterOuterAlt(localctx, 25)
|
|
{
|
|
p.SetState(5526)
|
|
p.Match(MySqlParserAPPLICATION_PASSWORD_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 26:
|
|
p.EnterOuterAlt(localctx, 26)
|
|
{
|
|
p.SetState(5527)
|
|
p.Match(MySqlParserAUDIT_ABORT_EXEMPT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 27:
|
|
p.EnterOuterAlt(localctx, 27)
|
|
{
|
|
p.SetState(5528)
|
|
p.Match(MySqlParserAUDIT_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 28:
|
|
p.EnterOuterAlt(localctx, 28)
|
|
{
|
|
p.SetState(5529)
|
|
p.Match(MySqlParserAUTHENTICATION_POLICY_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 29:
|
|
p.EnterOuterAlt(localctx, 29)
|
|
{
|
|
p.SetState(5530)
|
|
p.Match(MySqlParserBACKUP_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 30:
|
|
p.EnterOuterAlt(localctx, 30)
|
|
{
|
|
p.SetState(5531)
|
|
p.Match(MySqlParserBINLOG_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 31:
|
|
p.EnterOuterAlt(localctx, 31)
|
|
{
|
|
p.SetState(5532)
|
|
p.Match(MySqlParserBINLOG_ENCRYPTION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 32:
|
|
p.EnterOuterAlt(localctx, 32)
|
|
{
|
|
p.SetState(5533)
|
|
p.Match(MySqlParserCLONE_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 33:
|
|
p.EnterOuterAlt(localctx, 33)
|
|
{
|
|
p.SetState(5534)
|
|
p.Match(MySqlParserCONNECTION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 34:
|
|
p.EnterOuterAlt(localctx, 34)
|
|
{
|
|
p.SetState(5535)
|
|
p.Match(MySqlParserENCRYPTION_KEY_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 35:
|
|
p.EnterOuterAlt(localctx, 35)
|
|
{
|
|
p.SetState(5536)
|
|
p.Match(MySqlParserFIREWALL_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 36:
|
|
p.EnterOuterAlt(localctx, 36)
|
|
{
|
|
p.SetState(5537)
|
|
p.Match(MySqlParserFIREWALL_EXEMPT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 37:
|
|
p.EnterOuterAlt(localctx, 37)
|
|
{
|
|
p.SetState(5538)
|
|
p.Match(MySqlParserFIREWALL_USER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 38:
|
|
p.EnterOuterAlt(localctx, 38)
|
|
{
|
|
p.SetState(5539)
|
|
p.Match(MySqlParserFLUSH_OPTIMIZER_COSTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 39:
|
|
p.EnterOuterAlt(localctx, 39)
|
|
{
|
|
p.SetState(5540)
|
|
p.Match(MySqlParserFLUSH_STATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 40:
|
|
p.EnterOuterAlt(localctx, 40)
|
|
{
|
|
p.SetState(5541)
|
|
p.Match(MySqlParserFLUSH_TABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 41:
|
|
p.EnterOuterAlt(localctx, 41)
|
|
{
|
|
p.SetState(5542)
|
|
p.Match(MySqlParserFLUSH_USER_RESOURCES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 42:
|
|
p.EnterOuterAlt(localctx, 42)
|
|
{
|
|
p.SetState(5543)
|
|
p.Match(MySqlParserGROUP_REPLICATION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 43:
|
|
p.EnterOuterAlt(localctx, 43)
|
|
{
|
|
p.SetState(5544)
|
|
p.Match(MySqlParserINNODB_REDO_LOG_ARCHIVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 44:
|
|
p.EnterOuterAlt(localctx, 44)
|
|
{
|
|
p.SetState(5545)
|
|
p.Match(MySqlParserINNODB_REDO_LOG_ENABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 45:
|
|
p.EnterOuterAlt(localctx, 45)
|
|
{
|
|
p.SetState(5546)
|
|
p.Match(MySqlParserNDB_STORED_USER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 46:
|
|
p.EnterOuterAlt(localctx, 46)
|
|
{
|
|
p.SetState(5547)
|
|
p.Match(MySqlParserPASSWORDLESS_USER_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 47:
|
|
p.EnterOuterAlt(localctx, 47)
|
|
{
|
|
p.SetState(5548)
|
|
p.Match(MySqlParserPERSIST_RO_VARIABLES_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 48:
|
|
p.EnterOuterAlt(localctx, 48)
|
|
{
|
|
p.SetState(5549)
|
|
p.Match(MySqlParserREPLICATION_APPLIER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 49:
|
|
p.EnterOuterAlt(localctx, 49)
|
|
{
|
|
p.SetState(5550)
|
|
p.Match(MySqlParserREPLICATION_SLAVE_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 50:
|
|
p.EnterOuterAlt(localctx, 50)
|
|
{
|
|
p.SetState(5551)
|
|
p.Match(MySqlParserRESOURCE_GROUP_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 51:
|
|
p.EnterOuterAlt(localctx, 51)
|
|
{
|
|
p.SetState(5552)
|
|
p.Match(MySqlParserRESOURCE_GROUP_USER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 52:
|
|
p.EnterOuterAlt(localctx, 52)
|
|
{
|
|
p.SetState(5553)
|
|
p.Match(MySqlParserROLE_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 53:
|
|
p.EnterOuterAlt(localctx, 53)
|
|
{
|
|
p.SetState(5554)
|
|
p.Match(MySqlParserSERVICE_CONNECTION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 54:
|
|
p.EnterOuterAlt(localctx, 54)
|
|
{
|
|
p.SetState(5555)
|
|
p.Match(MySqlParserSESSION_VARIABLES_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 55:
|
|
p.EnterOuterAlt(localctx, 55)
|
|
{
|
|
p.SetState(5556)
|
|
p.Match(MySqlParserSET_USER_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 56:
|
|
p.EnterOuterAlt(localctx, 56)
|
|
{
|
|
p.SetState(5557)
|
|
p.Match(MySqlParserSKIP_QUERY_REWRITE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 57:
|
|
p.EnterOuterAlt(localctx, 57)
|
|
{
|
|
p.SetState(5558)
|
|
p.Match(MySqlParserSHOW_ROUTINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 58:
|
|
p.EnterOuterAlt(localctx, 58)
|
|
{
|
|
p.SetState(5559)
|
|
p.Match(MySqlParserSYSTEM_USER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 59:
|
|
p.EnterOuterAlt(localctx, 59)
|
|
{
|
|
p.SetState(5560)
|
|
p.Match(MySqlParserSYSTEM_VARIABLES_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 60:
|
|
p.EnterOuterAlt(localctx, 60)
|
|
{
|
|
p.SetState(5561)
|
|
p.Match(MySqlParserTABLE_ENCRYPTION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 61:
|
|
p.EnterOuterAlt(localctx, 61)
|
|
{
|
|
p.SetState(5562)
|
|
p.Match(MySqlParserTP_CONNECTION_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 62:
|
|
p.EnterOuterAlt(localctx, 62)
|
|
{
|
|
p.SetState(5563)
|
|
p.Match(MySqlParserVERSION_TOKEN_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 63:
|
|
p.EnterOuterAlt(localctx, 63)
|
|
{
|
|
p.SetState(5564)
|
|
p.Match(MySqlParserXA_RECOVER_ADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 64:
|
|
p.EnterOuterAlt(localctx, 64)
|
|
{
|
|
p.SetState(5565)
|
|
p.Match(MySqlParserLOAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5566)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5567)
|
|
p.Match(MySqlParserS3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 65:
|
|
p.EnterOuterAlt(localctx, 65)
|
|
{
|
|
p.SetState(5568)
|
|
p.Match(MySqlParserSELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5569)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5570)
|
|
p.Match(MySqlParserS3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 66:
|
|
p.EnterOuterAlt(localctx, 66)
|
|
{
|
|
p.SetState(5571)
|
|
p.Match(MySqlParserINVOKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5572)
|
|
p.Match(MySqlParserLAMBDA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPrivilegeLevelContext is an interface to support dynamic dispatch.
|
|
type IPrivilegeLevelContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsPrivilegeLevelContext differentiates from other interfaces.
|
|
IsPrivilegeLevelContext()
|
|
}
|
|
|
|
type PrivilegeLevelContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPrivilegeLevelContext() *PrivilegeLevelContext {
|
|
var p = new(PrivilegeLevelContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilegeLevel
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPrivilegeLevelContext(p *PrivilegeLevelContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilegeLevel
|
|
}
|
|
|
|
func (*PrivilegeLevelContext) IsPrivilegeLevelContext() {}
|
|
|
|
func NewPrivilegeLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeLevelContext {
|
|
var p = new(PrivilegeLevelContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_privilegeLevel
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrivilegeLevelContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PrivilegeLevelContext) CopyAll(ctx *PrivilegeLevelContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *PrivilegeLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrivilegeLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type DefiniteSchemaPrivLevelContext struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewDefiniteSchemaPrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteSchemaPrivLevelContext {
|
|
var p = new(DefiniteSchemaPrivLevelContext)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefiniteSchemaPrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefiniteSchemaPrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteSchemaPrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefiniteSchemaPrivLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DefiniteFullTablePrivLevel2Context struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewDefiniteFullTablePrivLevel2Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteFullTablePrivLevel2Context {
|
|
var p = new(DefiniteFullTablePrivLevel2Context)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) DottedId() IDottedIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDottedIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDottedIdContext)
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefiniteFullTablePrivLevel2(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefiniteFullTablePrivLevel2(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevel2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefiniteFullTablePrivLevel2(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DefiniteFullTablePrivLevelContext struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewDefiniteFullTablePrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteFullTablePrivLevelContext {
|
|
var p = new(DefiniteFullTablePrivLevelContext)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefiniteFullTablePrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefiniteFullTablePrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteFullTablePrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefiniteFullTablePrivLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type GlobalPrivLevelContext struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewGlobalPrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GlobalPrivLevelContext {
|
|
var p = new(GlobalPrivLevelContext)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) AllSTAR() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTAR)
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) STAR(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, i)
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGlobalPrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGlobalPrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *GlobalPrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGlobalPrivLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DefiniteTablePrivLevelContext struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewDefiniteTablePrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteTablePrivLevelContext {
|
|
var p = new(DefiniteTablePrivLevelContext)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefiniteTablePrivLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefiniteTablePrivLevelContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DefiniteTablePrivLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefiniteTablePrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteTablePrivLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefiniteTablePrivLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefiniteTablePrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefiniteTablePrivLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CurrentSchemaPriviLevelContext struct {
|
|
PrivilegeLevelContext
|
|
}
|
|
|
|
func NewCurrentSchemaPriviLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentSchemaPriviLevelContext {
|
|
var p = new(CurrentSchemaPriviLevelContext)
|
|
|
|
InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PrivilegeLevelContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CurrentSchemaPriviLevelContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CurrentSchemaPriviLevelContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *CurrentSchemaPriviLevelContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCurrentSchemaPriviLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentSchemaPriviLevelContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCurrentSchemaPriviLevel(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentSchemaPriviLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCurrentSchemaPriviLevel(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PrivilegeLevel() (localctx IPrivilegeLevelContext) {
|
|
localctx = NewPrivilegeLevelContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 466, MySqlParserRULE_privilegeLevel)
|
|
p.SetState(5591)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewCurrentSchemaPriviLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5575)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewGlobalPrivLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5576)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5577)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5578)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewDefiniteSchemaPrivLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5579)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(5580)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5581)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewDefiniteFullTablePrivLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5583)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(5584)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5585)
|
|
p.Uid()
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewDefiniteFullTablePrivLevel2Context(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5587)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(5588)
|
|
p.DottedId()
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewDefiniteTablePrivLevelContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5590)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRenameUserClauseContext is an interface to support dynamic dispatch.
|
|
type IRenameUserClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFromFirst returns the fromFirst rule contexts.
|
|
GetFromFirst() IUserNameContext
|
|
|
|
// GetToFirst returns the toFirst rule contexts.
|
|
GetToFirst() IUserNameContext
|
|
|
|
// SetFromFirst sets the fromFirst rule contexts.
|
|
SetFromFirst(IUserNameContext)
|
|
|
|
// SetToFirst sets the toFirst rule contexts.
|
|
SetToFirst(IUserNameContext)
|
|
|
|
// Getter signatures
|
|
TO() antlr.TerminalNode
|
|
AllUserName() []IUserNameContext
|
|
UserName(i int) IUserNameContext
|
|
|
|
// IsRenameUserClauseContext differentiates from other interfaces.
|
|
IsRenameUserClauseContext()
|
|
}
|
|
|
|
type RenameUserClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
fromFirst IUserNameContext
|
|
toFirst IUserNameContext
|
|
}
|
|
|
|
func NewEmptyRenameUserClauseContext() *RenameUserClauseContext {
|
|
var p = new(RenameUserClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameUserClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRenameUserClauseContext(p *RenameUserClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_renameUserClause
|
|
}
|
|
|
|
func (*RenameUserClauseContext) IsRenameUserClauseContext() {}
|
|
|
|
func NewRenameUserClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameUserClauseContext {
|
|
var p = new(RenameUserClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_renameUserClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RenameUserClauseContext) GetFromFirst() IUserNameContext { return s.fromFirst }
|
|
|
|
func (s *RenameUserClauseContext) GetToFirst() IUserNameContext { return s.toFirst }
|
|
|
|
func (s *RenameUserClauseContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v }
|
|
|
|
func (s *RenameUserClauseContext) SetToFirst(v IUserNameContext) { s.toFirst = v }
|
|
|
|
func (s *RenameUserClauseContext) TO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO, 0)
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) AllUserName() []IUserNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUserNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUserNameContext); ok {
|
|
tst[i] = t.(IUserNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) UserName(i int) IUserNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRenameUserClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRenameUserClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *RenameUserClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRenameUserClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RenameUserClause() (localctx IRenameUserClauseContext) {
|
|
localctx = NewRenameUserClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 468, MySqlParserRULE_renameUserClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5593)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*RenameUserClauseContext).fromFirst = _x
|
|
}
|
|
{
|
|
p.SetState(5594)
|
|
p.Match(MySqlParserTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5595)
|
|
|
|
var _x = p.UserName()
|
|
|
|
localctx.(*RenameUserClauseContext).toFirst = _x
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAnalyzeTableContext is an interface to support dynamic dispatch.
|
|
type IAnalyzeTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetActionOption returns the actionOption token.
|
|
GetActionOption() antlr.Token
|
|
|
|
// SetActionOption sets the actionOption token.
|
|
SetActionOption(antlr.Token)
|
|
|
|
// Getter signatures
|
|
ANALYZE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
TABLE() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
AllHISTOGRAM() []antlr.TerminalNode
|
|
HISTOGRAM(i int) antlr.TerminalNode
|
|
AllON() []antlr.TerminalNode
|
|
ON(i int) antlr.TerminalNode
|
|
AllFullColumnName() []IFullColumnNameContext
|
|
FullColumnName(i int) IFullColumnNameContext
|
|
DROP() antlr.TerminalNode
|
|
NO_WRITE_TO_BINLOG() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
WITH() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
BUCKETS() antlr.TerminalNode
|
|
|
|
// IsAnalyzeTableContext differentiates from other interfaces.
|
|
IsAnalyzeTableContext()
|
|
}
|
|
|
|
type AnalyzeTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
actionOption antlr.Token
|
|
}
|
|
|
|
func NewEmptyAnalyzeTableContext() *AnalyzeTableContext {
|
|
var p = new(AnalyzeTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_analyzeTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAnalyzeTableContext(p *AnalyzeTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_analyzeTable
|
|
}
|
|
|
|
func (*AnalyzeTableContext) IsAnalyzeTableContext() {}
|
|
|
|
func NewAnalyzeTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzeTableContext {
|
|
var p = new(AnalyzeTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_analyzeTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AnalyzeTableContext) GetActionOption() antlr.Token { return s.actionOption }
|
|
|
|
func (s *AnalyzeTableContext) SetActionOption(v antlr.Token) { s.actionOption = v }
|
|
|
|
func (s *AnalyzeTableContext) ANALYZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserANALYZE, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) AllHISTOGRAM() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserHISTOGRAM)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) HISTOGRAM(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHISTOGRAM, i)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) AllFullColumnName() []IFullColumnNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullColumnNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullColumnNameContext); ok {
|
|
tst[i] = t.(IFullColumnNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) FullColumnName(i int) IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) DROP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDROP, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) BUCKETS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBUCKETS, 0)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAnalyzeTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAnalyzeTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *AnalyzeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAnalyzeTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AnalyzeTable() (localctx IAnalyzeTableContext) {
|
|
localctx = NewAnalyzeTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 470, MySqlParserRULE_analyzeTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5597)
|
|
p.Match(MySqlParserANALYZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5599)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(5598)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AnalyzeTableContext).actionOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AnalyzeTableContext).actionOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5601)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5602)
|
|
p.Tables()
|
|
}
|
|
p.SetState(5620)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5603)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5604)
|
|
p.Match(MySqlParserHISTOGRAM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5605)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5606)
|
|
p.FullColumnName()
|
|
}
|
|
p.SetState(5611)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5607)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5608)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
p.SetState(5613)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5618)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 815, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5614)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5615)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(5616)
|
|
p.Match(MySqlParserBUCKETS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(5633)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 818, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5622)
|
|
p.Match(MySqlParserDROP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5623)
|
|
p.Match(MySqlParserHISTOGRAM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5624)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5625)
|
|
p.FullColumnName()
|
|
}
|
|
p.SetState(5630)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5626)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5627)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
p.SetState(5632)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICheckTableContext is an interface to support dynamic dispatch.
|
|
type ICheckTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CHECK() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
AllCheckTableOption() []ICheckTableOptionContext
|
|
CheckTableOption(i int) ICheckTableOptionContext
|
|
|
|
// IsCheckTableContext differentiates from other interfaces.
|
|
IsCheckTableContext()
|
|
}
|
|
|
|
type CheckTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCheckTableContext() *CheckTableContext {
|
|
var p = new(CheckTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checkTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCheckTableContext(p *CheckTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checkTable
|
|
}
|
|
|
|
func (*CheckTableContext) IsCheckTableContext() {}
|
|
|
|
func NewCheckTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckTableContext {
|
|
var p = new(CheckTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_checkTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CheckTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CheckTableContext) CHECK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECK, 0)
|
|
}
|
|
|
|
func (s *CheckTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *CheckTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *CheckTableContext) AllCheckTableOption() []ICheckTableOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICheckTableOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICheckTableOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICheckTableOptionContext); ok {
|
|
tst[i] = t.(ICheckTableOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CheckTableContext) CheckTableOption(i int) ICheckTableOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICheckTableOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICheckTableOptionContext)
|
|
}
|
|
|
|
func (s *CheckTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CheckTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CheckTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCheckTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCheckTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCheckTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CheckTable() (localctx ICheckTableContext) {
|
|
localctx = NewCheckTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 472, MySqlParserRULE_checkTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5635)
|
|
p.Match(MySqlParserCHECK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5636)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5637)
|
|
p.Tables()
|
|
}
|
|
p.SetState(5641)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserFOR || _la == MySqlParserCHANGED || _la == MySqlParserEXTENDED || _la == MySqlParserFAST || _la == MySqlParserMEDIUM || _la == MySqlParserQUICK {
|
|
{
|
|
p.SetState(5638)
|
|
p.CheckTableOption()
|
|
}
|
|
|
|
p.SetState(5643)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IChecksumTableContext is an interface to support dynamic dispatch.
|
|
type IChecksumTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetActionOption returns the actionOption token.
|
|
GetActionOption() antlr.Token
|
|
|
|
// SetActionOption sets the actionOption token.
|
|
SetActionOption(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CHECKSUM() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
QUICK() antlr.TerminalNode
|
|
EXTENDED() antlr.TerminalNode
|
|
|
|
// IsChecksumTableContext differentiates from other interfaces.
|
|
IsChecksumTableContext()
|
|
}
|
|
|
|
type ChecksumTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
actionOption antlr.Token
|
|
}
|
|
|
|
func NewEmptyChecksumTableContext() *ChecksumTableContext {
|
|
var p = new(ChecksumTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checksumTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyChecksumTableContext(p *ChecksumTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checksumTable
|
|
}
|
|
|
|
func (*ChecksumTableContext) IsChecksumTableContext() {}
|
|
|
|
func NewChecksumTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChecksumTableContext {
|
|
var p = new(ChecksumTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_checksumTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ChecksumTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ChecksumTableContext) GetActionOption() antlr.Token { return s.actionOption }
|
|
|
|
func (s *ChecksumTableContext) SetActionOption(v antlr.Token) { s.actionOption = v }
|
|
|
|
func (s *ChecksumTableContext) CHECKSUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECKSUM, 0)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) EXTENDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENDED, 0)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ChecksumTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ChecksumTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterChecksumTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChecksumTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitChecksumTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChecksumTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitChecksumTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ChecksumTable() (localctx IChecksumTableContext) {
|
|
localctx = NewChecksumTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 474, MySqlParserRULE_checksumTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5644)
|
|
p.Match(MySqlParserCHECKSUM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5645)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5646)
|
|
p.Tables()
|
|
}
|
|
p.SetState(5648)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEXTENDED || _la == MySqlParserQUICK {
|
|
{
|
|
p.SetState(5647)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ChecksumTableContext).actionOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserEXTENDED || _la == MySqlParserQUICK) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ChecksumTableContext).actionOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOptimizeTableContext is an interface to support dynamic dispatch.
|
|
type IOptimizeTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetActionOption returns the actionOption token.
|
|
GetActionOption() antlr.Token
|
|
|
|
// SetActionOption sets the actionOption token.
|
|
SetActionOption(antlr.Token)
|
|
|
|
// Getter signatures
|
|
OPTIMIZE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
TABLE() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
NO_WRITE_TO_BINLOG() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
|
|
// IsOptimizeTableContext differentiates from other interfaces.
|
|
IsOptimizeTableContext()
|
|
}
|
|
|
|
type OptimizeTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
actionOption antlr.Token
|
|
}
|
|
|
|
func NewEmptyOptimizeTableContext() *OptimizeTableContext {
|
|
var p = new(OptimizeTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_optimizeTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOptimizeTableContext(p *OptimizeTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_optimizeTable
|
|
}
|
|
|
|
func (*OptimizeTableContext) IsOptimizeTableContext() {}
|
|
|
|
func NewOptimizeTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptimizeTableContext {
|
|
var p = new(OptimizeTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_optimizeTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OptimizeTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OptimizeTableContext) GetActionOption() antlr.Token { return s.actionOption }
|
|
|
|
func (s *OptimizeTableContext) SetActionOption(v antlr.Token) { s.actionOption = v }
|
|
|
|
func (s *OptimizeTableContext) OPTIMIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIMIZE, 0)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OptimizeTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OptimizeTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOptimizeTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *OptimizeTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOptimizeTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *OptimizeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOptimizeTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OptimizeTable() (localctx IOptimizeTableContext) {
|
|
localctx = NewOptimizeTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 476, MySqlParserRULE_optimizeTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5650)
|
|
p.Match(MySqlParserOPTIMIZE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5652)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(5651)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*OptimizeTableContext).actionOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*OptimizeTableContext).actionOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5654)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5655)
|
|
p.Tables()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRepairTableContext is an interface to support dynamic dispatch.
|
|
type IRepairTableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetActionOption returns the actionOption token.
|
|
GetActionOption() antlr.Token
|
|
|
|
// SetActionOption sets the actionOption token.
|
|
SetActionOption(antlr.Token)
|
|
|
|
// Getter signatures
|
|
REPAIR() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
Tables() ITablesContext
|
|
QUICK() antlr.TerminalNode
|
|
EXTENDED() antlr.TerminalNode
|
|
USE_FRM() antlr.TerminalNode
|
|
NO_WRITE_TO_BINLOG() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
|
|
// IsRepairTableContext differentiates from other interfaces.
|
|
IsRepairTableContext()
|
|
}
|
|
|
|
type RepairTableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
actionOption antlr.Token
|
|
}
|
|
|
|
func NewEmptyRepairTableContext() *RepairTableContext {
|
|
var p = new(RepairTableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_repairTable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRepairTableContext(p *RepairTableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_repairTable
|
|
}
|
|
|
|
func (*RepairTableContext) IsRepairTableContext() {}
|
|
|
|
func NewRepairTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepairTableContext {
|
|
var p = new(RepairTableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_repairTable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RepairTableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RepairTableContext) GetActionOption() antlr.Token { return s.actionOption }
|
|
|
|
func (s *RepairTableContext) SetActionOption(v antlr.Token) { s.actionOption = v }
|
|
|
|
func (s *RepairTableContext) REPAIR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPAIR, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *RepairTableContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) EXTENDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENDED, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) USE_FRM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSE_FRM, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *RepairTableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RepairTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RepairTableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRepairTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *RepairTableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRepairTable(s)
|
|
}
|
|
}
|
|
|
|
func (s *RepairTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRepairTable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RepairTable() (localctx IRepairTableContext) {
|
|
localctx = NewRepairTableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 478, MySqlParserRULE_repairTable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5657)
|
|
p.Match(MySqlParserREPAIR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5659)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(5658)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*RepairTableContext).actionOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*RepairTableContext).actionOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5661)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5662)
|
|
p.Tables()
|
|
}
|
|
p.SetState(5664)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserQUICK {
|
|
{
|
|
p.SetState(5663)
|
|
p.Match(MySqlParserQUICK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(5667)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEXTENDED {
|
|
{
|
|
p.SetState(5666)
|
|
p.Match(MySqlParserEXTENDED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(5670)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSE_FRM {
|
|
{
|
|
p.SetState(5669)
|
|
p.Match(MySqlParserUSE_FRM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICheckTableOptionContext is an interface to support dynamic dispatch.
|
|
type ICheckTableOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FOR() antlr.TerminalNode
|
|
UPGRADE() antlr.TerminalNode
|
|
QUICK() antlr.TerminalNode
|
|
FAST() antlr.TerminalNode
|
|
MEDIUM() antlr.TerminalNode
|
|
EXTENDED() antlr.TerminalNode
|
|
CHANGED() antlr.TerminalNode
|
|
|
|
// IsCheckTableOptionContext differentiates from other interfaces.
|
|
IsCheckTableOptionContext()
|
|
}
|
|
|
|
type CheckTableOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCheckTableOptionContext() *CheckTableOptionContext {
|
|
var p = new(CheckTableOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checkTableOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCheckTableOptionContext(p *CheckTableOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_checkTableOption
|
|
}
|
|
|
|
func (*CheckTableOptionContext) IsCheckTableOptionContext() {}
|
|
|
|
func NewCheckTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckTableOptionContext {
|
|
var p = new(CheckTableOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_checkTableOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CheckTableOptionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) UPGRADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPGRADE, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) FAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAST, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) MEDIUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEDIUM, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) EXTENDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENDED, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) CHANGED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANGED, 0)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCheckTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCheckTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *CheckTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCheckTableOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CheckTableOption() (localctx ICheckTableOptionContext) {
|
|
localctx = NewCheckTableOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 480, MySqlParserRULE_checkTableOption)
|
|
p.SetState(5679)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFOR:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5672)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5673)
|
|
p.Match(MySqlParserUPGRADE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserQUICK:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5674)
|
|
p.Match(MySqlParserQUICK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFAST:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5675)
|
|
p.Match(MySqlParserFAST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMEDIUM:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5676)
|
|
p.Match(MySqlParserMEDIUM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEXTENDED:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5677)
|
|
p.Match(MySqlParserEXTENDED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCHANGED:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5678)
|
|
p.Match(MySqlParserCHANGED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICreateUdfunctionContext is an interface to support dynamic dispatch.
|
|
type ICreateUdfunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetReturnType returns the returnType token.
|
|
GetReturnType() antlr.Token
|
|
|
|
// SetReturnType sets the returnType token.
|
|
SetReturnType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CREATE() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
RETURNS() antlr.TerminalNode
|
|
SONAME() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
STRING() antlr.TerminalNode
|
|
INTEGER() antlr.TerminalNode
|
|
REAL() antlr.TerminalNode
|
|
DECIMAL() antlr.TerminalNode
|
|
AGGREGATE() antlr.TerminalNode
|
|
IfNotExists() IIfNotExistsContext
|
|
|
|
// IsCreateUdfunctionContext differentiates from other interfaces.
|
|
IsCreateUdfunctionContext()
|
|
}
|
|
|
|
type CreateUdfunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
returnType antlr.Token
|
|
}
|
|
|
|
func NewEmptyCreateUdfunctionContext() *CreateUdfunctionContext {
|
|
var p = new(CreateUdfunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createUdfunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCreateUdfunctionContext(p *CreateUdfunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_createUdfunction
|
|
}
|
|
|
|
func (*CreateUdfunctionContext) IsCreateUdfunctionContext() {}
|
|
|
|
func NewCreateUdfunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateUdfunctionContext {
|
|
var p = new(CreateUdfunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_createUdfunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CreateUdfunctionContext) GetReturnType() antlr.Token { return s.returnType }
|
|
|
|
func (s *CreateUdfunctionContext) SetReturnType(v antlr.Token) { s.returnType = v }
|
|
|
|
func (s *CreateUdfunctionContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) RETURNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNS, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) SONAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSONAME, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) INTEGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTEGER, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) REAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAL, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECIMAL, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) AGGREGATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAGGREGATE, 0)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCreateUdfunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCreateUdfunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *CreateUdfunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCreateUdfunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CreateUdfunction() (localctx ICreateUdfunctionContext) {
|
|
localctx = NewCreateUdfunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 482, MySqlParserRULE_createUdfunction)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5681)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5683)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAGGREGATE {
|
|
{
|
|
p.SetState(5682)
|
|
p.Match(MySqlParserAGGREGATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5685)
|
|
p.Match(MySqlParserFUNCTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5687)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 828, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5686)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5689)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(5690)
|
|
p.Match(MySqlParserRETURNS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5691)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CreateUdfunctionContext).returnType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-206)) & ^0x3f) == 0 && ((int64(1)<<(_la-206))&261) != 0) || _la == MySqlParserSTRING) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CreateUdfunctionContext).returnType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5692)
|
|
p.Match(MySqlParserSONAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5693)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IInstallPluginContext is an interface to support dynamic dispatch.
|
|
type IInstallPluginContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
INSTALL() antlr.TerminalNode
|
|
PLUGIN() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
SONAME() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsInstallPluginContext differentiates from other interfaces.
|
|
IsInstallPluginContext()
|
|
}
|
|
|
|
type InstallPluginContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyInstallPluginContext() *InstallPluginContext {
|
|
var p = new(InstallPluginContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_installPlugin
|
|
return p
|
|
}
|
|
|
|
func InitEmptyInstallPluginContext(p *InstallPluginContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_installPlugin
|
|
}
|
|
|
|
func (*InstallPluginContext) IsInstallPluginContext() {}
|
|
|
|
func NewInstallPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InstallPluginContext {
|
|
var p = new(InstallPluginContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_installPlugin
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InstallPluginContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *InstallPluginContext) INSTALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTALL, 0)
|
|
}
|
|
|
|
func (s *InstallPluginContext) PLUGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGIN, 0)
|
|
}
|
|
|
|
func (s *InstallPluginContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *InstallPluginContext) SONAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSONAME, 0)
|
|
}
|
|
|
|
func (s *InstallPluginContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *InstallPluginContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InstallPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *InstallPluginContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInstallPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *InstallPluginContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInstallPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *InstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInstallPlugin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) InstallPlugin() (localctx IInstallPluginContext) {
|
|
localctx = NewInstallPluginContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 484, MySqlParserRULE_installPlugin)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5695)
|
|
p.Match(MySqlParserINSTALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5696)
|
|
p.Match(MySqlParserPLUGIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5697)
|
|
p.Uid()
|
|
}
|
|
{
|
|
p.SetState(5698)
|
|
p.Match(MySqlParserSONAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5699)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUninstallPluginContext is an interface to support dynamic dispatch.
|
|
type IUninstallPluginContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
UNINSTALL() antlr.TerminalNode
|
|
PLUGIN() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsUninstallPluginContext differentiates from other interfaces.
|
|
IsUninstallPluginContext()
|
|
}
|
|
|
|
type UninstallPluginContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUninstallPluginContext() *UninstallPluginContext {
|
|
var p = new(UninstallPluginContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uninstallPlugin
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUninstallPluginContext(p *UninstallPluginContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uninstallPlugin
|
|
}
|
|
|
|
func (*UninstallPluginContext) IsUninstallPluginContext() {}
|
|
|
|
func NewUninstallPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UninstallPluginContext {
|
|
var p = new(UninstallPluginContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_uninstallPlugin
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UninstallPluginContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UninstallPluginContext) UNINSTALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNINSTALL, 0)
|
|
}
|
|
|
|
func (s *UninstallPluginContext) PLUGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGIN, 0)
|
|
}
|
|
|
|
func (s *UninstallPluginContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *UninstallPluginContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UninstallPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UninstallPluginContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUninstallPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *UninstallPluginContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUninstallPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *UninstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUninstallPlugin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UninstallPlugin() (localctx IUninstallPluginContext) {
|
|
localctx = NewUninstallPluginContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 486, MySqlParserRULE_uninstallPlugin)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5701)
|
|
p.Match(MySqlParserUNINSTALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5702)
|
|
p.Match(MySqlParserPLUGIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5703)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISetStatementContext is an interface to support dynamic dispatch.
|
|
type ISetStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSetStatementContext differentiates from other interfaces.
|
|
IsSetStatementContext()
|
|
}
|
|
|
|
type SetStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySetStatementContext() *SetStatementContext {
|
|
var p = new(SetStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySetStatementContext(p *SetStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_setStatement
|
|
}
|
|
|
|
func (*SetStatementContext) IsSetStatementContext() {}
|
|
|
|
func NewSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetStatementContext {
|
|
var p = new(SetStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_setStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SetStatementContext) CopyAll(ctx *SetStatementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SetStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SetTransactionContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetTransactionContext {
|
|
var p = new(SetTransactionContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetTransactionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetTransactionContext) SetTransactionStatement() ISetTransactionStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISetTransactionStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISetTransactionStatementContext)
|
|
}
|
|
|
|
func (s *SetTransactionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetTransactionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetTransaction(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetTransaction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetCharsetContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetCharsetContext {
|
|
var p = new(SetCharsetContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetCharsetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetCharsetContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetCharsetContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *SetCharsetContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *SetCharsetContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *SetCharsetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetCharsetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetCharset(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetCharset(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetNamesContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetNamesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNamesContext {
|
|
var p = new(SetNamesContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetNamesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetNamesContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetNamesContext) NAMES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNAMES, 0)
|
|
}
|
|
|
|
func (s *SetNamesContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *SetNamesContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *SetNamesContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *SetNamesContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *SetNamesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetNames(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetNamesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetNames(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetNames(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetPasswordContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetPasswordContext {
|
|
var p = new(SetPasswordContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetPasswordContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetPasswordContext) SetPasswordStatement() ISetPasswordStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISetPasswordStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISetPasswordStatementContext)
|
|
}
|
|
|
|
func (s *SetPasswordContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetPassword(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetPasswordContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetPassword(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetPassword(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetAutocommitContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetAutocommitContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetAutocommitContext {
|
|
var p = new(SetAutocommitContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetAutocommitContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetAutocommitContext) SetAutocommitStatement() ISetAutocommitStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISetAutocommitStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISetAutocommitStatementContext)
|
|
}
|
|
|
|
func (s *SetAutocommitContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetAutocommit(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetAutocommitContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetAutocommit(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetAutocommitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetAutocommit(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetNewValueInsideTriggerContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetNewValueInsideTriggerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNewValueInsideTriggerContext {
|
|
var p = new(SetNewValueInsideTriggerContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) AllFullId() []IFullIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullIdContext); ok {
|
|
tst[i] = t.(IFullIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) FullId(i int) IFullIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) AllVAR_ASSIGN() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserVAR_ASSIGN)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) VAR_ASSIGN(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_ASSIGN, i)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetNewValueInsideTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetNewValueInsideTrigger(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetNewValueInsideTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetNewValueInsideTrigger(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SetVariableContext struct {
|
|
SetStatementContext
|
|
}
|
|
|
|
func NewSetVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetVariableContext {
|
|
var p = new(SetVariableContext)
|
|
|
|
InitEmptySetStatementContext(&p.SetStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SetStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SetVariableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SetVariableContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllVariableClause() []IVariableClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IVariableClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IVariableClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IVariableClauseContext); ok {
|
|
tst[i] = t.(IVariableClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetVariableContext) VariableClause(i int) IVariableClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IVariableClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IVariableClauseContext)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *SetVariableContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllVAR_ASSIGN() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserVAR_ASSIGN)
|
|
}
|
|
|
|
func (s *SetVariableContext) VAR_ASSIGN(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_ASSIGN, i)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SetVariableContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllON() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserON)
|
|
}
|
|
|
|
func (s *SetVariableContext) ON(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, i)
|
|
}
|
|
|
|
func (s *SetVariableContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SetVariableContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SetVariableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSetVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetVariableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSetVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *SetVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSetVariable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SetStatement() (localctx ISetStatementContext) {
|
|
localctx = NewSetStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 488, MySqlParserRULE_setStatement)
|
|
var _la int
|
|
|
|
p.SetState(5757)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSetVariableContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5705)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5706)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(5707)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(5710)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5708)
|
|
p.expression(0)
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5709)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(5721)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5712)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5713)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(5714)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(5717)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 830, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(5715)
|
|
p.expression(0)
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(5716)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(5723)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewSetCharsetContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5724)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5725)
|
|
p.CharSet()
|
|
}
|
|
p.SetState(5728)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(5726)
|
|
p.CharsetName()
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(5727)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewSetNamesContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5730)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5731)
|
|
p.Match(MySqlParserNAMES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5738)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL:
|
|
{
|
|
p.SetState(5732)
|
|
p.CharsetName()
|
|
}
|
|
p.SetState(5735)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOLLATE {
|
|
{
|
|
p.SetState(5733)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5734)
|
|
p.CollationName()
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserDEFAULT:
|
|
{
|
|
p.SetState(5737)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewSetPasswordContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5740)
|
|
p.SetPasswordStatement()
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewSetTransactionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5741)
|
|
p.SetTransactionStatement()
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewSetAutocommitContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5742)
|
|
p.SetAutocommitStatement()
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewSetNewValueInsideTriggerContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(5743)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5744)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(5745)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5746)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(5754)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5747)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5748)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(5749)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5750)
|
|
p.expression(0)
|
|
}
|
|
|
|
p.SetState(5756)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowStatementContext is an interface to support dynamic dispatch.
|
|
type IShowStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsShowStatementContext differentiates from other interfaces.
|
|
IsShowStatementContext()
|
|
}
|
|
|
|
type ShowStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowStatementContext() *ShowStatementContext {
|
|
var p = new(ShowStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowStatementContext(p *ShowStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showStatement
|
|
}
|
|
|
|
func (*ShowStatementContext) IsShowStatementContext() {}
|
|
|
|
func NewShowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowStatementContext {
|
|
var p = new(ShowStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowStatementContext) CopyAll(ctx *ShowStatementContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ShowStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type ShowOpenTablesContext struct {
|
|
ShowStatementContext
|
|
schemaFormat antlr.Token
|
|
}
|
|
|
|
func NewShowOpenTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowOpenTablesContext {
|
|
var p = new(ShowOpenTablesContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) GetSchemaFormat() antlr.Token { return s.schemaFormat }
|
|
|
|
func (s *ShowOpenTablesContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v }
|
|
|
|
func (s *ShowOpenTablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) OPEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPEN, 0)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) ShowFilter() IShowFilterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowFilterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowFilterContext)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowOpenTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowOpenTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowOpenTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowOpenTables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowGlobalInfoContext struct {
|
|
ShowStatementContext
|
|
}
|
|
|
|
func NewShowGlobalInfoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGlobalInfoContext {
|
|
var p = new(ShowGlobalInfoContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) ShowGlobalInfoClause() IShowGlobalInfoClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowGlobalInfoClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowGlobalInfoClauseContext)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowGlobalInfo(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowGlobalInfo(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGlobalInfoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowGlobalInfo(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowCreateFullIdObjectContext struct {
|
|
ShowStatementContext
|
|
namedEntity antlr.Token
|
|
}
|
|
|
|
func NewShowCreateFullIdObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateFullIdObjectContext {
|
|
var p = new(ShowCreateFullIdObjectContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) GetNamedEntity() antlr.Token { return s.namedEntity }
|
|
|
|
func (s *ShowCreateFullIdObjectContext) SetNamedEntity(v antlr.Token) { s.namedEntity = v }
|
|
|
|
func (s *ShowCreateFullIdObjectContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) TRIGGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGER, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowCreateFullIdObject(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowCreateFullIdObject(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateFullIdObjectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowCreateFullIdObject(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowCreateUserContext struct {
|
|
ShowStatementContext
|
|
}
|
|
|
|
func NewShowCreateUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateUserContext {
|
|
var p = new(ShowCreateUserContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowCreateUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowCreateUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowCreateUser(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowErrorsContext struct {
|
|
ShowStatementContext
|
|
errorFormat antlr.Token
|
|
offset IDecimalLiteralContext
|
|
rowCount IDecimalLiteralContext
|
|
}
|
|
|
|
func NewShowErrorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowErrorsContext {
|
|
var p = new(ShowErrorsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowErrorsContext) GetErrorFormat() antlr.Token { return s.errorFormat }
|
|
|
|
func (s *ShowErrorsContext) SetErrorFormat(v antlr.Token) { s.errorFormat = v }
|
|
|
|
func (s *ShowErrorsContext) GetOffset() IDecimalLiteralContext { return s.offset }
|
|
|
|
func (s *ShowErrorsContext) GetRowCount() IDecimalLiteralContext { return s.rowCount }
|
|
|
|
func (s *ShowErrorsContext) SetOffset(v IDecimalLiteralContext) { s.offset = v }
|
|
|
|
func (s *ShowErrorsContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v }
|
|
|
|
func (s *ShowErrorsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowErrorsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) ERRORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERRORS, 0)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) WARNINGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWARNINGS, 0)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ShowErrorsContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *ShowErrorsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowErrors(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowErrorsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowErrors(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowErrorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowErrors(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowCountErrorsContext struct {
|
|
ShowStatementContext
|
|
errorFormat antlr.Token
|
|
}
|
|
|
|
func NewShowCountErrorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCountErrorsContext {
|
|
var p = new(ShowCountErrorsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) GetErrorFormat() antlr.Token { return s.errorFormat }
|
|
|
|
func (s *ShowCountErrorsContext) SetErrorFormat(v antlr.Token) { s.errorFormat = v }
|
|
|
|
func (s *ShowCountErrorsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOUNT, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) ERRORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERRORS, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) WARNINGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWARNINGS, 0)
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowCountErrors(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowCountErrors(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCountErrorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowCountErrors(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowObjectFilterContext struct {
|
|
ShowStatementContext
|
|
}
|
|
|
|
func NewShowObjectFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowObjectFilterContext {
|
|
var p = new(ShowObjectFilterContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) ShowCommonEntity() IShowCommonEntityContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowCommonEntityContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowCommonEntityContext)
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) ShowFilter() IShowFilterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowFilterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowFilterContext)
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowObjectFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowObjectFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowObjectFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowObjectFilter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowCreateDbContext struct {
|
|
ShowStatementContext
|
|
schemaFormat antlr.Token
|
|
}
|
|
|
|
func NewShowCreateDbContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateDbContext {
|
|
var p = new(ShowCreateDbContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) GetSchemaFormat() antlr.Token { return s.schemaFormat }
|
|
|
|
func (s *ShowCreateDbContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v }
|
|
|
|
func (s *ShowCreateDbContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) CREATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) IfNotExists() IIfNotExistsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIfNotExistsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIfNotExistsContext)
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowCreateDb(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowCreateDb(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCreateDbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowCreateDb(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowEngineContext struct {
|
|
ShowStatementContext
|
|
engineOption antlr.Token
|
|
}
|
|
|
|
func NewShowEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowEngineContext {
|
|
var p = new(ShowEngineContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowEngineContext) GetEngineOption() antlr.Token { return s.engineOption }
|
|
|
|
func (s *ShowEngineContext) SetEngineOption(v antlr.Token) { s.engineOption = v }
|
|
|
|
func (s *ShowEngineContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowEngineContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowEngineContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *ShowEngineContext) EngineName() IEngineNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameContext)
|
|
}
|
|
|
|
func (s *ShowEngineContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *ShowEngineContext) MUTEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMUTEX, 0)
|
|
}
|
|
|
|
func (s *ShowEngineContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowEngineContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowEngine(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowEngine(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowSchemaFilterContext struct {
|
|
ShowStatementContext
|
|
schemaFormat antlr.Token
|
|
}
|
|
|
|
func NewShowSchemaFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSchemaFilterContext {
|
|
var p = new(ShowSchemaFilterContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) GetSchemaFormat() antlr.Token { return s.schemaFormat }
|
|
|
|
func (s *ShowSchemaFilterContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v }
|
|
|
|
func (s *ShowSchemaFilterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) ShowSchemaEntity() IShowSchemaEntityContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowSchemaEntityContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowSchemaEntityContext)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) ShowFilter() IShowFilterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowFilterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowFilterContext)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowSchemaFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowSchemaFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSchemaFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowSchemaFilter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowIndexesContext struct {
|
|
ShowStatementContext
|
|
indexFormat antlr.Token
|
|
tableFormat antlr.Token
|
|
schemaFormat antlr.Token
|
|
}
|
|
|
|
func NewShowIndexesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexesContext {
|
|
var p = new(ShowIndexesContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *ShowIndexesContext) GetTableFormat() antlr.Token { return s.tableFormat }
|
|
|
|
func (s *ShowIndexesContext) GetSchemaFormat() antlr.Token { return s.schemaFormat }
|
|
|
|
func (s *ShowIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *ShowIndexesContext) SetTableFormat(v antlr.Token) { s.tableFormat = v }
|
|
|
|
func (s *ShowIndexesContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v }
|
|
|
|
func (s *ShowIndexesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowIndexesContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) INDEXES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEXES, 0)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEYS, 0)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) AllFROM() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserFROM)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) FROM(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, i)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) AllIN() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserIN)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) IN(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, i)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ShowIndexesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowIndexesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowIndexes(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowLogEventsContext struct {
|
|
ShowStatementContext
|
|
logFormat antlr.Token
|
|
filename antlr.Token
|
|
fromPosition IDecimalLiteralContext
|
|
offset IDecimalLiteralContext
|
|
rowCount IDecimalLiteralContext
|
|
}
|
|
|
|
func NewShowLogEventsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLogEventsContext {
|
|
var p = new(ShowLogEventsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) GetLogFormat() antlr.Token { return s.logFormat }
|
|
|
|
func (s *ShowLogEventsContext) GetFilename() antlr.Token { return s.filename }
|
|
|
|
func (s *ShowLogEventsContext) SetLogFormat(v antlr.Token) { s.logFormat = v }
|
|
|
|
func (s *ShowLogEventsContext) SetFilename(v antlr.Token) { s.filename = v }
|
|
|
|
func (s *ShowLogEventsContext) GetFromPosition() IDecimalLiteralContext { return s.fromPosition }
|
|
|
|
func (s *ShowLogEventsContext) GetOffset() IDecimalLiteralContext { return s.offset }
|
|
|
|
func (s *ShowLogEventsContext) GetRowCount() IDecimalLiteralContext { return s.rowCount }
|
|
|
|
func (s *ShowLogEventsContext) SetFromPosition(v IDecimalLiteralContext) { s.fromPosition = v }
|
|
|
|
func (s *ShowLogEventsContext) SetOffset(v IDecimalLiteralContext) { s.offset = v }
|
|
|
|
func (s *ShowLogEventsContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v }
|
|
|
|
func (s *ShowLogEventsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) EVENTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENTS, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) RELAYLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAYLOG, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowLogEvents(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowLogEvents(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowLogEventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowLogEvents(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowMasterLogsContext struct {
|
|
ShowStatementContext
|
|
logFormat antlr.Token
|
|
}
|
|
|
|
func NewShowMasterLogsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowMasterLogsContext {
|
|
var p = new(ShowMasterLogsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) GetLogFormat() antlr.Token { return s.logFormat }
|
|
|
|
func (s *ShowMasterLogsContext) SetLogFormat(v antlr.Token) { s.logFormat = v }
|
|
|
|
func (s *ShowMasterLogsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) LOGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGS, 0)
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowMasterLogs(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowMasterLogs(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowMasterLogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowMasterLogs(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowGrantsContext struct {
|
|
ShowStatementContext
|
|
}
|
|
|
|
func NewShowGrantsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGrantsContext {
|
|
var p = new(ShowGrantsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowGrantsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowGrantsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowGrantsContext) GRANTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANTS, 0)
|
|
}
|
|
|
|
func (s *ShowGrantsContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *ShowGrantsContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *ShowGrantsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowGrants(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGrantsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowGrants(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGrantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowGrants(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowSlaveStatusContext struct {
|
|
ShowStatementContext
|
|
}
|
|
|
|
func NewShowSlaveStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSlaveStatusContext {
|
|
var p = new(ShowSlaveStatusContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) CHANNEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANNEL, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowSlaveStatus(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowSlaveStatus(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSlaveStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowSlaveStatus(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowRoutineContext struct {
|
|
ShowStatementContext
|
|
routine antlr.Token
|
|
}
|
|
|
|
func NewShowRoutineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRoutineContext {
|
|
var p = new(ShowRoutineContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowRoutineContext) GetRoutine() antlr.Token { return s.routine }
|
|
|
|
func (s *ShowRoutineContext) SetRoutine(v antlr.Token) { s.routine = v }
|
|
|
|
func (s *ShowRoutineContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowRoutineContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowRoutineContext) CODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCODE, 0)
|
|
}
|
|
|
|
func (s *ShowRoutineContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *ShowRoutineContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *ShowRoutineContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *ShowRoutineContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowRoutine(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowRoutineContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowRoutine(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowRoutineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowRoutine(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowProfileContext struct {
|
|
ShowStatementContext
|
|
queryCount IDecimalLiteralContext
|
|
offset IDecimalLiteralContext
|
|
rowCount IDecimalLiteralContext
|
|
}
|
|
|
|
func NewShowProfileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowProfileContext {
|
|
var p = new(ShowProfileContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowProfileContext) GetQueryCount() IDecimalLiteralContext { return s.queryCount }
|
|
|
|
func (s *ShowProfileContext) GetOffset() IDecimalLiteralContext { return s.offset }
|
|
|
|
func (s *ShowProfileContext) GetRowCount() IDecimalLiteralContext { return s.rowCount }
|
|
|
|
func (s *ShowProfileContext) SetQueryCount(v IDecimalLiteralContext) { s.queryCount = v }
|
|
|
|
func (s *ShowProfileContext) SetOffset(v IDecimalLiteralContext) { s.offset = v }
|
|
|
|
func (s *ShowProfileContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v }
|
|
|
|
func (s *ShowProfileContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowProfileContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowProfileContext) PROFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROFILE, 0)
|
|
}
|
|
|
|
func (s *ShowProfileContext) AllShowProfileType() []IShowProfileTypeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IShowProfileTypeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IShowProfileTypeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IShowProfileTypeContext); ok {
|
|
tst[i] = t.(IShowProfileTypeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ShowProfileContext) ShowProfileType(i int) IShowProfileTypeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowProfileTypeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowProfileTypeContext)
|
|
}
|
|
|
|
func (s *ShowProfileContext) LIMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIMIT, 0)
|
|
}
|
|
|
|
func (s *ShowProfileContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ShowProfileContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ShowProfileContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *ShowProfileContext) QUERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUERY, 0)
|
|
}
|
|
|
|
func (s *ShowProfileContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ShowProfileContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ShowProfileContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowProfile(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowProfileContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowProfile(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowProfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowProfile(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ShowColumnsContext struct {
|
|
ShowStatementContext
|
|
columnsFormat antlr.Token
|
|
tableFormat antlr.Token
|
|
schemaFormat antlr.Token
|
|
}
|
|
|
|
func NewShowColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowColumnsContext {
|
|
var p = new(ShowColumnsContext)
|
|
|
|
InitEmptyShowStatementContext(&p.ShowStatementContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ShowStatementContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowColumnsContext) GetColumnsFormat() antlr.Token { return s.columnsFormat }
|
|
|
|
func (s *ShowColumnsContext) GetTableFormat() antlr.Token { return s.tableFormat }
|
|
|
|
func (s *ShowColumnsContext) GetSchemaFormat() antlr.Token { return s.schemaFormat }
|
|
|
|
func (s *ShowColumnsContext) SetColumnsFormat(v antlr.Token) { s.columnsFormat = v }
|
|
|
|
func (s *ShowColumnsContext) SetTableFormat(v antlr.Token) { s.tableFormat = v }
|
|
|
|
func (s *ShowColumnsContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v }
|
|
|
|
func (s *ShowColumnsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowColumnsContext) SHOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW, 0)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) FIELDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIELDS, 0)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) AllFROM() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserFROM)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) FROM(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, i)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) AllIN() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserIN)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) IN(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, i)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) FULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULL, 0)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) ShowFilter() IShowFilterContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IShowFilterContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IShowFilterContext)
|
|
}
|
|
|
|
func (s *ShowColumnsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowColumns(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowColumnsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowColumns(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowColumns(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowStatement() (localctx IShowStatementContext) {
|
|
localctx = NewShowStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 490, MySqlParserRULE_showStatement)
|
|
var _la int
|
|
|
|
p.SetState(5912)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 859, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewShowMasterLogsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5759)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5760)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowMasterLogsContext).logFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBINARY || _la == MySqlParserMASTER) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowMasterLogsContext).logFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5761)
|
|
p.Match(MySqlParserLOGS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewShowLogEventsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5762)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5763)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowLogEventsContext).logFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBINLOG || _la == MySqlParserRELAYLOG) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowLogEventsContext).logFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5764)
|
|
p.Match(MySqlParserEVENTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5767)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIN {
|
|
{
|
|
p.SetState(5765)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5766)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*ShowLogEventsContext).filename = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(5771)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM {
|
|
{
|
|
p.SetState(5769)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5770)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowLogEventsContext).fromPosition = _x
|
|
}
|
|
|
|
}
|
|
p.SetState(5780)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(5773)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5777)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 839, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5774)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowLogEventsContext).offset = _x
|
|
}
|
|
{
|
|
p.SetState(5775)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5779)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowLogEventsContext).rowCount = _x
|
|
}
|
|
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewShowObjectFilterContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5782)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5783)
|
|
p.ShowCommonEntity()
|
|
}
|
|
p.SetState(5785)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(5784)
|
|
p.ShowFilter()
|
|
}
|
|
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewShowColumnsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5787)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5789)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFULL {
|
|
{
|
|
p.SetState(5788)
|
|
p.Match(MySqlParserFULL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5791)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowColumnsContext).columnsFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowColumnsContext).columnsFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5792)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowColumnsContext).tableFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowColumnsContext).tableFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5793)
|
|
p.TableName()
|
|
}
|
|
p.SetState(5796)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM || _la == MySqlParserIN {
|
|
{
|
|
p.SetState(5794)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowColumnsContext).schemaFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowColumnsContext).schemaFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5795)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(5799)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(5798)
|
|
p.ShowFilter()
|
|
}
|
|
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewShowCreateDbContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5801)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5802)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5803)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowCreateDbContext).schemaFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowCreateDbContext).schemaFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(5805)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 845, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5804)
|
|
p.IfNotExists()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5807)
|
|
p.Uid()
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewShowCreateFullIdObjectContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5808)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5809)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5810)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowCreateFullIdObjectContext).namedEntity = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&72567767433217) != 0) || _la == MySqlParserEVENT || _la == MySqlParserFUNCTION || _la == MySqlParserVIEW) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowCreateFullIdObjectContext).namedEntity = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5811)
|
|
p.FullId()
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewShowCreateUserContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(5812)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5813)
|
|
p.Match(MySqlParserCREATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5814)
|
|
p.Match(MySqlParserUSER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5815)
|
|
p.UserName()
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewShowEngineContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(5816)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5817)
|
|
p.Match(MySqlParserENGINE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5818)
|
|
p.EngineName()
|
|
}
|
|
{
|
|
p.SetState(5819)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowEngineContext).engineOption = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserMUTEX || _la == MySqlParserSTATUS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowEngineContext).engineOption = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewShowGlobalInfoContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(5821)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5822)
|
|
p.ShowGlobalInfoClause()
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewShowErrorsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(5823)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5824)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowErrorsContext).errorFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserERRORS || _la == MySqlParserWARNINGS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowErrorsContext).errorFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(5832)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(5825)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5829)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 846, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5826)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowErrorsContext).offset = _x
|
|
}
|
|
{
|
|
p.SetState(5827)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5831)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowErrorsContext).rowCount = _x
|
|
}
|
|
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewShowCountErrorsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(5834)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5835)
|
|
p.Match(MySqlParserCOUNT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5836)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5837)
|
|
p.Match(MySqlParserSTAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5838)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5839)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowCountErrorsContext).errorFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserERRORS || _la == MySqlParserWARNINGS) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowCountErrorsContext).errorFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewShowSchemaFilterContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(5840)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5841)
|
|
p.ShowSchemaEntity()
|
|
}
|
|
p.SetState(5844)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM || _la == MySqlParserIN {
|
|
{
|
|
p.SetState(5842)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowSchemaFilterContext).schemaFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowSchemaFilterContext).schemaFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5843)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(5847)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(5846)
|
|
p.ShowFilter()
|
|
}
|
|
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewShowRoutineContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(5849)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5850)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowRoutineContext).routine = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPROCEDURE || _la == MySqlParserFUNCTION) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowRoutineContext).routine = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5851)
|
|
p.Match(MySqlParserCODE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5852)
|
|
p.FullId()
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewShowGrantsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(5853)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5854)
|
|
p.Match(MySqlParserGRANTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5857)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(5855)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5856)
|
|
p.UserName()
|
|
}
|
|
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewShowIndexesContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(5859)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5860)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowIndexesContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEYS || _la == MySqlParserINDEXES) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowIndexesContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5861)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowIndexesContext).tableFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowIndexesContext).tableFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5862)
|
|
p.TableName()
|
|
}
|
|
p.SetState(5865)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM || _la == MySqlParserIN {
|
|
{
|
|
p.SetState(5863)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowIndexesContext).schemaFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowIndexesContext).schemaFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5864)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(5869)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(5867)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5868)
|
|
p.expression(0)
|
|
}
|
|
|
|
}
|
|
|
|
case 16:
|
|
localctx = NewShowOpenTablesContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(5871)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5872)
|
|
p.Match(MySqlParserOPEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5873)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5876)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFROM || _la == MySqlParserIN {
|
|
{
|
|
p.SetState(5874)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ShowOpenTablesContext).schemaFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFROM || _la == MySqlParserIN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ShowOpenTablesContext).schemaFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5875)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(5879)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
|
|
{
|
|
p.SetState(5878)
|
|
p.ShowFilter()
|
|
}
|
|
|
|
}
|
|
|
|
case 17:
|
|
localctx = NewShowProfileContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(5881)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5882)
|
|
p.Match(MySqlParserPROFILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5883)
|
|
p.ShowProfileType()
|
|
}
|
|
p.SetState(5888)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5884)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5885)
|
|
p.ShowProfileType()
|
|
}
|
|
|
|
p.SetState(5890)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(5894)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(5891)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5892)
|
|
p.Match(MySqlParserQUERY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5893)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowProfileContext).queryCount = _x
|
|
}
|
|
|
|
}
|
|
|
|
{
|
|
p.SetState(5896)
|
|
p.Match(MySqlParserLIMIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5900)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 857, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(5897)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowProfileContext).offset = _x
|
|
}
|
|
{
|
|
p.SetState(5898)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5902)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*ShowProfileContext).rowCount = _x
|
|
}
|
|
|
|
case 18:
|
|
localctx = NewShowSlaveStatusContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(5904)
|
|
p.Match(MySqlParserSHOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5905)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5906)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(5910)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(5907)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5908)
|
|
p.Match(MySqlParserCHANNEL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5909)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IVariableClauseContext is an interface to support dynamic dispatch.
|
|
type IVariableClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LOCAL_ID() antlr.TerminalNode
|
|
GLOBAL_ID() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
GLOBAL() antlr.TerminalNode
|
|
SESSION() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
AllAT_SIGN() []antlr.TerminalNode
|
|
AT_SIGN(i int) antlr.TerminalNode
|
|
|
|
// IsVariableClauseContext differentiates from other interfaces.
|
|
IsVariableClauseContext()
|
|
}
|
|
|
|
type VariableClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyVariableClauseContext() *VariableClauseContext {
|
|
var p = new(VariableClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_variableClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyVariableClauseContext(p *VariableClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_variableClause
|
|
}
|
|
|
|
func (*VariableClauseContext) IsVariableClauseContext() {}
|
|
|
|
func NewVariableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableClauseContext {
|
|
var p = new(VariableClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_variableClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *VariableClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *VariableClauseContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *VariableClauseContext) GLOBAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL_ID, 0)
|
|
}
|
|
|
|
func (s *VariableClauseContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *VariableClauseContext) GLOBAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL, 0)
|
|
}
|
|
|
|
func (s *VariableClauseContext) SESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION, 0)
|
|
}
|
|
|
|
func (s *VariableClauseContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *VariableClauseContext) AllAT_SIGN() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserAT_SIGN)
|
|
}
|
|
|
|
func (s *VariableClauseContext) AT_SIGN(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAT_SIGN, i)
|
|
}
|
|
|
|
func (s *VariableClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *VariableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *VariableClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterVariableClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *VariableClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitVariableClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *VariableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitVariableClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) VariableClause() (localctx IVariableClauseContext) {
|
|
localctx = NewVariableClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 492, MySqlParserRULE_variableClause)
|
|
var _la int
|
|
|
|
p.SetState(5924)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLOCAL_ID:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5914)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserGLOBAL_ID:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5915)
|
|
p.Match(MySqlParserGLOBAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserAT_SIGN, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(5921)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 861, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(5918)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAT_SIGN {
|
|
{
|
|
p.SetState(5916)
|
|
p.Match(MySqlParserAT_SIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5917)
|
|
p.Match(MySqlParserAT_SIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5920)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserGLOBAL || _la == MySqlParserLOCAL || _la == MySqlParserSESSION) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(5923)
|
|
p.Uid()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowCommonEntityContext is an interface to support dynamic dispatch.
|
|
type IShowCommonEntityContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CHARACTER() antlr.TerminalNode
|
|
SET() antlr.TerminalNode
|
|
COLLATION() antlr.TerminalNode
|
|
DATABASES() antlr.TerminalNode
|
|
SCHEMAS() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
STATUS() antlr.TerminalNode
|
|
PROCEDURE() antlr.TerminalNode
|
|
VARIABLES() antlr.TerminalNode
|
|
GLOBAL() antlr.TerminalNode
|
|
SESSION() antlr.TerminalNode
|
|
|
|
// IsShowCommonEntityContext differentiates from other interfaces.
|
|
IsShowCommonEntityContext()
|
|
}
|
|
|
|
type ShowCommonEntityContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowCommonEntityContext() *ShowCommonEntityContext {
|
|
var p = new(ShowCommonEntityContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showCommonEntity
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowCommonEntityContext(p *ShowCommonEntityContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showCommonEntity
|
|
}
|
|
|
|
func (*ShowCommonEntityContext) IsShowCommonEntityContext() {}
|
|
|
|
func NewShowCommonEntityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowCommonEntityContext {
|
|
var p = new(ShowCommonEntityContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showCommonEntity
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowCommonEntityContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) COLLATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATION, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) DATABASES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASES, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) SCHEMAS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMAS, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) PROCEDURE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCEDURE, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) VARIABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARIABLES, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) GLOBAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) SESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION, 0)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowCommonEntity(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowCommonEntity(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowCommonEntityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowCommonEntity(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowCommonEntity() (localctx IShowCommonEntityContext) {
|
|
localctx = NewShowCommonEntityContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 494, MySqlParserRULE_showCommonEntity)
|
|
var _la int
|
|
|
|
p.SetState(5939)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCHARACTER:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5926)
|
|
p.Match(MySqlParserCHARACTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5927)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCOLLATION:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5928)
|
|
p.Match(MySqlParserCOLLATION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDATABASES:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5929)
|
|
p.Match(MySqlParserDATABASES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSCHEMAS:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5930)
|
|
p.Match(MySqlParserSCHEMAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFUNCTION:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5931)
|
|
p.Match(MySqlParserFUNCTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5932)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPROCEDURE:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5933)
|
|
p.Match(MySqlParserPROCEDURE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5934)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserGLOBAL, MySqlParserSESSION, MySqlParserSTATUS, MySqlParserVARIABLES:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
p.SetState(5936)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserGLOBAL || _la == MySqlParserSESSION {
|
|
{
|
|
p.SetState(5935)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserGLOBAL || _la == MySqlParserSESSION) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5938)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSTATUS || _la == MySqlParserVARIABLES) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowFilterContext is an interface to support dynamic dispatch.
|
|
type IShowFilterContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LIKE() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
WHERE() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsShowFilterContext differentiates from other interfaces.
|
|
IsShowFilterContext()
|
|
}
|
|
|
|
type ShowFilterContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowFilterContext() *ShowFilterContext {
|
|
var p = new(ShowFilterContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showFilter
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowFilterContext(p *ShowFilterContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showFilter
|
|
}
|
|
|
|
func (*ShowFilterContext) IsShowFilterContext() {}
|
|
|
|
func NewShowFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowFilterContext {
|
|
var p = new(ShowFilterContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showFilter
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowFilterContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowFilterContext) LIKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIKE, 0)
|
|
}
|
|
|
|
func (s *ShowFilterContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ShowFilterContext) WHERE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHERE, 0)
|
|
}
|
|
|
|
func (s *ShowFilterContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ShowFilterContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShowFilterContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowFilterContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowFilter(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowFilter(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowFilter() (localctx IShowFilterContext) {
|
|
localctx = NewShowFilterContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 496, MySqlParserRULE_showFilter)
|
|
p.SetState(5945)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLIKE:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5941)
|
|
p.Match(MySqlParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5942)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserWHERE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5943)
|
|
p.Match(MySqlParserWHERE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5944)
|
|
p.expression(0)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowGlobalInfoClauseContext is an interface to support dynamic dispatch.
|
|
type IShowGlobalInfoClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ENGINES() antlr.TerminalNode
|
|
STORAGE() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
STATUS() antlr.TerminalNode
|
|
PLUGINS() antlr.TerminalNode
|
|
PRIVILEGES() antlr.TerminalNode
|
|
PROCESSLIST() antlr.TerminalNode
|
|
FULL() antlr.TerminalNode
|
|
PROFILES() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
HOSTS() antlr.TerminalNode
|
|
AUTHORS() antlr.TerminalNode
|
|
CONTRIBUTORS() antlr.TerminalNode
|
|
|
|
// IsShowGlobalInfoClauseContext differentiates from other interfaces.
|
|
IsShowGlobalInfoClauseContext()
|
|
}
|
|
|
|
type ShowGlobalInfoClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowGlobalInfoClauseContext() *ShowGlobalInfoClauseContext {
|
|
var p = new(ShowGlobalInfoClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showGlobalInfoClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowGlobalInfoClauseContext(p *ShowGlobalInfoClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showGlobalInfoClause
|
|
}
|
|
|
|
func (*ShowGlobalInfoClauseContext) IsShowGlobalInfoClauseContext() {}
|
|
|
|
func NewShowGlobalInfoClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowGlobalInfoClauseContext {
|
|
var p = new(ShowGlobalInfoClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showGlobalInfoClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowGlobalInfoClauseContext) ENGINES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINES, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) STORAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORAGE, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) PLUGINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGINS, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) PRIVILEGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIVILEGES, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) PROCESSLIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCESSLIST, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) FULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULL, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) PROFILES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROFILES, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) HOSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOSTS, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) AUTHORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTHORS, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) CONTRIBUTORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTRIBUTORS, 0)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowGlobalInfoClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowGlobalInfoClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowGlobalInfoClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowGlobalInfoClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowGlobalInfoClause() (localctx IShowGlobalInfoClauseContext) {
|
|
localctx = NewShowGlobalInfoClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 498, MySqlParserRULE_showGlobalInfoClause)
|
|
var _la int
|
|
|
|
p.SetState(5964)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserENGINES, MySqlParserSTORAGE:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(5948)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTORAGE {
|
|
{
|
|
p.SetState(5947)
|
|
p.Match(MySqlParserSTORAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5950)
|
|
p.Match(MySqlParserENGINES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMASTER:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5951)
|
|
p.Match(MySqlParserMASTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5952)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPLUGINS:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5953)
|
|
p.Match(MySqlParserPLUGINS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPRIVILEGES:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5954)
|
|
p.Match(MySqlParserPRIVILEGES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFULL, MySqlParserPROCESSLIST:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
p.SetState(5956)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFULL {
|
|
{
|
|
p.SetState(5955)
|
|
p.Match(MySqlParserFULL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5958)
|
|
p.Match(MySqlParserPROCESSLIST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPROFILES:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5959)
|
|
p.Match(MySqlParserPROFILES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSLAVE:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(5960)
|
|
p.Match(MySqlParserSLAVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5961)
|
|
p.Match(MySqlParserHOSTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserAUTHORS:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(5962)
|
|
p.Match(MySqlParserAUTHORS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCONTRIBUTORS:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(5963)
|
|
p.Match(MySqlParserCONTRIBUTORS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowSchemaEntityContext is an interface to support dynamic dispatch.
|
|
type IShowSchemaEntityContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EVENTS() antlr.TerminalNode
|
|
TABLE() antlr.TerminalNode
|
|
STATUS() antlr.TerminalNode
|
|
TABLES() antlr.TerminalNode
|
|
FULL() antlr.TerminalNode
|
|
TRIGGERS() antlr.TerminalNode
|
|
|
|
// IsShowSchemaEntityContext differentiates from other interfaces.
|
|
IsShowSchemaEntityContext()
|
|
}
|
|
|
|
type ShowSchemaEntityContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowSchemaEntityContext() *ShowSchemaEntityContext {
|
|
var p = new(ShowSchemaEntityContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showSchemaEntity
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowSchemaEntityContext(p *ShowSchemaEntityContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showSchemaEntity
|
|
}
|
|
|
|
func (*ShowSchemaEntityContext) IsShowSchemaEntityContext() {}
|
|
|
|
func NewShowSchemaEntityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowSchemaEntityContext {
|
|
var p = new(ShowSchemaEntityContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showSchemaEntity
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowSchemaEntityContext) EVENTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENTS, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) FULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULL, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) TRIGGERS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGERS, 0)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowSchemaEntity(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowSchemaEntity(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowSchemaEntityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowSchemaEntity(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowSchemaEntity() (localctx IShowSchemaEntityContext) {
|
|
localctx = NewShowSchemaEntityContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 500, MySqlParserRULE_showSchemaEntity)
|
|
var _la int
|
|
|
|
p.SetState(5974)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserEVENTS:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5966)
|
|
p.Match(MySqlParserEVENTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTABLE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5967)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5968)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFULL, MySqlParserTABLES:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(5970)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFULL {
|
|
{
|
|
p.SetState(5969)
|
|
p.Match(MySqlParserFULL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(5972)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTRIGGERS:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5973)
|
|
p.Match(MySqlParserTRIGGERS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShowProfileTypeContext is an interface to support dynamic dispatch.
|
|
type IShowProfileTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ALL() antlr.TerminalNode
|
|
BLOCK() antlr.TerminalNode
|
|
IO() antlr.TerminalNode
|
|
CONTEXT() antlr.TerminalNode
|
|
SWITCHES() antlr.TerminalNode
|
|
CPU() antlr.TerminalNode
|
|
IPC() antlr.TerminalNode
|
|
MEMORY() antlr.TerminalNode
|
|
PAGE() antlr.TerminalNode
|
|
FAULTS() antlr.TerminalNode
|
|
SOURCE() antlr.TerminalNode
|
|
SWAPS() antlr.TerminalNode
|
|
|
|
// IsShowProfileTypeContext differentiates from other interfaces.
|
|
IsShowProfileTypeContext()
|
|
}
|
|
|
|
type ShowProfileTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShowProfileTypeContext() *ShowProfileTypeContext {
|
|
var p = new(ShowProfileTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showProfileType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShowProfileTypeContext(p *ShowProfileTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_showProfileType
|
|
}
|
|
|
|
func (*ShowProfileTypeContext) IsShowProfileTypeContext() {}
|
|
|
|
func NewShowProfileTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowProfileTypeContext {
|
|
var p = new(ShowProfileTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_showProfileType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShowProfileTypeContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) BLOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBLOCK, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) IO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIO, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) CONTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTEXT, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) SWITCHES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSWITCHES, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) CPU() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCPU, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) IPC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIPC, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) MEMORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMORY, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) PAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) FAULTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAULTS, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) SOURCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOURCE, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) SWAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSWAPS, 0)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShowProfileType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShowProfileType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShowProfileTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShowProfileType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShowProfileType() (localctx IShowProfileTypeContext) {
|
|
localctx = NewShowProfileTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 502, MySqlParserRULE_showProfileType)
|
|
p.SetState(5988)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserALL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5976)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBLOCK:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(5977)
|
|
p.Match(MySqlParserBLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5978)
|
|
p.Match(MySqlParserIO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCONTEXT:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(5979)
|
|
p.Match(MySqlParserCONTEXT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5980)
|
|
p.Match(MySqlParserSWITCHES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCPU:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(5981)
|
|
p.Match(MySqlParserCPU)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserIPC:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(5982)
|
|
p.Match(MySqlParserIPC)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMEMORY:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(5983)
|
|
p.Match(MySqlParserMEMORY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPAGE:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(5984)
|
|
p.Match(MySqlParserPAGE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5985)
|
|
p.Match(MySqlParserFAULTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSOURCE:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(5986)
|
|
p.Match(MySqlParserSOURCE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSWAPS:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(5987)
|
|
p.Match(MySqlParserSWAPS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBinlogStatementContext is an interface to support dynamic dispatch.
|
|
type IBinlogStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BINLOG() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsBinlogStatementContext differentiates from other interfaces.
|
|
IsBinlogStatementContext()
|
|
}
|
|
|
|
type BinlogStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBinlogStatementContext() *BinlogStatementContext {
|
|
var p = new(BinlogStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_binlogStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBinlogStatementContext(p *BinlogStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_binlogStatement
|
|
}
|
|
|
|
func (*BinlogStatementContext) IsBinlogStatementContext() {}
|
|
|
|
func NewBinlogStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BinlogStatementContext {
|
|
var p = new(BinlogStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_binlogStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BinlogStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BinlogStatementContext) BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG, 0)
|
|
}
|
|
|
|
func (s *BinlogStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *BinlogStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BinlogStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BinlogStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBinlogStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinlogStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBinlogStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinlogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBinlogStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BinlogStatement() (localctx IBinlogStatementContext) {
|
|
localctx = NewBinlogStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 504, MySqlParserRULE_binlogStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5990)
|
|
p.Match(MySqlParserBINLOG)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5991)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICacheIndexStatementContext is an interface to support dynamic dispatch.
|
|
type ICacheIndexStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetSchema returns the schema rule contexts.
|
|
GetSchema() IUidContext
|
|
|
|
// SetSchema sets the schema rule contexts.
|
|
SetSchema(IUidContext)
|
|
|
|
// Getter signatures
|
|
CACHE() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
AllTableIndexes() []ITableIndexesContext
|
|
TableIndexes(i int) ITableIndexesContext
|
|
IN() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
PARTITION() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
ALL() antlr.TerminalNode
|
|
|
|
// IsCacheIndexStatementContext differentiates from other interfaces.
|
|
IsCacheIndexStatementContext()
|
|
}
|
|
|
|
type CacheIndexStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
schema IUidContext
|
|
}
|
|
|
|
func NewEmptyCacheIndexStatementContext() *CacheIndexStatementContext {
|
|
var p = new(CacheIndexStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cacheIndexStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCacheIndexStatementContext(p *CacheIndexStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_cacheIndexStatement
|
|
}
|
|
|
|
func (*CacheIndexStatementContext) IsCacheIndexStatementContext() {}
|
|
|
|
func NewCacheIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CacheIndexStatementContext {
|
|
var p = new(CacheIndexStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_cacheIndexStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CacheIndexStatementContext) GetSchema() IUidContext { return s.schema }
|
|
|
|
func (s *CacheIndexStatementContext) SetSchema(v IUidContext) { s.schema = v }
|
|
|
|
func (s *CacheIndexStatementContext) CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCACHE, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) AllTableIndexes() []ITableIndexesContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableIndexesContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableIndexesContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableIndexesContext); ok {
|
|
tst[i] = t.(ITableIndexesContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) TableIndexes(i int) ITableIndexesContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableIndexesContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableIndexesContext)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCacheIndexStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCacheIndexStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *CacheIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCacheIndexStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CacheIndexStatement() (localctx ICacheIndexStatementContext) {
|
|
localctx = NewCacheIndexStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 506, MySqlParserRULE_cacheIndexStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(5993)
|
|
p.Match(MySqlParserCACHE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5994)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5995)
|
|
p.TableIndexes()
|
|
}
|
|
p.SetState(6000)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(5996)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(5997)
|
|
p.TableIndexes()
|
|
}
|
|
|
|
p.SetState(6002)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(6010)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(6003)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6004)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6007)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(6005)
|
|
p.UidList()
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(6006)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6009)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6012)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6013)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*CacheIndexStatementContext).schema = _x
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFlushStatementContext is an interface to support dynamic dispatch.
|
|
type IFlushStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFlushFormat returns the flushFormat token.
|
|
GetFlushFormat() antlr.Token
|
|
|
|
// SetFlushFormat sets the flushFormat token.
|
|
SetFlushFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
FLUSH() antlr.TerminalNode
|
|
AllFlushOption() []IFlushOptionContext
|
|
FlushOption(i int) IFlushOptionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
NO_WRITE_TO_BINLOG() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
|
|
// IsFlushStatementContext differentiates from other interfaces.
|
|
IsFlushStatementContext()
|
|
}
|
|
|
|
type FlushStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
flushFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyFlushStatementContext() *FlushStatementContext {
|
|
var p = new(FlushStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFlushStatementContext(p *FlushStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushStatement
|
|
}
|
|
|
|
func (*FlushStatementContext) IsFlushStatementContext() {}
|
|
|
|
func NewFlushStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushStatementContext {
|
|
var p = new(FlushStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_flushStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FlushStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FlushStatementContext) GetFlushFormat() antlr.Token { return s.flushFormat }
|
|
|
|
func (s *FlushStatementContext) SetFlushFormat(v antlr.Token) { s.flushFormat = v }
|
|
|
|
func (s *FlushStatementContext) FLUSH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH, 0)
|
|
}
|
|
|
|
func (s *FlushStatementContext) AllFlushOption() []IFlushOptionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFlushOptionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFlushOptionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFlushOptionContext); ok {
|
|
tst[i] = t.(IFlushOptionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FlushStatementContext) FlushOption(i int) IFlushOptionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFlushOptionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFlushOptionContext)
|
|
}
|
|
|
|
func (s *FlushStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *FlushStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *FlushStatementContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0)
|
|
}
|
|
|
|
func (s *FlushStatementContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *FlushStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FlushStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FlushStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFlushStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *FlushStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFlushStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *FlushStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFlushStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FlushStatement() (localctx IFlushStatementContext) {
|
|
localctx = NewFlushStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 508, MySqlParserRULE_flushStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6015)
|
|
p.Match(MySqlParserFLUSH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6017)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
|
|
{
|
|
p.SetState(6016)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*FlushStatementContext).flushFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*FlushStatementContext).flushFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6019)
|
|
p.FlushOption()
|
|
}
|
|
p.SetState(6024)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6020)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6021)
|
|
p.FlushOption()
|
|
}
|
|
|
|
p.SetState(6026)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IKillStatementContext is an interface to support dynamic dispatch.
|
|
type IKillStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetConnectionFormat returns the connectionFormat token.
|
|
GetConnectionFormat() antlr.Token
|
|
|
|
// SetConnectionFormat sets the connectionFormat token.
|
|
SetConnectionFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
KILL() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
CONNECTION() antlr.TerminalNode
|
|
QUERY() antlr.TerminalNode
|
|
|
|
// IsKillStatementContext differentiates from other interfaces.
|
|
IsKillStatementContext()
|
|
}
|
|
|
|
type KillStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
connectionFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyKillStatementContext() *KillStatementContext {
|
|
var p = new(KillStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_killStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyKillStatementContext(p *KillStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_killStatement
|
|
}
|
|
|
|
func (*KillStatementContext) IsKillStatementContext() {}
|
|
|
|
func NewKillStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KillStatementContext {
|
|
var p = new(KillStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_killStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *KillStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *KillStatementContext) GetConnectionFormat() antlr.Token { return s.connectionFormat }
|
|
|
|
func (s *KillStatementContext) SetConnectionFormat(v antlr.Token) { s.connectionFormat = v }
|
|
|
|
func (s *KillStatementContext) KILL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKILL, 0)
|
|
}
|
|
|
|
func (s *KillStatementContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *KillStatementContext) CONNECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION, 0)
|
|
}
|
|
|
|
func (s *KillStatementContext) QUERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUERY, 0)
|
|
}
|
|
|
|
func (s *KillStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *KillStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *KillStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterKillStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *KillStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitKillStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *KillStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitKillStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) KillStatement() (localctx IKillStatementContext) {
|
|
localctx = NewKillStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 510, MySqlParserRULE_killStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6027)
|
|
p.Match(MySqlParserKILL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6029)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 877, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6028)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*KillStatementContext).connectionFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCONNECTION || _la == MySqlParserQUERY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*KillStatementContext).connectionFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6031)
|
|
p.expression(0)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILoadIndexIntoCacheContext is an interface to support dynamic dispatch.
|
|
type ILoadIndexIntoCacheContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LOAD() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
INTO() antlr.TerminalNode
|
|
CACHE() antlr.TerminalNode
|
|
AllLoadedTableIndexes() []ILoadedTableIndexesContext
|
|
LoadedTableIndexes(i int) ILoadedTableIndexesContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsLoadIndexIntoCacheContext differentiates from other interfaces.
|
|
IsLoadIndexIntoCacheContext()
|
|
}
|
|
|
|
type LoadIndexIntoCacheContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLoadIndexIntoCacheContext() *LoadIndexIntoCacheContext {
|
|
var p = new(LoadIndexIntoCacheContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadIndexIntoCache
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLoadIndexIntoCacheContext(p *LoadIndexIntoCacheContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadIndexIntoCache
|
|
}
|
|
|
|
func (*LoadIndexIntoCacheContext) IsLoadIndexIntoCacheContext() {}
|
|
|
|
func NewLoadIndexIntoCacheContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadIndexIntoCacheContext {
|
|
var p = new(LoadIndexIntoCacheContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_loadIndexIntoCache
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LoadIndexIntoCacheContext) LOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOAD, 0)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) INTO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTO, 0)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCACHE, 0)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) AllLoadedTableIndexes() []ILoadedTableIndexesContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ILoadedTableIndexesContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ILoadedTableIndexesContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ILoadedTableIndexesContext); ok {
|
|
tst[i] = t.(ILoadedTableIndexesContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) LoadedTableIndexes(i int) ILoadedTableIndexesContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILoadedTableIndexesContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILoadedTableIndexesContext)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLoadIndexIntoCache(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLoadIndexIntoCache(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadIndexIntoCacheContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLoadIndexIntoCache(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LoadIndexIntoCache() (localctx ILoadIndexIntoCacheContext) {
|
|
localctx = NewLoadIndexIntoCacheContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 512, MySqlParserRULE_loadIndexIntoCache)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6033)
|
|
p.Match(MySqlParserLOAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6034)
|
|
p.Match(MySqlParserINDEX)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6035)
|
|
p.Match(MySqlParserINTO)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6036)
|
|
p.Match(MySqlParserCACHE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6037)
|
|
p.LoadedTableIndexes()
|
|
}
|
|
p.SetState(6042)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6038)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6039)
|
|
p.LoadedTableIndexes()
|
|
}
|
|
|
|
p.SetState(6044)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IResetStatementContext is an interface to support dynamic dispatch.
|
|
type IResetStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RESET() antlr.TerminalNode
|
|
QUERY() antlr.TerminalNode
|
|
CACHE() antlr.TerminalNode
|
|
|
|
// IsResetStatementContext differentiates from other interfaces.
|
|
IsResetStatementContext()
|
|
}
|
|
|
|
type ResetStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyResetStatementContext() *ResetStatementContext {
|
|
var p = new(ResetStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyResetStatementContext(p *ResetStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resetStatement
|
|
}
|
|
|
|
func (*ResetStatementContext) IsResetStatementContext() {}
|
|
|
|
func NewResetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetStatementContext {
|
|
var p = new(ResetStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_resetStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ResetStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ResetStatementContext) RESET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESET, 0)
|
|
}
|
|
|
|
func (s *ResetStatementContext) QUERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUERY, 0)
|
|
}
|
|
|
|
func (s *ResetStatementContext) CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCACHE, 0)
|
|
}
|
|
|
|
func (s *ResetStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ResetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ResetStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterResetStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitResetStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitResetStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ResetStatement() (localctx IResetStatementContext) {
|
|
localctx = NewResetStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 514, MySqlParserRULE_resetStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6045)
|
|
p.Match(MySqlParserRESET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6046)
|
|
p.Match(MySqlParserQUERY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6047)
|
|
p.Match(MySqlParserCACHE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IShutdownStatementContext is an interface to support dynamic dispatch.
|
|
type IShutdownStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SHUTDOWN() antlr.TerminalNode
|
|
|
|
// IsShutdownStatementContext differentiates from other interfaces.
|
|
IsShutdownStatementContext()
|
|
}
|
|
|
|
type ShutdownStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyShutdownStatementContext() *ShutdownStatementContext {
|
|
var p = new(ShutdownStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_shutdownStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyShutdownStatementContext(p *ShutdownStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_shutdownStatement
|
|
}
|
|
|
|
func (*ShutdownStatementContext) IsShutdownStatementContext() {}
|
|
|
|
func NewShutdownStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShutdownStatementContext {
|
|
var p = new(ShutdownStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_shutdownStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ShutdownStatementContext) SHUTDOWN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHUTDOWN, 0)
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterShutdownStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitShutdownStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ShutdownStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitShutdownStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ShutdownStatement() (localctx IShutdownStatementContext) {
|
|
localctx = NewShutdownStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 516, MySqlParserRULE_shutdownStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6049)
|
|
p.Match(MySqlParserSHUTDOWN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableIndexesContext is an interface to support dynamic dispatch.
|
|
type ITableIndexesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIndexFormat returns the indexFormat token.
|
|
GetIndexFormat() antlr.Token
|
|
|
|
// SetIndexFormat sets the indexFormat token.
|
|
SetIndexFormat(antlr.Token)
|
|
|
|
// Getter signatures
|
|
TableName() ITableNameContext
|
|
LR_BRACKET() antlr.TerminalNode
|
|
UidList() IUidListContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
KEY() antlr.TerminalNode
|
|
|
|
// IsTableIndexesContext differentiates from other interfaces.
|
|
IsTableIndexesContext()
|
|
}
|
|
|
|
type TableIndexesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
indexFormat antlr.Token
|
|
}
|
|
|
|
func NewEmptyTableIndexesContext() *TableIndexesContext {
|
|
var p = new(TableIndexesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableIndexes
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableIndexesContext(p *TableIndexesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableIndexes
|
|
}
|
|
|
|
func (*TableIndexesContext) IsTableIndexesContext() {}
|
|
|
|
func NewTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableIndexesContext {
|
|
var p = new(TableIndexesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableIndexes
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableIndexesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *TableIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *TableIndexesContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *TableIndexesContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableIndexesContext) UidList() IUidListContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *TableIndexesContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TableIndexesContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *TableIndexesContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *TableIndexesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TableIndexesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableIndexesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableIndexes(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableIndexes() (localctx ITableIndexesContext) {
|
|
localctx = NewTableIndexesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 518, MySqlParserRULE_tableIndexes)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6051)
|
|
p.TableName()
|
|
}
|
|
p.SetState(6059)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY || _la == MySqlParserLR_BRACKET {
|
|
p.SetState(6053)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(6052)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TableIndexesContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TableIndexesContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6055)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6056)
|
|
p.UidList()
|
|
}
|
|
{
|
|
p.SetState(6057)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFlushOptionContext is an interface to support dynamic dispatch.
|
|
type IFlushOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsFlushOptionContext differentiates from other interfaces.
|
|
IsFlushOptionContext()
|
|
}
|
|
|
|
type FlushOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFlushOptionContext() *FlushOptionContext {
|
|
var p = new(FlushOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFlushOptionContext(p *FlushOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushOption
|
|
}
|
|
|
|
func (*FlushOptionContext) IsFlushOptionContext() {}
|
|
|
|
func NewFlushOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushOptionContext {
|
|
var p = new(FlushOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_flushOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FlushOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FlushOptionContext) CopyAll(ctx *FlushOptionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *FlushOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FlushOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type TableFlushOptionContext struct {
|
|
FlushOptionContext
|
|
}
|
|
|
|
func NewTableFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableFlushOptionContext {
|
|
var p = new(TableFlushOptionContext)
|
|
|
|
InitEmptyFlushOptionContext(&p.FlushOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FlushOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) Tables() ITablesContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITablesContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITablesContext)
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) FlushTableOption() IFlushTableOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFlushTableOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFlushTableOptionContext)
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableFlushOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ChannelFlushOptionContext struct {
|
|
FlushOptionContext
|
|
}
|
|
|
|
func NewChannelFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ChannelFlushOptionContext {
|
|
var p = new(ChannelFlushOptionContext)
|
|
|
|
InitEmptyFlushOptionContext(&p.FlushOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FlushOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) RELAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY, 0)
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) LOGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGS, 0)
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) ChannelOption() IChannelOptionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IChannelOptionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IChannelOptionContext)
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterChannelFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitChannelFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *ChannelFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitChannelFlushOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SimpleFlushOptionContext struct {
|
|
FlushOptionContext
|
|
}
|
|
|
|
func NewSimpleFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleFlushOptionContext {
|
|
var p = new(SimpleFlushOptionContext)
|
|
|
|
InitEmptyFlushOptionContext(&p.FlushOptionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FlushOptionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) DES_KEY_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDES_KEY_FILE, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) HOSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOSTS, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) LOGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGS, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) OPTIMIZER_COSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIMIZER_COSTS, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) PRIVILEGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIVILEGES, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) QUERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUERY, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCACHE, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) USER_RESOURCES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER_RESOURCES, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) ERROR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERROR, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) GENERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGENERAL, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) RELAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) SLOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLOW, 0)
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleFlushOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleFlushOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FlushOption() (localctx IFlushOptionContext) {
|
|
localctx = NewFlushOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 520, MySqlParserRULE_flushOption)
|
|
var _la int
|
|
|
|
p.SetState(6093)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSimpleFlushOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6079)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDES_KEY_FILE:
|
|
{
|
|
p.SetState(6061)
|
|
p.Match(MySqlParserDES_KEY_FILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserHOSTS:
|
|
{
|
|
p.SetState(6062)
|
|
p.Match(MySqlParserHOSTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBINARY, MySqlParserENGINE, MySqlParserERROR, MySqlParserGENERAL, MySqlParserLOGS, MySqlParserRELAY, MySqlParserSLOW:
|
|
p.SetState(6064)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserBINARY || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW {
|
|
{
|
|
p.SetState(6063)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBINARY || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6066)
|
|
p.Match(MySqlParserLOGS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserOPTIMIZER_COSTS:
|
|
{
|
|
p.SetState(6067)
|
|
p.Match(MySqlParserOPTIMIZER_COSTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserPRIVILEGES:
|
|
{
|
|
p.SetState(6068)
|
|
p.Match(MySqlParserPRIVILEGES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserQUERY:
|
|
{
|
|
p.SetState(6069)
|
|
p.Match(MySqlParserQUERY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6070)
|
|
p.Match(MySqlParserCACHE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTATUS:
|
|
{
|
|
p.SetState(6071)
|
|
p.Match(MySqlParserSTATUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUSER_RESOURCES:
|
|
{
|
|
p.SetState(6072)
|
|
p.Match(MySqlParserUSER_RESOURCES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTABLES:
|
|
{
|
|
p.SetState(6073)
|
|
p.Match(MySqlParserTABLES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6077)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 882, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6074)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6075)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6076)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewChannelFlushOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6081)
|
|
p.Match(MySqlParserRELAY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6082)
|
|
p.Match(MySqlParserLOGS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6084)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(6083)
|
|
p.ChannelOption()
|
|
}
|
|
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewTableFlushOptionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6086)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6088)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6087)
|
|
p.Tables()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6091)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 886, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6090)
|
|
p.FlushTableOption()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFlushTableOptionContext is an interface to support dynamic dispatch.
|
|
type IFlushTableOptionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WITH() antlr.TerminalNode
|
|
READ() antlr.TerminalNode
|
|
LOCK() antlr.TerminalNode
|
|
FOR() antlr.TerminalNode
|
|
EXPORT() antlr.TerminalNode
|
|
|
|
// IsFlushTableOptionContext differentiates from other interfaces.
|
|
IsFlushTableOptionContext()
|
|
}
|
|
|
|
type FlushTableOptionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFlushTableOptionContext() *FlushTableOptionContext {
|
|
var p = new(FlushTableOptionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushTableOption
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFlushTableOptionContext(p *FlushTableOptionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_flushTableOption
|
|
}
|
|
|
|
func (*FlushTableOptionContext) IsFlushTableOptionContext() {}
|
|
|
|
func NewFlushTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushTableOptionContext {
|
|
var p = new(FlushTableOptionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_flushTableOption
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FlushTableOptionContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) READ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAD, 0)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCK, 0)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) EXPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPORT, 0)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFlushTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFlushTableOption(s)
|
|
}
|
|
}
|
|
|
|
func (s *FlushTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFlushTableOption(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FlushTableOption() (localctx IFlushTableOptionContext) {
|
|
localctx = NewFlushTableOptionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 522, MySqlParserRULE_flushTableOption)
|
|
p.SetState(6100)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserWITH:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6095)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6096)
|
|
p.Match(MySqlParserREAD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6097)
|
|
p.Match(MySqlParserLOCK)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserFOR:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6098)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6099)
|
|
p.Match(MySqlParserEXPORT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILoadedTableIndexesContext is an interface to support dynamic dispatch.
|
|
type ILoadedTableIndexesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetIndexFormat returns the indexFormat token.
|
|
GetIndexFormat() antlr.Token
|
|
|
|
// SetIndexFormat sets the indexFormat token.
|
|
SetIndexFormat(antlr.Token)
|
|
|
|
// GetPartitionList returns the partitionList rule contexts.
|
|
GetPartitionList() IUidListContext
|
|
|
|
// GetIndexList returns the indexList rule contexts.
|
|
GetIndexList() IUidListContext
|
|
|
|
// SetPartitionList sets the partitionList rule contexts.
|
|
SetPartitionList(IUidListContext)
|
|
|
|
// SetIndexList sets the indexList rule contexts.
|
|
SetIndexList(IUidListContext)
|
|
|
|
// Getter signatures
|
|
TableName() ITableNameContext
|
|
PARTITION() antlr.TerminalNode
|
|
AllLR_BRACKET() []antlr.TerminalNode
|
|
LR_BRACKET(i int) antlr.TerminalNode
|
|
AllRR_BRACKET() []antlr.TerminalNode
|
|
RR_BRACKET(i int) antlr.TerminalNode
|
|
IGNORE() antlr.TerminalNode
|
|
LEAVES() antlr.TerminalNode
|
|
AllUidList() []IUidListContext
|
|
UidList(i int) IUidListContext
|
|
ALL() antlr.TerminalNode
|
|
INDEX() antlr.TerminalNode
|
|
KEY() antlr.TerminalNode
|
|
|
|
// IsLoadedTableIndexesContext differentiates from other interfaces.
|
|
IsLoadedTableIndexesContext()
|
|
}
|
|
|
|
type LoadedTableIndexesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
partitionList IUidListContext
|
|
indexFormat antlr.Token
|
|
indexList IUidListContext
|
|
}
|
|
|
|
func NewEmptyLoadedTableIndexesContext() *LoadedTableIndexesContext {
|
|
var p = new(LoadedTableIndexesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadedTableIndexes
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLoadedTableIndexesContext(p *LoadedTableIndexesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_loadedTableIndexes
|
|
}
|
|
|
|
func (*LoadedTableIndexesContext) IsLoadedTableIndexesContext() {}
|
|
|
|
func NewLoadedTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadedTableIndexesContext {
|
|
var p = new(LoadedTableIndexesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_loadedTableIndexes
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LoadedTableIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat }
|
|
|
|
func (s *LoadedTableIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v }
|
|
|
|
func (s *LoadedTableIndexesContext) GetPartitionList() IUidListContext { return s.partitionList }
|
|
|
|
func (s *LoadedTableIndexesContext) GetIndexList() IUidListContext { return s.indexList }
|
|
|
|
func (s *LoadedTableIndexesContext) SetPartitionList(v IUidListContext) { s.partitionList = v }
|
|
|
|
func (s *LoadedTableIndexesContext) SetIndexList(v IUidListContext) { s.indexList = v }
|
|
|
|
func (s *LoadedTableIndexesContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) IGNORE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) LEAVES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAVES, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) AllUidList() []IUidListContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidListContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidListContext); ok {
|
|
tst[i] = t.(IUidListContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) UidList(i int) IUidListContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidListContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidListContext)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEX, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY, 0)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLoadedTableIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLoadedTableIndexes(s)
|
|
}
|
|
}
|
|
|
|
func (s *LoadedTableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLoadedTableIndexes(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LoadedTableIndexes() (localctx ILoadedTableIndexesContext) {
|
|
localctx = NewLoadedTableIndexesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 524, MySqlParserRULE_loadedTableIndexes)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6102)
|
|
p.TableName()
|
|
}
|
|
p.SetState(6110)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(6103)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6104)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6107)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(6105)
|
|
|
|
var _x = p.UidList()
|
|
|
|
localctx.(*LoadedTableIndexesContext).partitionList = _x
|
|
}
|
|
|
|
case MySqlParserALL:
|
|
{
|
|
p.SetState(6106)
|
|
p.Match(MySqlParserALL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6109)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6119)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 892, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(6113)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINDEX || _la == MySqlParserKEY {
|
|
{
|
|
p.SetState(6112)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LoadedTableIndexesContext).indexFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LoadedTableIndexesContext).indexFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6115)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6116)
|
|
|
|
var _x = p.UidList()
|
|
|
|
localctx.(*LoadedTableIndexesContext).indexList = _x
|
|
}
|
|
{
|
|
p.SetState(6117)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6123)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserIGNORE {
|
|
{
|
|
p.SetState(6121)
|
|
p.Match(MySqlParserIGNORE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6122)
|
|
p.Match(MySqlParserLEAVES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISimpleDescribeStatementContext is an interface to support dynamic dispatch.
|
|
type ISimpleDescribeStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCommand returns the command token.
|
|
GetCommand() antlr.Token
|
|
|
|
// GetPattern returns the pattern token.
|
|
GetPattern() antlr.Token
|
|
|
|
// SetCommand sets the command token.
|
|
SetCommand(antlr.Token)
|
|
|
|
// SetPattern sets the pattern token.
|
|
SetPattern(antlr.Token)
|
|
|
|
// GetColumn returns the column rule contexts.
|
|
GetColumn() IUidContext
|
|
|
|
// SetColumn sets the column rule contexts.
|
|
SetColumn(IUidContext)
|
|
|
|
// Getter signatures
|
|
TableName() ITableNameContext
|
|
EXPLAIN() antlr.TerminalNode
|
|
DESCRIBE() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsSimpleDescribeStatementContext differentiates from other interfaces.
|
|
IsSimpleDescribeStatementContext()
|
|
}
|
|
|
|
type SimpleDescribeStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
command antlr.Token
|
|
column IUidContext
|
|
pattern antlr.Token
|
|
}
|
|
|
|
func NewEmptySimpleDescribeStatementContext() *SimpleDescribeStatementContext {
|
|
var p = new(SimpleDescribeStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleDescribeStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySimpleDescribeStatementContext(p *SimpleDescribeStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleDescribeStatement
|
|
}
|
|
|
|
func (*SimpleDescribeStatementContext) IsSimpleDescribeStatementContext() {}
|
|
|
|
func NewSimpleDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleDescribeStatementContext {
|
|
var p = new(SimpleDescribeStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_simpleDescribeStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SimpleDescribeStatementContext) GetCommand() antlr.Token { return s.command }
|
|
|
|
func (s *SimpleDescribeStatementContext) GetPattern() antlr.Token { return s.pattern }
|
|
|
|
func (s *SimpleDescribeStatementContext) SetCommand(v antlr.Token) { s.command = v }
|
|
|
|
func (s *SimpleDescribeStatementContext) SetPattern(v antlr.Token) { s.pattern = v }
|
|
|
|
func (s *SimpleDescribeStatementContext) GetColumn() IUidContext { return s.column }
|
|
|
|
func (s *SimpleDescribeStatementContext) SetColumn(v IUidContext) { s.column = v }
|
|
|
|
func (s *SimpleDescribeStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) EXPLAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPLAIN, 0)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) DESCRIBE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESCRIBE, 0)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleDescribeStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleDescribeStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleDescribeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleDescribeStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SimpleDescribeStatement() (localctx ISimpleDescribeStatementContext) {
|
|
localctx = NewSimpleDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 526, MySqlParserRULE_simpleDescribeStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6125)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SimpleDescribeStatementContext).command = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4611791571543654400) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SimpleDescribeStatementContext).command = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6126)
|
|
p.TableName()
|
|
}
|
|
p.SetState(6129)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6127)
|
|
|
|
var _x = p.Uid()
|
|
|
|
localctx.(*SimpleDescribeStatementContext).column = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(6128)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*SimpleDescribeStatementContext).pattern = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFullDescribeStatementContext is an interface to support dynamic dispatch.
|
|
type IFullDescribeStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCommand returns the command token.
|
|
GetCommand() antlr.Token
|
|
|
|
// GetFormatType returns the formatType token.
|
|
GetFormatType() antlr.Token
|
|
|
|
// GetFormatValue returns the formatValue token.
|
|
GetFormatValue() antlr.Token
|
|
|
|
// SetCommand sets the command token.
|
|
SetCommand(antlr.Token)
|
|
|
|
// SetFormatType sets the formatType token.
|
|
SetFormatType(antlr.Token)
|
|
|
|
// SetFormatValue sets the formatValue token.
|
|
SetFormatValue(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DescribeObjectClause() IDescribeObjectClauseContext
|
|
EXPLAIN() antlr.TerminalNode
|
|
DESCRIBE() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
EXTENDED() antlr.TerminalNode
|
|
PARTITIONS() antlr.TerminalNode
|
|
FORMAT() antlr.TerminalNode
|
|
TRADITIONAL() antlr.TerminalNode
|
|
JSON() antlr.TerminalNode
|
|
|
|
// IsFullDescribeStatementContext differentiates from other interfaces.
|
|
IsFullDescribeStatementContext()
|
|
}
|
|
|
|
type FullDescribeStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
command antlr.Token
|
|
formatType antlr.Token
|
|
formatValue antlr.Token
|
|
}
|
|
|
|
func NewEmptyFullDescribeStatementContext() *FullDescribeStatementContext {
|
|
var p = new(FullDescribeStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullDescribeStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFullDescribeStatementContext(p *FullDescribeStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullDescribeStatement
|
|
}
|
|
|
|
func (*FullDescribeStatementContext) IsFullDescribeStatementContext() {}
|
|
|
|
func NewFullDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullDescribeStatementContext {
|
|
var p = new(FullDescribeStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fullDescribeStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FullDescribeStatementContext) GetCommand() antlr.Token { return s.command }
|
|
|
|
func (s *FullDescribeStatementContext) GetFormatType() antlr.Token { return s.formatType }
|
|
|
|
func (s *FullDescribeStatementContext) GetFormatValue() antlr.Token { return s.formatValue }
|
|
|
|
func (s *FullDescribeStatementContext) SetCommand(v antlr.Token) { s.command = v }
|
|
|
|
func (s *FullDescribeStatementContext) SetFormatType(v antlr.Token) { s.formatType = v }
|
|
|
|
func (s *FullDescribeStatementContext) SetFormatValue(v antlr.Token) { s.formatValue = v }
|
|
|
|
func (s *FullDescribeStatementContext) DescribeObjectClause() IDescribeObjectClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDescribeObjectClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDescribeObjectClauseContext)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) EXPLAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPLAIN, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) DESCRIBE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESCRIBE, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) EXTENDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENDED, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) PARTITIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONS, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFORMAT, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) TRADITIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRADITIONAL, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) JSON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON, 0)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFullDescribeStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFullDescribeStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullDescribeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFullDescribeStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FullDescribeStatement() (localctx IFullDescribeStatementContext) {
|
|
localctx = NewFullDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 528, MySqlParserRULE_fullDescribeStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6131)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*FullDescribeStatementContext).command = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4611791571543654400) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*FullDescribeStatementContext).command = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6135)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserEXTENDED || _la == MySqlParserPARTITIONS || _la == MySqlParserFORMAT {
|
|
{
|
|
p.SetState(6132)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*FullDescribeStatementContext).formatType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserEXTENDED || _la == MySqlParserPARTITIONS || _la == MySqlParserFORMAT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*FullDescribeStatementContext).formatType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6133)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6134)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*FullDescribeStatementContext).formatValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserJSON || _la == MySqlParserTRADITIONAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*FullDescribeStatementContext).formatValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6137)
|
|
p.DescribeObjectClause()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHelpStatementContext is an interface to support dynamic dispatch.
|
|
type IHelpStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HELP() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsHelpStatementContext differentiates from other interfaces.
|
|
IsHelpStatementContext()
|
|
}
|
|
|
|
type HelpStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHelpStatementContext() *HelpStatementContext {
|
|
var p = new(HelpStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_helpStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHelpStatementContext(p *HelpStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_helpStatement
|
|
}
|
|
|
|
func (*HelpStatementContext) IsHelpStatementContext() {}
|
|
|
|
func NewHelpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HelpStatementContext {
|
|
var p = new(HelpStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_helpStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HelpStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HelpStatementContext) HELP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHELP, 0)
|
|
}
|
|
|
|
func (s *HelpStatementContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *HelpStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HelpStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HelpStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHelpStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HelpStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHelpStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *HelpStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHelpStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HelpStatement() (localctx IHelpStatementContext) {
|
|
localctx = NewHelpStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 530, MySqlParserRULE_helpStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6139)
|
|
p.Match(MySqlParserHELP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6140)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUseStatementContext is an interface to support dynamic dispatch.
|
|
type IUseStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
USE() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsUseStatementContext differentiates from other interfaces.
|
|
IsUseStatementContext()
|
|
}
|
|
|
|
type UseStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUseStatementContext() *UseStatementContext {
|
|
var p = new(UseStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_useStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUseStatementContext(p *UseStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_useStatement
|
|
}
|
|
|
|
func (*UseStatementContext) IsUseStatementContext() {}
|
|
|
|
func NewUseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseStatementContext {
|
|
var p = new(UseStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_useStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UseStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UseStatementContext) USE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSE, 0)
|
|
}
|
|
|
|
func (s *UseStatementContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *UseStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UseStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UseStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUseStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *UseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUseStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UseStatement() (localctx IUseStatementContext) {
|
|
localctx = NewUseStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 532, MySqlParserRULE_useStatement)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6142)
|
|
p.Match(MySqlParserUSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6143)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISignalStatementContext is an interface to support dynamic dispatch.
|
|
type ISignalStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SIGNAL() antlr.TerminalNode
|
|
ID() antlr.TerminalNode
|
|
REVERSE_QUOTE_ID() antlr.TerminalNode
|
|
SET() antlr.TerminalNode
|
|
AllSignalConditionInformation() []ISignalConditionInformationContext
|
|
SignalConditionInformation(i int) ISignalConditionInformationContext
|
|
SQLSTATE() antlr.TerminalNode
|
|
StringLiteral() IStringLiteralContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
VALUE() antlr.TerminalNode
|
|
|
|
// IsSignalStatementContext differentiates from other interfaces.
|
|
IsSignalStatementContext()
|
|
}
|
|
|
|
type SignalStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySignalStatementContext() *SignalStatementContext {
|
|
var p = new(SignalStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_signalStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptySignalStatementContext(p *SignalStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_signalStatement
|
|
}
|
|
|
|
func (*SignalStatementContext) IsSignalStatementContext() {}
|
|
|
|
func NewSignalStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignalStatementContext {
|
|
var p = new(SignalStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_signalStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SignalStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SignalStatementContext) SIGNAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIGNAL, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) REVERSE_QUOTE_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVERSE_QUOTE_ID, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) AllSignalConditionInformation() []ISignalConditionInformationContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISignalConditionInformationContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
tst[i] = t.(ISignalConditionInformationContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SignalStatementContext) SignalConditionInformation(i int) ISignalConditionInformationContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISignalConditionInformationContext)
|
|
}
|
|
|
|
func (s *SignalStatementContext) SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLSTATE, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *SignalStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SignalStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SignalStatementContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *SignalStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SignalStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SignalStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSignalStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SignalStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSignalStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *SignalStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSignalStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SignalStatement() (localctx ISignalStatementContext) {
|
|
localctx = NewSignalStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 534, MySqlParserRULE_signalStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6145)
|
|
p.Match(MySqlParserSIGNAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6153)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSQLSTATE:
|
|
{
|
|
p.SetState(6146)
|
|
p.Match(MySqlParserSQLSTATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6148)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVALUE {
|
|
{
|
|
p.SetState(6147)
|
|
p.Match(MySqlParserVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6150)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case MySqlParserID:
|
|
{
|
|
p.SetState(6151)
|
|
p.Match(MySqlParserID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREVERSE_QUOTE_ID:
|
|
{
|
|
p.SetState(6152)
|
|
p.Match(MySqlParserREVERSE_QUOTE_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(6164)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 899, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6155)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6156)
|
|
p.SignalConditionInformation()
|
|
}
|
|
p.SetState(6161)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6157)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6158)
|
|
p.SignalConditionInformation()
|
|
}
|
|
|
|
p.SetState(6163)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IResignalStatementContext is an interface to support dynamic dispatch.
|
|
type IResignalStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
RESIGNAL() antlr.TerminalNode
|
|
ID() antlr.TerminalNode
|
|
REVERSE_QUOTE_ID() antlr.TerminalNode
|
|
SET() antlr.TerminalNode
|
|
AllSignalConditionInformation() []ISignalConditionInformationContext
|
|
SignalConditionInformation(i int) ISignalConditionInformationContext
|
|
SQLSTATE() antlr.TerminalNode
|
|
StringLiteral() IStringLiteralContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
VALUE() antlr.TerminalNode
|
|
|
|
// IsResignalStatementContext differentiates from other interfaces.
|
|
IsResignalStatementContext()
|
|
}
|
|
|
|
type ResignalStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyResignalStatementContext() *ResignalStatementContext {
|
|
var p = new(ResignalStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resignalStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyResignalStatementContext(p *ResignalStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_resignalStatement
|
|
}
|
|
|
|
func (*ResignalStatementContext) IsResignalStatementContext() {}
|
|
|
|
func NewResignalStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResignalStatementContext {
|
|
var p = new(ResignalStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_resignalStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ResignalStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ResignalStatementContext) RESIGNAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESIGNAL, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) REVERSE_QUOTE_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVERSE_QUOTE_ID, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) AllSignalConditionInformation() []ISignalConditionInformationContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISignalConditionInformationContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
tst[i] = t.(ISignalConditionInformationContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ResignalStatementContext) SignalConditionInformation(i int) ISignalConditionInformationContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISignalConditionInformationContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISignalConditionInformationContext)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQLSTATE, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ResignalStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ResignalStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterResignalStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResignalStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitResignalStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *ResignalStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitResignalStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ResignalStatement() (localctx IResignalStatementContext) {
|
|
localctx = NewResignalStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 536, MySqlParserRULE_resignalStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6166)
|
|
p.Match(MySqlParserRESIGNAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6174)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSQLSTATE:
|
|
{
|
|
p.SetState(6167)
|
|
p.Match(MySqlParserSQLSTATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6169)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVALUE {
|
|
{
|
|
p.SetState(6168)
|
|
p.Match(MySqlParserVALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6171)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case MySqlParserID:
|
|
{
|
|
p.SetState(6172)
|
|
p.Match(MySqlParserID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREVERSE_QUOTE_ID:
|
|
{
|
|
p.SetState(6173)
|
|
p.Match(MySqlParserREVERSE_QUOTE_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI:
|
|
|
|
default:
|
|
}
|
|
p.SetState(6185)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 903, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6176)
|
|
p.Match(MySqlParserSET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6177)
|
|
p.SignalConditionInformation()
|
|
}
|
|
p.SetState(6182)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6178)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6179)
|
|
p.SignalConditionInformation()
|
|
}
|
|
|
|
p.SetState(6184)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISignalConditionInformationContext is an interface to support dynamic dispatch.
|
|
type ISignalConditionInformationContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
CLASS_ORIGIN() antlr.TerminalNode
|
|
SUBCLASS_ORIGIN() antlr.TerminalNode
|
|
MESSAGE_TEXT() antlr.TerminalNode
|
|
MYSQL_ERRNO() antlr.TerminalNode
|
|
CONSTRAINT_CATALOG() antlr.TerminalNode
|
|
CONSTRAINT_SCHEMA() antlr.TerminalNode
|
|
CONSTRAINT_NAME() antlr.TerminalNode
|
|
CATALOG_NAME() antlr.TerminalNode
|
|
SCHEMA_NAME() antlr.TerminalNode
|
|
TABLE_NAME() antlr.TerminalNode
|
|
COLUMN_NAME() antlr.TerminalNode
|
|
CURSOR_NAME() antlr.TerminalNode
|
|
StringLiteral() IStringLiteralContext
|
|
DECIMAL_LITERAL() antlr.TerminalNode
|
|
MysqlVariable() IMysqlVariableContext
|
|
SimpleId() ISimpleIdContext
|
|
|
|
// IsSignalConditionInformationContext differentiates from other interfaces.
|
|
IsSignalConditionInformationContext()
|
|
}
|
|
|
|
type SignalConditionInformationContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySignalConditionInformationContext() *SignalConditionInformationContext {
|
|
var p = new(SignalConditionInformationContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_signalConditionInformation
|
|
return p
|
|
}
|
|
|
|
func InitEmptySignalConditionInformationContext(p *SignalConditionInformationContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_signalConditionInformation
|
|
}
|
|
|
|
func (*SignalConditionInformationContext) IsSignalConditionInformationContext() {}
|
|
|
|
func NewSignalConditionInformationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignalConditionInformationContext {
|
|
var p = new(SignalConditionInformationContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_signalConditionInformation
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SignalConditionInformationContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) SUBCLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) MESSAGE_TEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMESSAGE_TEXT, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) MYSQL_ERRNO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL_ERRNO, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CONSTRAINT_CATALOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CONSTRAINT_SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CONSTRAINT_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CATALOG_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCATALOG_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) SCHEMA_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) TABLE_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) COLUMN_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) CURSOR_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURSOR_NAME, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) DECIMAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECIMAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) MysqlVariable() IMysqlVariableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMysqlVariableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMysqlVariableContext)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) SimpleId() ISimpleIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleIdContext)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSignalConditionInformation(s)
|
|
}
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSignalConditionInformation(s)
|
|
}
|
|
}
|
|
|
|
func (s *SignalConditionInformationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSignalConditionInformation(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SignalConditionInformation() (localctx ISignalConditionInformationContext) {
|
|
localctx = NewSignalConditionInformationContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 538, MySqlParserRULE_signalConditionInformation)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6187)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&272105729) != 0) || _la == MySqlParserMESSAGE_TEXT || _la == MySqlParserMYSQL_ERRNO || _la == MySqlParserSUBCLASS_ORIGIN || _la == MySqlParserTABLE_NAME || _la == MySqlParserCATALOG_NAME || _la == MySqlParserSCHEMA_NAME) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6188)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6193)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTART_NATIONAL_STRING_LITERAL, MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
|
|
{
|
|
p.SetState(6189)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case MySqlParserDECIMAL_LITERAL:
|
|
{
|
|
p.SetState(6190)
|
|
p.Match(MySqlParserDECIMAL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID:
|
|
{
|
|
p.SetState(6191)
|
|
p.MysqlVariable()
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID:
|
|
{
|
|
p.SetState(6192)
|
|
p.SimpleId()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWithStatementContext is an interface to support dynamic dispatch.
|
|
type IWithStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WITH() antlr.TerminalNode
|
|
AllCommonTableExpressions() []ICommonTableExpressionsContext
|
|
CommonTableExpressions(i int) ICommonTableExpressionsContext
|
|
RECURSIVE() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsWithStatementContext differentiates from other interfaces.
|
|
IsWithStatementContext()
|
|
}
|
|
|
|
type WithStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWithStatementContext() *WithStatementContext {
|
|
var p = new(WithStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_withStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWithStatementContext(p *WithStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_withStatement
|
|
}
|
|
|
|
func (*WithStatementContext) IsWithStatementContext() {}
|
|
|
|
func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext {
|
|
var p = new(WithStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_withStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WithStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WithStatementContext) WITH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITH, 0)
|
|
}
|
|
|
|
func (s *WithStatementContext) AllCommonTableExpressions() []ICommonTableExpressionsContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICommonTableExpressionsContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICommonTableExpressionsContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICommonTableExpressionsContext); ok {
|
|
tst[i] = t.(ICommonTableExpressionsContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *WithStatementContext) CommonTableExpressions(i int) ICommonTableExpressionsContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICommonTableExpressionsContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICommonTableExpressionsContext)
|
|
}
|
|
|
|
func (s *WithStatementContext) RECURSIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRECURSIVE, 0)
|
|
}
|
|
|
|
func (s *WithStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *WithStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *WithStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WithStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WithStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWithStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWithStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *WithStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWithStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WithStatement() (localctx IWithStatementContext) {
|
|
localctx = NewWithStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 540, MySqlParserRULE_withStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6195)
|
|
p.Match(MySqlParserWITH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6197)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 905, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6196)
|
|
p.Match(MySqlParserRECURSIVE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6199)
|
|
p.CommonTableExpressions()
|
|
}
|
|
p.SetState(6204)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6200)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6201)
|
|
p.CommonTableExpressions()
|
|
}
|
|
|
|
p.SetState(6206)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableStatementContext is an interface to support dynamic dispatch.
|
|
type ITableStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
TABLE() antlr.TerminalNode
|
|
TableName() ITableNameContext
|
|
OrderByClause() IOrderByClauseContext
|
|
LimitClause() ILimitClauseContext
|
|
|
|
// IsTableStatementContext differentiates from other interfaces.
|
|
IsTableStatementContext()
|
|
}
|
|
|
|
type TableStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableStatementContext() *TableStatementContext {
|
|
var p = new(TableStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableStatementContext(p *TableStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableStatement
|
|
}
|
|
|
|
func (*TableStatementContext) IsTableStatementContext() {}
|
|
|
|
func NewTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableStatementContext {
|
|
var p = new(TableStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableStatementContext) TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE, 0)
|
|
}
|
|
|
|
func (s *TableStatementContext) TableName() ITableNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *TableStatementContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *TableStatementContext) LimitClause() ILimitClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILimitClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILimitClauseContext)
|
|
}
|
|
|
|
func (s *TableStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TableStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableStatement() (localctx ITableStatementContext) {
|
|
localctx = NewTableStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 542, MySqlParserRULE_tableStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6207)
|
|
p.Match(MySqlParserTABLE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6208)
|
|
p.TableName()
|
|
}
|
|
p.SetState(6210)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserORDER {
|
|
{
|
|
p.SetState(6209)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(6213)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLIMIT {
|
|
{
|
|
p.SetState(6212)
|
|
p.LimitClause()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDiagnosticsStatementContext is an interface to support dynamic dispatch.
|
|
type IDiagnosticsStatementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
GET() antlr.TerminalNode
|
|
DIAGNOSTICS() antlr.TerminalNode
|
|
CURRENT() antlr.TerminalNode
|
|
STACKED() antlr.TerminalNode
|
|
AllVariableClause() []IVariableClauseContext
|
|
VariableClause(i int) IVariableClauseContext
|
|
AllEQUAL_SYMBOL() []antlr.TerminalNode
|
|
EQUAL_SYMBOL(i int) antlr.TerminalNode
|
|
CONDITION() antlr.TerminalNode
|
|
AllDiagnosticsConditionInformationName() []IDiagnosticsConditionInformationNameContext
|
|
DiagnosticsConditionInformationName(i int) IDiagnosticsConditionInformationNameContext
|
|
AllNUMBER() []antlr.TerminalNode
|
|
NUMBER(i int) antlr.TerminalNode
|
|
AllROW_COUNT() []antlr.TerminalNode
|
|
ROW_COUNT(i int) antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsDiagnosticsStatementContext differentiates from other interfaces.
|
|
IsDiagnosticsStatementContext()
|
|
}
|
|
|
|
type DiagnosticsStatementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDiagnosticsStatementContext() *DiagnosticsStatementContext {
|
|
var p = new(DiagnosticsStatementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsStatement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDiagnosticsStatementContext(p *DiagnosticsStatementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsStatement
|
|
}
|
|
|
|
func (*DiagnosticsStatementContext) IsDiagnosticsStatementContext() {}
|
|
|
|
func NewDiagnosticsStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiagnosticsStatementContext {
|
|
var p = new(DiagnosticsStatementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsStatement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DiagnosticsStatementContext) GET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGET, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) DIAGNOSTICS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIAGNOSTICS, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) CURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) STACKED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTACKED, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllVariableClause() []IVariableClauseContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IVariableClauseContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IVariableClauseContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IVariableClauseContext); ok {
|
|
tst[i] = t.(IVariableClauseContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) VariableClause(i int) IVariableClauseContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IVariableClauseContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IVariableClauseContext)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllEQUAL_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserEQUAL_SYMBOL)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) EQUAL_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, i)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) CONDITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONDITION, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllDiagnosticsConditionInformationName() []IDiagnosticsConditionInformationNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDiagnosticsConditionInformationNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok {
|
|
tst[i] = t.(IDiagnosticsConditionInformationNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) DiagnosticsConditionInformationName(i int) IDiagnosticsConditionInformationNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDiagnosticsConditionInformationNameContext)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllNUMBER() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserNUMBER)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) NUMBER(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMBER, i)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllROW_COUNT() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserROW_COUNT)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) ROW_COUNT(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_COUNT, i)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDiagnosticsStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDiagnosticsStatement(s)
|
|
}
|
|
}
|
|
|
|
func (s *DiagnosticsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDiagnosticsStatement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DiagnosticsStatement() (localctx IDiagnosticsStatementContext) {
|
|
localctx = NewDiagnosticsStatementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 544, MySqlParserRULE_diagnosticsStatement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6215)
|
|
p.Match(MySqlParserGET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6217)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCURRENT || _la == MySqlParserSTACKED {
|
|
{
|
|
p.SetState(6216)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCURRENT || _la == MySqlParserSTACKED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6219)
|
|
p.Match(MySqlParserDIAGNOSTICS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6251)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 913, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6220)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(6221)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6222)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6230)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6223)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6224)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(6225)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6226)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
p.SetState(6232)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6233)
|
|
p.Match(MySqlParserCONDITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6236)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
{
|
|
p.SetState(6234)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserAT_SIGN, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID, MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID:
|
|
{
|
|
p.SetState(6235)
|
|
p.VariableClause()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6238)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(6239)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6240)
|
|
p.DiagnosticsConditionInformationName()
|
|
}
|
|
p.SetState(6248)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6241)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6242)
|
|
p.VariableClause()
|
|
}
|
|
{
|
|
p.SetState(6243)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6244)
|
|
p.DiagnosticsConditionInformationName()
|
|
}
|
|
|
|
p.SetState(6250)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDiagnosticsConditionInformationNameContext is an interface to support dynamic dispatch.
|
|
type IDiagnosticsConditionInformationNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CLASS_ORIGIN() antlr.TerminalNode
|
|
SUBCLASS_ORIGIN() antlr.TerminalNode
|
|
RETURNED_SQLSTATE() antlr.TerminalNode
|
|
MESSAGE_TEXT() antlr.TerminalNode
|
|
MYSQL_ERRNO() antlr.TerminalNode
|
|
CONSTRAINT_CATALOG() antlr.TerminalNode
|
|
CONSTRAINT_SCHEMA() antlr.TerminalNode
|
|
CONSTRAINT_NAME() antlr.TerminalNode
|
|
CATALOG_NAME() antlr.TerminalNode
|
|
SCHEMA_NAME() antlr.TerminalNode
|
|
TABLE_NAME() antlr.TerminalNode
|
|
COLUMN_NAME() antlr.TerminalNode
|
|
CURSOR_NAME() antlr.TerminalNode
|
|
|
|
// IsDiagnosticsConditionInformationNameContext differentiates from other interfaces.
|
|
IsDiagnosticsConditionInformationNameContext()
|
|
}
|
|
|
|
type DiagnosticsConditionInformationNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDiagnosticsConditionInformationNameContext() *DiagnosticsConditionInformationNameContext {
|
|
var p = new(DiagnosticsConditionInformationNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDiagnosticsConditionInformationNameContext(p *DiagnosticsConditionInformationNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName
|
|
}
|
|
|
|
func (*DiagnosticsConditionInformationNameContext) IsDiagnosticsConditionInformationNameContext() {}
|
|
|
|
func NewDiagnosticsConditionInformationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiagnosticsConditionInformationNameContext {
|
|
var p = new(DiagnosticsConditionInformationNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) SUBCLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) RETURNED_SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNED_SQLSTATE, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) MESSAGE_TEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMESSAGE_TEXT, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) MYSQL_ERRNO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL_ERRNO, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_CATALOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CATALOG_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCATALOG_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) SCHEMA_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) TABLE_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) COLUMN_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) CURSOR_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURSOR_NAME, 0)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDiagnosticsConditionInformationName(s)
|
|
}
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDiagnosticsConditionInformationName(s)
|
|
}
|
|
}
|
|
|
|
func (s *DiagnosticsConditionInformationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDiagnosticsConditionInformationName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DiagnosticsConditionInformationName() (localctx IDiagnosticsConditionInformationNameContext) {
|
|
localctx = NewDiagnosticsConditionInformationNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 546, MySqlParserRULE_diagnosticsConditionInformationName)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6253)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&272105729) != 0) || _la == MySqlParserMESSAGE_TEXT || _la == MySqlParserMYSQL_ERRNO || ((int64((_la-592)) & ^0x3f) == 0 && ((int64(1)<<(_la-592))&18155135997837313) != 0) || _la == MySqlParserCATALOG_NAME || _la == MySqlParserSCHEMA_NAME) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDescribeObjectClauseContext is an interface to support dynamic dispatch.
|
|
type IDescribeObjectClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsDescribeObjectClauseContext differentiates from other interfaces.
|
|
IsDescribeObjectClauseContext()
|
|
}
|
|
|
|
type DescribeObjectClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDescribeObjectClauseContext() *DescribeObjectClauseContext {
|
|
var p = new(DescribeObjectClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_describeObjectClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDescribeObjectClauseContext(p *DescribeObjectClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_describeObjectClause
|
|
}
|
|
|
|
func (*DescribeObjectClauseContext) IsDescribeObjectClauseContext() {}
|
|
|
|
func NewDescribeObjectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescribeObjectClauseContext {
|
|
var p = new(DescribeObjectClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_describeObjectClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DescribeObjectClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DescribeObjectClauseContext) CopyAll(ctx *DescribeObjectClauseContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *DescribeObjectClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DescribeObjectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type DescribeStatementsContext struct {
|
|
DescribeObjectClauseContext
|
|
}
|
|
|
|
func NewDescribeStatementsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeStatementsContext {
|
|
var p = new(DescribeStatementsContext)
|
|
|
|
InitEmptyDescribeObjectClauseContext(&p.DescribeObjectClauseContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DescribeObjectClauseContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) DeleteStatement() IDeleteStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDeleteStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDeleteStatementContext)
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) InsertStatement() IInsertStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IInsertStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IInsertStatementContext)
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) ReplaceStatement() IReplaceStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IReplaceStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IReplaceStatementContext)
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) UpdateStatement() IUpdateStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUpdateStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUpdateStatementContext)
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDescribeStatements(s)
|
|
}
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDescribeStatements(s)
|
|
}
|
|
}
|
|
|
|
func (s *DescribeStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDescribeStatements(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DescribeConnectionContext struct {
|
|
DescribeObjectClauseContext
|
|
}
|
|
|
|
func NewDescribeConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeConnectionContext {
|
|
var p = new(DescribeConnectionContext)
|
|
|
|
InitEmptyDescribeObjectClauseContext(&p.DescribeObjectClauseContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DescribeObjectClauseContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) CONNECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION, 0)
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDescribeConnection(s)
|
|
}
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDescribeConnection(s)
|
|
}
|
|
}
|
|
|
|
func (s *DescribeConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDescribeConnection(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DescribeObjectClause() (localctx IDescribeObjectClauseContext) {
|
|
localctx = NewDescribeObjectClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 548, MySqlParserRULE_describeObjectClause)
|
|
p.SetState(6265)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDELETE, MySqlParserINSERT, MySqlParserREPLACE, MySqlParserSELECT, MySqlParserUPDATE, MySqlParserLR_BRACKET:
|
|
localctx = NewDescribeStatementsContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6260)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSELECT, MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(6255)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case MySqlParserDELETE:
|
|
{
|
|
p.SetState(6256)
|
|
p.DeleteStatement()
|
|
}
|
|
|
|
case MySqlParserINSERT:
|
|
{
|
|
p.SetState(6257)
|
|
p.InsertStatement()
|
|
}
|
|
|
|
case MySqlParserREPLACE:
|
|
{
|
|
p.SetState(6258)
|
|
p.ReplaceStatement()
|
|
}
|
|
|
|
case MySqlParserUPDATE:
|
|
{
|
|
p.SetState(6259)
|
|
p.UpdateStatement()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserFOR:
|
|
localctx = NewDescribeConnectionContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6262)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6263)
|
|
p.Match(MySqlParserCONNECTION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6264)
|
|
p.Uid()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFullIdContext is an interface to support dynamic dispatch.
|
|
type IFullIdContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
DOT_ID() antlr.TerminalNode
|
|
DOT() antlr.TerminalNode
|
|
|
|
// IsFullIdContext differentiates from other interfaces.
|
|
IsFullIdContext()
|
|
}
|
|
|
|
type FullIdContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFullIdContext() *FullIdContext {
|
|
var p = new(FullIdContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullId
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFullIdContext(p *FullIdContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullId
|
|
}
|
|
|
|
func (*FullIdContext) IsFullIdContext() {}
|
|
|
|
func NewFullIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullIdContext {
|
|
var p = new(FullIdContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fullId
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FullIdContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FullIdContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FullIdContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *FullIdContext) DOT_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT_ID, 0)
|
|
}
|
|
|
|
func (s *FullIdContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *FullIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FullIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FullIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFullId(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFullId(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFullId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FullId() (localctx IFullIdContext) {
|
|
localctx = NewFullIdContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 550, MySqlParserRULE_fullId)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6267)
|
|
p.Uid()
|
|
}
|
|
p.SetState(6271)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 916, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6268)
|
|
p.Match(MySqlParserDOT_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 916, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(6269)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6270)
|
|
p.Uid()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITableNameContext is an interface to support dynamic dispatch.
|
|
type ITableNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FullId() IFullIdContext
|
|
|
|
// IsTableNameContext differentiates from other interfaces.
|
|
IsTableNameContext()
|
|
}
|
|
|
|
type TableNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTableNameContext() *TableNameContext {
|
|
var p = new(TableNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTableNameContext(p *TableNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tableName
|
|
}
|
|
|
|
func (*TableNameContext) IsTableNameContext() {}
|
|
|
|
func NewTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableNameContext {
|
|
var p = new(TableNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tableName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TableNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TableNameContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *TableNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTableName(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTableName(s)
|
|
}
|
|
}
|
|
|
|
func (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTableName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TableName() (localctx ITableNameContext) {
|
|
localctx = NewTableNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 552, MySqlParserRULE_tableName)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6273)
|
|
p.FullId()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRoleNameContext is an interface to support dynamic dispatch.
|
|
type IRoleNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
UserName() IUserNameContext
|
|
Uid() IUidContext
|
|
|
|
// IsRoleNameContext differentiates from other interfaces.
|
|
IsRoleNameContext()
|
|
}
|
|
|
|
type RoleNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyRoleNameContext() *RoleNameContext {
|
|
var p = new(RoleNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_roleName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRoleNameContext(p *RoleNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_roleName
|
|
}
|
|
|
|
func (*RoleNameContext) IsRoleNameContext() {}
|
|
|
|
func NewRoleNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleNameContext {
|
|
var p = new(RoleNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_roleName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RoleNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RoleNameContext) UserName() IUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUserNameContext)
|
|
}
|
|
|
|
func (s *RoleNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *RoleNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RoleNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RoleNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRoleName(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRoleName(s)
|
|
}
|
|
}
|
|
|
|
func (s *RoleNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRoleName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) RoleName() (localctx IRoleNameContext) {
|
|
localctx = NewRoleNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 554, MySqlParserRULE_roleName)
|
|
p.SetState(6277)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 917, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6275)
|
|
p.UserName()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6276)
|
|
p.Uid()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFullColumnNameContext is an interface to support dynamic dispatch.
|
|
type IFullColumnNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
AllDottedId() []IDottedIdContext
|
|
DottedId(i int) IDottedIdContext
|
|
|
|
// IsFullColumnNameContext differentiates from other interfaces.
|
|
IsFullColumnNameContext()
|
|
}
|
|
|
|
type FullColumnNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFullColumnNameContext() *FullColumnNameContext {
|
|
var p = new(FullColumnNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullColumnName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFullColumnNameContext(p *FullColumnNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullColumnName
|
|
}
|
|
|
|
func (*FullColumnNameContext) IsFullColumnNameContext() {}
|
|
|
|
func NewFullColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullColumnNameContext {
|
|
var p = new(FullColumnNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fullColumnName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FullColumnNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FullColumnNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *FullColumnNameContext) AllDottedId() []IDottedIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDottedIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDottedIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDottedIdContext); ok {
|
|
tst[i] = t.(IDottedIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FullColumnNameContext) DottedId(i int) IDottedIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDottedIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDottedIdContext)
|
|
}
|
|
|
|
func (s *FullColumnNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FullColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FullColumnNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFullColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFullColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFullColumnName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FullColumnName() (localctx IFullColumnNameContext) {
|
|
localctx = NewFullColumnNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 556, MySqlParserRULE_fullColumnName)
|
|
p.SetState(6293)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 922, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6279)
|
|
p.Uid()
|
|
}
|
|
p.SetState(6284)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 919, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6280)
|
|
p.DottedId()
|
|
}
|
|
p.SetState(6282)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6281)
|
|
p.DottedId()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(6287)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 920, p.GetParserRuleContext()) == 1 {
|
|
p.SetState(6286)
|
|
p.MatchWildcard()
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6289)
|
|
p.DottedId()
|
|
}
|
|
p.SetState(6291)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6290)
|
|
p.DottedId()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexColumnNameContext is an interface to support dynamic dispatch.
|
|
type IIndexColumnNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetSortType returns the sortType token.
|
|
GetSortType() antlr.Token
|
|
|
|
// SetSortType sets the sortType token.
|
|
SetSortType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
Expression() IExpressionContext
|
|
Uid() IUidContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
ASC() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
|
|
// IsIndexColumnNameContext differentiates from other interfaces.
|
|
IsIndexColumnNameContext()
|
|
}
|
|
|
|
type IndexColumnNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
sortType antlr.Token
|
|
}
|
|
|
|
func NewEmptyIndexColumnNameContext() *IndexColumnNameContext {
|
|
var p = new(IndexColumnNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexColumnNameContext(p *IndexColumnNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnName
|
|
}
|
|
|
|
func (*IndexColumnNameContext) IsIndexColumnNameContext() {}
|
|
|
|
func NewIndexColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNameContext {
|
|
var p = new(IndexColumnNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexColumnName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexColumnNameContext) GetSortType() antlr.Token { return s.sortType }
|
|
|
|
func (s *IndexColumnNameContext) SetSortType(v antlr.Token) { s.sortType = v }
|
|
|
|
func (s *IndexColumnNameContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) ASC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASC, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexColumnName(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexColumnName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexColumnName() (localctx IIndexColumnNameContext) {
|
|
localctx = NewIndexColumnNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 558, MySqlParserRULE_indexColumnName)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6306)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 925, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.SetState(6297)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 923, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6295)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6296)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(6303)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(6299)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6300)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6301)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6305)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(6309)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserASC || _la == MySqlParserDESC {
|
|
{
|
|
p.SetState(6308)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*IndexColumnNameContext).sortType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserASC || _la == MySqlParserDESC) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*IndexColumnNameContext).sortType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISimpleUserNameContext is an interface to support dynamic dispatch.
|
|
type ISimpleUserNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
ID() antlr.TerminalNode
|
|
ADMIN() antlr.TerminalNode
|
|
KeywordsCanBeId() IKeywordsCanBeIdContext
|
|
|
|
// IsSimpleUserNameContext differentiates from other interfaces.
|
|
IsSimpleUserNameContext()
|
|
}
|
|
|
|
type SimpleUserNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySimpleUserNameContext() *SimpleUserNameContext {
|
|
var p = new(SimpleUserNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleUserName
|
|
return p
|
|
}
|
|
|
|
func InitEmptySimpleUserNameContext(p *SimpleUserNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleUserName
|
|
}
|
|
|
|
func (*SimpleUserNameContext) IsSimpleUserNameContext() {}
|
|
|
|
func NewSimpleUserNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleUserNameContext {
|
|
var p = new(SimpleUserNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_simpleUserName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SimpleUserNameContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADMIN, 0)
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) KeywordsCanBeId() IKeywordsCanBeIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IKeywordsCanBeIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IKeywordsCanBeIdContext)
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleUserName(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleUserName(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleUserNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleUserName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SimpleUserName() (localctx ISimpleUserNameContext) {
|
|
localctx = NewSimpleUserNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 560, MySqlParserRULE_simpleUserName)
|
|
p.SetState(6315)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6311)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6312)
|
|
p.Match(MySqlParserID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6313)
|
|
p.Match(MySqlParserADMIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6314)
|
|
p.KeywordsCanBeId()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHostNameContext is an interface to support dynamic dispatch.
|
|
type IHostNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LOCAL_ID() antlr.TerminalNode
|
|
HOST_IP_ADDRESS() antlr.TerminalNode
|
|
AT_SIGN() antlr.TerminalNode
|
|
|
|
// IsHostNameContext differentiates from other interfaces.
|
|
IsHostNameContext()
|
|
}
|
|
|
|
type HostNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHostNameContext() *HostNameContext {
|
|
var p = new(HostNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_hostName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHostNameContext(p *HostNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_hostName
|
|
}
|
|
|
|
func (*HostNameContext) IsHostNameContext() {}
|
|
|
|
func NewHostNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HostNameContext {
|
|
var p = new(HostNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_hostName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HostNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HostNameContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *HostNameContext) HOST_IP_ADDRESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOST_IP_ADDRESS, 0)
|
|
}
|
|
|
|
func (s *HostNameContext) AT_SIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAT_SIGN, 0)
|
|
}
|
|
|
|
func (s *HostNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HostNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HostNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHostName(s)
|
|
}
|
|
}
|
|
|
|
func (s *HostNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHostName(s)
|
|
}
|
|
}
|
|
|
|
func (s *HostNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHostName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HostName() (localctx IHostNameContext) {
|
|
localctx = NewHostNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 562, MySqlParserRULE_hostName)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6317)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-1137)) & ^0x3f) == 0 && ((int64(1)<<(_la-1137))&6291457) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserNameContext is an interface to support dynamic dispatch.
|
|
type IUserNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SimpleUserName() ISimpleUserNameContext
|
|
HostName() IHostNameContext
|
|
CurrentUserExpression() ICurrentUserExpressionContext
|
|
|
|
// IsUserNameContext differentiates from other interfaces.
|
|
IsUserNameContext()
|
|
}
|
|
|
|
type UserNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUserNameContext() *UserNameContext {
|
|
var p = new(UserNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserNameContext(p *UserNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userName
|
|
}
|
|
|
|
func (*UserNameContext) IsUserNameContext() {}
|
|
|
|
func NewUserNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserNameContext {
|
|
var p = new(UserNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserNameContext) SimpleUserName() ISimpleUserNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleUserNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleUserNameContext)
|
|
}
|
|
|
|
func (s *UserNameContext) HostName() IHostNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHostNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHostNameContext)
|
|
}
|
|
|
|
func (s *UserNameContext) CurrentUserExpression() ICurrentUserExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICurrentUserExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICurrentUserExpressionContext)
|
|
}
|
|
|
|
func (s *UserNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserName(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserName(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserName() (localctx IUserNameContext) {
|
|
localctx = NewUserNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 564, MySqlParserRULE_userName)
|
|
p.SetState(6324)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 928, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6319)
|
|
p.SimpleUserName()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6320)
|
|
p.SimpleUserName()
|
|
}
|
|
{
|
|
p.SetState(6321)
|
|
p.HostName()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6323)
|
|
p.CurrentUserExpression()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IMysqlVariableContext is an interface to support dynamic dispatch.
|
|
type IMysqlVariableContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LOCAL_ID() antlr.TerminalNode
|
|
GLOBAL_ID() antlr.TerminalNode
|
|
|
|
// IsMysqlVariableContext differentiates from other interfaces.
|
|
IsMysqlVariableContext()
|
|
}
|
|
|
|
type MysqlVariableContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyMysqlVariableContext() *MysqlVariableContext {
|
|
var p = new(MysqlVariableContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_mysqlVariable
|
|
return p
|
|
}
|
|
|
|
func InitEmptyMysqlVariableContext(p *MysqlVariableContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_mysqlVariable
|
|
}
|
|
|
|
func (*MysqlVariableContext) IsMysqlVariableContext() {}
|
|
|
|
func NewMysqlVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MysqlVariableContext {
|
|
var p = new(MysqlVariableContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_mysqlVariable
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MysqlVariableContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *MysqlVariableContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *MysqlVariableContext) GLOBAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL_ID, 0)
|
|
}
|
|
|
|
func (s *MysqlVariableContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MysqlVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *MysqlVariableContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMysqlVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *MysqlVariableContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMysqlVariable(s)
|
|
}
|
|
}
|
|
|
|
func (s *MysqlVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMysqlVariable(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) MysqlVariable() (localctx IMysqlVariableContext) {
|
|
localctx = NewMysqlVariableContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 566, MySqlParserRULE_mysqlVariable)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6326)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLOCAL_ID || _la == MySqlParserGLOBAL_ID) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICharsetNameContext is an interface to support dynamic dispatch.
|
|
type ICharsetNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BINARY() antlr.TerminalNode
|
|
CharsetNameBase() ICharsetNameBaseContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode
|
|
|
|
// IsCharsetNameContext differentiates from other interfaces.
|
|
IsCharsetNameContext()
|
|
}
|
|
|
|
type CharsetNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCharsetNameContext() *CharsetNameContext {
|
|
var p = new(CharsetNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charsetName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCharsetNameContext(p *CharsetNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charsetName
|
|
}
|
|
|
|
func (*CharsetNameContext) IsCharsetNameContext() {}
|
|
|
|
func NewCharsetNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameContext {
|
|
var p = new(CharsetNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_charsetName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CharsetNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CharsetNameContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *CharsetNameContext) CharsetNameBase() ICharsetNameBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameBaseContext)
|
|
}
|
|
|
|
func (s *CharsetNameContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CharsetNameContext) CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARSET_REVERSE_QOUTE_STRING, 0)
|
|
}
|
|
|
|
func (s *CharsetNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CharsetNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CharsetNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCharsetName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharsetNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCharsetName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharsetNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCharsetName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CharsetName() (localctx ICharsetNameContext) {
|
|
localctx = NewCharsetNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 568, MySqlParserRULE_charsetName)
|
|
p.SetState(6332)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 929, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6328)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6329)
|
|
p.CharsetNameBase()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6330)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6331)
|
|
p.Match(MySqlParserCHARSET_REVERSE_QOUTE_STRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICollationNameContext is an interface to support dynamic dispatch.
|
|
type ICollationNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsCollationNameContext differentiates from other interfaces.
|
|
IsCollationNameContext()
|
|
}
|
|
|
|
type CollationNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCollationNameContext() *CollationNameContext {
|
|
var p = new(CollationNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_collationName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCollationNameContext(p *CollationNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_collationName
|
|
}
|
|
|
|
func (*CollationNameContext) IsCollationNameContext() {}
|
|
|
|
func NewCollationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollationNameContext {
|
|
var p = new(CollationNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_collationName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CollationNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CollationNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *CollationNameContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *CollationNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CollationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CollationNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCollationName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollationNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCollationName(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCollationName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CollationName() (localctx ICollationNameContext) {
|
|
localctx = NewCollationNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 570, MySqlParserRULE_collationName)
|
|
p.SetState(6336)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 930, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6334)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6335)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IEngineNameContext is an interface to support dynamic dispatch.
|
|
type IEngineNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EngineNameBase() IEngineNameBaseContext
|
|
ID() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsEngineNameContext differentiates from other interfaces.
|
|
IsEngineNameContext()
|
|
}
|
|
|
|
type EngineNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyEngineNameContext() *EngineNameContext {
|
|
var p = new(EngineNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_engineName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyEngineNameContext(p *EngineNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_engineName
|
|
}
|
|
|
|
func (*EngineNameContext) IsEngineNameContext() {}
|
|
|
|
func NewEngineNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EngineNameContext {
|
|
var p = new(EngineNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_engineName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *EngineNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *EngineNameContext) EngineNameBase() IEngineNameBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameBaseContext)
|
|
}
|
|
|
|
func (s *EngineNameContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *EngineNameContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *EngineNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *EngineNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *EngineNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterEngineName(s)
|
|
}
|
|
}
|
|
|
|
func (s *EngineNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitEngineName(s)
|
|
}
|
|
}
|
|
|
|
func (s *EngineNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitEngineName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) EngineName() (localctx IEngineNameContext) {
|
|
localctx = NewEngineNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 572, MySqlParserRULE_engineName)
|
|
p.SetState(6341)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCONNECT, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6338)
|
|
p.EngineNameBase()
|
|
}
|
|
|
|
case MySqlParserID:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6339)
|
|
p.Match(MySqlParserID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTRING_LITERAL:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6340)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IEngineNameBaseContext is an interface to support dynamic dispatch.
|
|
type IEngineNameBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ARCHIVE() antlr.TerminalNode
|
|
BLACKHOLE() antlr.TerminalNode
|
|
CONNECT() antlr.TerminalNode
|
|
CSV() antlr.TerminalNode
|
|
FEDERATED() antlr.TerminalNode
|
|
INNODB() antlr.TerminalNode
|
|
MEMORY() antlr.TerminalNode
|
|
MRG_MYISAM() antlr.TerminalNode
|
|
MYISAM() antlr.TerminalNode
|
|
NDB() antlr.TerminalNode
|
|
NDBCLUSTER() antlr.TerminalNode
|
|
PERFORMANCE_SCHEMA() antlr.TerminalNode
|
|
TOKUDB() antlr.TerminalNode
|
|
|
|
// IsEngineNameBaseContext differentiates from other interfaces.
|
|
IsEngineNameBaseContext()
|
|
}
|
|
|
|
type EngineNameBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyEngineNameBaseContext() *EngineNameBaseContext {
|
|
var p = new(EngineNameBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_engineNameBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyEngineNameBaseContext(p *EngineNameBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_engineNameBase
|
|
}
|
|
|
|
func (*EngineNameBaseContext) IsEngineNameBaseContext() {}
|
|
|
|
func NewEngineNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EngineNameBaseContext {
|
|
var p = new(EngineNameBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_engineNameBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *EngineNameBaseContext) ARCHIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserARCHIVE, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) BLACKHOLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBLACKHOLE, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) CONNECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECT, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) CSV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCSV, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) FEDERATED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFEDERATED, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) INNODB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNODB, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) MEMORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMORY, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) MRG_MYISAM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMRG_MYISAM, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) MYISAM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYISAM, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) NDB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNDB, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) NDBCLUSTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNDBCLUSTER, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) PERFORMANCE_SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERFORMANCE_SCHEMA, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) TOKUDB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTOKUDB, 0)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterEngineNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitEngineNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *EngineNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitEngineNameBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) EngineNameBase() (localctx IEngineNameBaseContext) {
|
|
localctx = NewEngineNameBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 574, MySqlParserRULE_engineNameBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6343)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCONNECT || ((int64((_la-787)) & ^0x3f) == 0 && ((int64(1)<<(_la-787))&4095) != 0)) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUuidSetContext is an interface to support dynamic dispatch.
|
|
type IUuidSetContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllDecimalLiteral() []IDecimalLiteralContext
|
|
DecimalLiteral(i int) IDecimalLiteralContext
|
|
AllMINUS() []antlr.TerminalNode
|
|
MINUS(i int) antlr.TerminalNode
|
|
AllCOLON_SYMB() []antlr.TerminalNode
|
|
COLON_SYMB(i int) antlr.TerminalNode
|
|
|
|
// IsUuidSetContext differentiates from other interfaces.
|
|
IsUuidSetContext()
|
|
}
|
|
|
|
type UuidSetContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUuidSetContext() *UuidSetContext {
|
|
var p = new(UuidSetContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uuidSet
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUuidSetContext(p *UuidSetContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uuidSet
|
|
}
|
|
|
|
func (*UuidSetContext) IsUuidSetContext() {}
|
|
|
|
func NewUuidSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UuidSetContext {
|
|
var p = new(UuidSetContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_uuidSet
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UuidSetContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UuidSetContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UuidSetContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *UuidSetContext) AllMINUS() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserMINUS)
|
|
}
|
|
|
|
func (s *UuidSetContext) MINUS(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, i)
|
|
}
|
|
|
|
func (s *UuidSetContext) AllCOLON_SYMB() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOLON_SYMB)
|
|
}
|
|
|
|
func (s *UuidSetContext) COLON_SYMB(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLON_SYMB, i)
|
|
}
|
|
|
|
func (s *UuidSetContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UuidSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UuidSetContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUuidSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *UuidSetContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUuidSet(s)
|
|
}
|
|
}
|
|
|
|
func (s *UuidSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUuidSet(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UuidSet() (localctx IUuidSetContext) {
|
|
localctx = NewUuidSetContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 576, MySqlParserRULE_uuidSet)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6345)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6346)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6347)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6348)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6349)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6350)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6351)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6352)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6353)
|
|
p.DecimalLiteral()
|
|
}
|
|
p.SetState(6359)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserCOLON_SYMB {
|
|
{
|
|
p.SetState(6354)
|
|
p.Match(MySqlParserCOLON_SYMB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6355)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6356)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6357)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
p.SetState(6361)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXidContext is an interface to support dynamic dispatch.
|
|
type IXidContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetGlobalTableUid returns the globalTableUid rule contexts.
|
|
GetGlobalTableUid() IXuidStringIdContext
|
|
|
|
// GetQualifier returns the qualifier rule contexts.
|
|
GetQualifier() IXuidStringIdContext
|
|
|
|
// GetIdFormat returns the idFormat rule contexts.
|
|
GetIdFormat() IDecimalLiteralContext
|
|
|
|
// SetGlobalTableUid sets the globalTableUid rule contexts.
|
|
SetGlobalTableUid(IXuidStringIdContext)
|
|
|
|
// SetQualifier sets the qualifier rule contexts.
|
|
SetQualifier(IXuidStringIdContext)
|
|
|
|
// SetIdFormat sets the idFormat rule contexts.
|
|
SetIdFormat(IDecimalLiteralContext)
|
|
|
|
// Getter signatures
|
|
AllXuidStringId() []IXuidStringIdContext
|
|
XuidStringId(i int) IXuidStringIdContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
|
|
// IsXidContext differentiates from other interfaces.
|
|
IsXidContext()
|
|
}
|
|
|
|
type XidContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
globalTableUid IXuidStringIdContext
|
|
qualifier IXuidStringIdContext
|
|
idFormat IDecimalLiteralContext
|
|
}
|
|
|
|
func NewEmptyXidContext() *XidContext {
|
|
var p = new(XidContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xid
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXidContext(p *XidContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xid
|
|
}
|
|
|
|
func (*XidContext) IsXidContext() {}
|
|
|
|
func NewXidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XidContext {
|
|
var p = new(XidContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xid
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XidContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XidContext) GetGlobalTableUid() IXuidStringIdContext { return s.globalTableUid }
|
|
|
|
func (s *XidContext) GetQualifier() IXuidStringIdContext { return s.qualifier }
|
|
|
|
func (s *XidContext) GetIdFormat() IDecimalLiteralContext { return s.idFormat }
|
|
|
|
func (s *XidContext) SetGlobalTableUid(v IXuidStringIdContext) { s.globalTableUid = v }
|
|
|
|
func (s *XidContext) SetQualifier(v IXuidStringIdContext) { s.qualifier = v }
|
|
|
|
func (s *XidContext) SetIdFormat(v IDecimalLiteralContext) { s.idFormat = v }
|
|
|
|
func (s *XidContext) AllXuidStringId() []IXuidStringIdContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IXuidStringIdContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IXuidStringIdContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IXuidStringIdContext); ok {
|
|
tst[i] = t.(IXuidStringIdContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *XidContext) XuidStringId(i int) IXuidStringIdContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IXuidStringIdContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IXuidStringIdContext)
|
|
}
|
|
|
|
func (s *XidContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *XidContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *XidContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *XidContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XidContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXid(s)
|
|
}
|
|
}
|
|
|
|
func (s *XidContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXid(s)
|
|
}
|
|
}
|
|
|
|
func (s *XidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXid(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Xid() (localctx IXidContext) {
|
|
localctx = NewXidContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 578, MySqlParserRULE_xid)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6363)
|
|
|
|
var _x = p.XuidStringId()
|
|
|
|
localctx.(*XidContext).globalTableUid = _x
|
|
}
|
|
p.SetState(6370)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6364)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6365)
|
|
|
|
var _x = p.XuidStringId()
|
|
|
|
localctx.(*XidContext).qualifier = _x
|
|
}
|
|
p.SetState(6368)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6366)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6367)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*XidContext).idFormat = _x
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IXuidStringIdContext is an interface to support dynamic dispatch.
|
|
type IXuidStringIdContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
BIT_STRING() antlr.TerminalNode
|
|
AllHEXADECIMAL_LITERAL() []antlr.TerminalNode
|
|
HEXADECIMAL_LITERAL(i int) antlr.TerminalNode
|
|
|
|
// IsXuidStringIdContext differentiates from other interfaces.
|
|
IsXuidStringIdContext()
|
|
}
|
|
|
|
type XuidStringIdContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyXuidStringIdContext() *XuidStringIdContext {
|
|
var p = new(XuidStringIdContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xuidStringId
|
|
return p
|
|
}
|
|
|
|
func InitEmptyXuidStringIdContext(p *XuidStringIdContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_xuidStringId
|
|
}
|
|
|
|
func (*XuidStringIdContext) IsXuidStringIdContext() {}
|
|
|
|
func NewXuidStringIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XuidStringIdContext {
|
|
var p = new(XuidStringIdContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_xuidStringId
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *XuidStringIdContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *XuidStringIdContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *XuidStringIdContext) BIT_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_STRING, 0)
|
|
}
|
|
|
|
func (s *XuidStringIdContext) AllHEXADECIMAL_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserHEXADECIMAL_LITERAL)
|
|
}
|
|
|
|
func (s *XuidStringIdContext) HEXADECIMAL_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHEXADECIMAL_LITERAL, i)
|
|
}
|
|
|
|
func (s *XuidStringIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *XuidStringIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *XuidStringIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterXuidStringId(s)
|
|
}
|
|
}
|
|
|
|
func (s *XuidStringIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitXuidStringId(s)
|
|
}
|
|
}
|
|
|
|
func (s *XuidStringIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitXuidStringId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) XuidStringId() (localctx IXuidStringIdContext) {
|
|
localctx = NewXuidStringIdContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 580, MySqlParserRULE_xuidStringId)
|
|
var _la int
|
|
|
|
p.SetState(6379)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTRING_LITERAL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6372)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_STRING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6373)
|
|
p.Match(MySqlParserBIT_STRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserHEXADECIMAL_LITERAL:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(6375)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserHEXADECIMAL_LITERAL {
|
|
{
|
|
p.SetState(6374)
|
|
p.Match(MySqlParserHEXADECIMAL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(6377)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAuthPluginContext is an interface to support dynamic dispatch.
|
|
type IAuthPluginContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsAuthPluginContext differentiates from other interfaces.
|
|
IsAuthPluginContext()
|
|
}
|
|
|
|
type AuthPluginContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAuthPluginContext() *AuthPluginContext {
|
|
var p = new(AuthPluginContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authPlugin
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAuthPluginContext(p *AuthPluginContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_authPlugin
|
|
}
|
|
|
|
func (*AuthPluginContext) IsAuthPluginContext() {}
|
|
|
|
func NewAuthPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthPluginContext {
|
|
var p = new(AuthPluginContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_authPlugin
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AuthPluginContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AuthPluginContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *AuthPluginContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AuthPluginContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AuthPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AuthPluginContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAuthPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *AuthPluginContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAuthPlugin(s)
|
|
}
|
|
}
|
|
|
|
func (s *AuthPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAuthPlugin(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AuthPlugin() (localctx IAuthPluginContext) {
|
|
localctx = NewAuthPluginContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 582, MySqlParserRULE_authPlugin)
|
|
p.SetState(6383)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 937, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6381)
|
|
p.Uid()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6382)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUidContext is an interface to support dynamic dispatch.
|
|
type IUidContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
SimpleId() ISimpleIdContext
|
|
CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
|
|
// IsUidContext differentiates from other interfaces.
|
|
IsUidContext()
|
|
}
|
|
|
|
type UidContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUidContext() *UidContext {
|
|
var p = new(UidContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uid
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUidContext(p *UidContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uid
|
|
}
|
|
|
|
func (*UidContext) IsUidContext() {}
|
|
|
|
func NewUidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidContext {
|
|
var p = new(UidContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_uid
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UidContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UidContext) SimpleId() ISimpleIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISimpleIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISimpleIdContext)
|
|
}
|
|
|
|
func (s *UidContext) CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARSET_REVERSE_QOUTE_STRING, 0)
|
|
}
|
|
|
|
func (s *UidContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *UidContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UidContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUid(s)
|
|
}
|
|
}
|
|
|
|
func (s *UidContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUid(s)
|
|
}
|
|
}
|
|
|
|
func (s *UidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUid(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Uid() (localctx IUidContext) {
|
|
localctx = NewUidContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 584, MySqlParserRULE_uid)
|
|
p.SetState(6388)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6385)
|
|
p.SimpleId()
|
|
}
|
|
|
|
case MySqlParserCHARSET_REVERSE_QOUTE_STRING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6386)
|
|
p.Match(MySqlParserCHARSET_REVERSE_QOUTE_STRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTRING_LITERAL:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6387)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISimpleIdContext is an interface to support dynamic dispatch.
|
|
type ISimpleIdContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ID() antlr.TerminalNode
|
|
CharsetNameBase() ICharsetNameBaseContext
|
|
TransactionLevelBase() ITransactionLevelBaseContext
|
|
EngineNameBase() IEngineNameBaseContext
|
|
PrivilegesBase() IPrivilegesBaseContext
|
|
IntervalTypeBase() IIntervalTypeBaseContext
|
|
DataTypeBase() IDataTypeBaseContext
|
|
KeywordsCanBeId() IKeywordsCanBeIdContext
|
|
ScalarFunctionName() IScalarFunctionNameContext
|
|
|
|
// IsSimpleIdContext differentiates from other interfaces.
|
|
IsSimpleIdContext()
|
|
}
|
|
|
|
type SimpleIdContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySimpleIdContext() *SimpleIdContext {
|
|
var p = new(SimpleIdContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleId
|
|
return p
|
|
}
|
|
|
|
func InitEmptySimpleIdContext(p *SimpleIdContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleId
|
|
}
|
|
|
|
func (*SimpleIdContext) IsSimpleIdContext() {}
|
|
|
|
func NewSimpleIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleIdContext {
|
|
var p = new(SimpleIdContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_simpleId
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleIdContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SimpleIdContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserID, 0)
|
|
}
|
|
|
|
func (s *SimpleIdContext) CharsetNameBase() ICharsetNameBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) TransactionLevelBase() ITransactionLevelBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITransactionLevelBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITransactionLevelBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) EngineNameBase() IEngineNameBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IEngineNameBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IEngineNameBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) PrivilegesBase() IPrivilegesBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPrivilegesBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPrivilegesBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) IntervalTypeBase() IIntervalTypeBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) DataTypeBase() IDataTypeBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDataTypeBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDataTypeBaseContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) KeywordsCanBeId() IKeywordsCanBeIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IKeywordsCanBeIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IKeywordsCanBeIdContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) ScalarFunctionName() IScalarFunctionNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IScalarFunctionNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IScalarFunctionNameContext)
|
|
}
|
|
|
|
func (s *SimpleIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SimpleIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleId(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleId(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SimpleId() (localctx ISimpleIdContext) {
|
|
localctx = NewSimpleIdContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 586, MySqlParserRULE_simpleId)
|
|
p.SetState(6399)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 939, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6390)
|
|
p.Match(MySqlParserID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6391)
|
|
p.CharsetNameBase()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6392)
|
|
p.TransactionLevelBase()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6393)
|
|
p.EngineNameBase()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6394)
|
|
p.PrivilegesBase()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6395)
|
|
p.IntervalTypeBase()
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(6396)
|
|
p.DataTypeBase()
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(6397)
|
|
p.KeywordsCanBeId()
|
|
}
|
|
|
|
case 9:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(6398)
|
|
p.ScalarFunctionName()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDottedIdContext is an interface to support dynamic dispatch.
|
|
type IDottedIdContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DOT_ID() antlr.TerminalNode
|
|
DOT() antlr.TerminalNode
|
|
Uid() IUidContext
|
|
|
|
// IsDottedIdContext differentiates from other interfaces.
|
|
IsDottedIdContext()
|
|
}
|
|
|
|
type DottedIdContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDottedIdContext() *DottedIdContext {
|
|
var p = new(DottedIdContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dottedId
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDottedIdContext(p *DottedIdContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dottedId
|
|
}
|
|
|
|
func (*DottedIdContext) IsDottedIdContext() {}
|
|
|
|
func NewDottedIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DottedIdContext {
|
|
var p = new(DottedIdContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dottedId
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DottedIdContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DottedIdContext) DOT_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT_ID, 0)
|
|
}
|
|
|
|
func (s *DottedIdContext) DOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOT, 0)
|
|
}
|
|
|
|
func (s *DottedIdContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *DottedIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DottedIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DottedIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDottedId(s)
|
|
}
|
|
}
|
|
|
|
func (s *DottedIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDottedId(s)
|
|
}
|
|
}
|
|
|
|
func (s *DottedIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDottedId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DottedId() (localctx IDottedIdContext) {
|
|
localctx = NewDottedIdContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 588, MySqlParserRULE_dottedId)
|
|
p.SetState(6404)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDOT_ID:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6401)
|
|
p.Match(MySqlParserDOT_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDOT:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6402)
|
|
p.Match(MySqlParserDOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6403)
|
|
p.Uid()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDecimalLiteralContext is an interface to support dynamic dispatch.
|
|
type IDecimalLiteralContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DECIMAL_LITERAL() antlr.TerminalNode
|
|
ZERO_DECIMAL() antlr.TerminalNode
|
|
ONE_DECIMAL() antlr.TerminalNode
|
|
TWO_DECIMAL() antlr.TerminalNode
|
|
REAL_LITERAL() antlr.TerminalNode
|
|
|
|
// IsDecimalLiteralContext differentiates from other interfaces.
|
|
IsDecimalLiteralContext()
|
|
}
|
|
|
|
type DecimalLiteralContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDecimalLiteralContext() *DecimalLiteralContext {
|
|
var p = new(DecimalLiteralContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_decimalLiteral
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDecimalLiteralContext(p *DecimalLiteralContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_decimalLiteral
|
|
}
|
|
|
|
func (*DecimalLiteralContext) IsDecimalLiteralContext() {}
|
|
|
|
func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext {
|
|
var p = new(DecimalLiteralContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_decimalLiteral
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DecimalLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECIMAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) ZERO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZERO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) ONE_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) TWO_DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTWO_DECIMAL, 0)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) REAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDecimalLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDecimalLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *DecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDecimalLiteral(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DecimalLiteral() (localctx IDecimalLiteralContext) {
|
|
localctx = NewDecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 590, MySqlParserRULE_decimalLiteral)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6406)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&10247) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFileSizeLiteralContext is an interface to support dynamic dispatch.
|
|
type IFileSizeLiteralContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FILESIZE_LITERAL() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
|
|
// IsFileSizeLiteralContext differentiates from other interfaces.
|
|
IsFileSizeLiteralContext()
|
|
}
|
|
|
|
type FileSizeLiteralContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFileSizeLiteralContext() *FileSizeLiteralContext {
|
|
var p = new(FileSizeLiteralContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fileSizeLiteral
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFileSizeLiteralContext(p *FileSizeLiteralContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fileSizeLiteral
|
|
}
|
|
|
|
func (*FileSizeLiteralContext) IsFileSizeLiteralContext() {}
|
|
|
|
func NewFileSizeLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FileSizeLiteralContext {
|
|
var p = new(FileSizeLiteralContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fileSizeLiteral
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FileSizeLiteralContext) FILESIZE_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILESIZE_LITERAL, 0)
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFileSizeLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFileSizeLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *FileSizeLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFileSizeLiteral(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FileSizeLiteral() (localctx IFileSizeLiteralContext) {
|
|
localctx = NewFileSizeLiteralContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 592, MySqlParserRULE_fileSizeLiteral)
|
|
p.SetState(6410)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFILESIZE_LITERAL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6408)
|
|
p.Match(MySqlParserFILESIZE_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6409)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IStringLiteralContext is an interface to support dynamic dispatch.
|
|
type IStringLiteralContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
START_NATIONAL_STRING_LITERAL() antlr.TerminalNode
|
|
STRING_CHARSET_NAME() antlr.TerminalNode
|
|
COLLATE() antlr.TerminalNode
|
|
CollationName() ICollationNameContext
|
|
|
|
// IsStringLiteralContext differentiates from other interfaces.
|
|
IsStringLiteralContext()
|
|
}
|
|
|
|
type StringLiteralContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyStringLiteralContext() *StringLiteralContext {
|
|
var p = new(StringLiteralContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stringLiteral
|
|
return p
|
|
}
|
|
|
|
func InitEmptyStringLiteralContext(p *StringLiteralContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_stringLiteral
|
|
}
|
|
|
|
func (*StringLiteralContext) IsStringLiteralContext() {}
|
|
|
|
func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext {
|
|
var p = new(StringLiteralContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_stringLiteral
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *StringLiteralContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *StringLiteralContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *StringLiteralContext) START_NATIONAL_STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART_NATIONAL_STRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *StringLiteralContext) STRING_CHARSET_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_CHARSET_NAME, 0)
|
|
}
|
|
|
|
func (s *StringLiteralContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *StringLiteralContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStringLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStringLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStringLiteral(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) StringLiteral() (localctx IStringLiteralContext) {
|
|
localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 594, MySqlParserRULE_stringLiteral)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(6435)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 948, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6417)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
|
|
p.SetState(6413)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTRING_CHARSET_NAME {
|
|
{
|
|
p.SetState(6412)
|
|
p.Match(MySqlParserSTRING_CHARSET_NAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6415)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTART_NATIONAL_STRING_LITERAL:
|
|
{
|
|
p.SetState(6416)
|
|
p.Match(MySqlParserSTART_NATIONAL_STRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(6420)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = 1
|
|
for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
switch _alt {
|
|
case 1:
|
|
{
|
|
p.SetState(6419)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(6422)
|
|
p.GetErrorHandler().Sync(p)
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 944, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
p.SetState(6429)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
|
|
p.SetState(6425)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTRING_CHARSET_NAME {
|
|
{
|
|
p.SetState(6424)
|
|
p.Match(MySqlParserSTRING_CHARSET_NAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6427)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSTART_NATIONAL_STRING_LITERAL:
|
|
{
|
|
p.SetState(6428)
|
|
p.Match(MySqlParserSTART_NATIONAL_STRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(6433)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 947, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6431)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6432)
|
|
p.CollationName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBooleanLiteralContext is an interface to support dynamic dispatch.
|
|
type IBooleanLiteralContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
TRUE() antlr.TerminalNode
|
|
FALSE() antlr.TerminalNode
|
|
|
|
// IsBooleanLiteralContext differentiates from other interfaces.
|
|
IsBooleanLiteralContext()
|
|
}
|
|
|
|
type BooleanLiteralContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBooleanLiteralContext() *BooleanLiteralContext {
|
|
var p = new(BooleanLiteralContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_booleanLiteral
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBooleanLiteralContext(p *BooleanLiteralContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_booleanLiteral
|
|
}
|
|
|
|
func (*BooleanLiteralContext) IsBooleanLiteralContext() {}
|
|
|
|
func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext {
|
|
var p = new(BooleanLiteralContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_booleanLiteral
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BooleanLiteralContext) TRUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRUE, 0)
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) FALSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFALSE, 0)
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBooleanLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBooleanLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBooleanLiteral(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BooleanLiteral() (localctx IBooleanLiteralContext) {
|
|
localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 596, MySqlParserRULE_booleanLiteral)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6437)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFALSE || _la == MySqlParserTRUE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IHexadecimalLiteralContext is an interface to support dynamic dispatch.
|
|
type IHexadecimalLiteralContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
HEXADECIMAL_LITERAL() antlr.TerminalNode
|
|
STRING_CHARSET_NAME() antlr.TerminalNode
|
|
|
|
// IsHexadecimalLiteralContext differentiates from other interfaces.
|
|
IsHexadecimalLiteralContext()
|
|
}
|
|
|
|
type HexadecimalLiteralContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyHexadecimalLiteralContext() *HexadecimalLiteralContext {
|
|
var p = new(HexadecimalLiteralContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_hexadecimalLiteral
|
|
return p
|
|
}
|
|
|
|
func InitEmptyHexadecimalLiteralContext(p *HexadecimalLiteralContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_hexadecimalLiteral
|
|
}
|
|
|
|
func (*HexadecimalLiteralContext) IsHexadecimalLiteralContext() {}
|
|
|
|
func NewHexadecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalLiteralContext {
|
|
var p = new(HexadecimalLiteralContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_hexadecimalLiteral
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *HexadecimalLiteralContext) HEXADECIMAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHEXADECIMAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) STRING_CHARSET_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_CHARSET_NAME, 0)
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterHexadecimalLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitHexadecimalLiteral(s)
|
|
}
|
|
}
|
|
|
|
func (s *HexadecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitHexadecimalLiteral(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext) {
|
|
localctx = NewHexadecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 598, MySqlParserRULE_hexadecimalLiteral)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6440)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSTRING_CHARSET_NAME {
|
|
{
|
|
p.SetState(6439)
|
|
p.Match(MySqlParserSTRING_CHARSET_NAME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6442)
|
|
p.Match(MySqlParserHEXADECIMAL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// INullNotnullContext is an interface to support dynamic dispatch.
|
|
type INullNotnullContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
NULL_SPEC_LITERAL() antlr.TerminalNode
|
|
NOT() antlr.TerminalNode
|
|
|
|
// IsNullNotnullContext differentiates from other interfaces.
|
|
IsNullNotnullContext()
|
|
}
|
|
|
|
type NullNotnullContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyNullNotnullContext() *NullNotnullContext {
|
|
var p = new(NullNotnullContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_nullNotnull
|
|
return p
|
|
}
|
|
|
|
func InitEmptyNullNotnullContext(p *NullNotnullContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_nullNotnull
|
|
}
|
|
|
|
func (*NullNotnullContext) IsNullNotnullContext() {}
|
|
|
|
func NewNullNotnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullNotnullContext {
|
|
var p = new(NullNotnullContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_nullNotnull
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NullNotnullContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *NullNotnullContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *NullNotnullContext) NULL_SPEC_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_SPEC_LITERAL, 0)
|
|
}
|
|
|
|
func (s *NullNotnullContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *NullNotnullContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NullNotnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *NullNotnullContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNullNotnull(s)
|
|
}
|
|
}
|
|
|
|
func (s *NullNotnullContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNullNotnull(s)
|
|
}
|
|
}
|
|
|
|
func (s *NullNotnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNullNotnull(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) NullNotnull() (localctx INullNotnullContext) {
|
|
localctx = NewNullNotnullContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 600, MySqlParserRULE_nullNotnull)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6445)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(6444)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6447)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNULL_LITERAL || _la == MySqlParserNULL_SPEC_LITERAL) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IConstantContext is an interface to support dynamic dispatch.
|
|
type IConstantContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetNullLiteral returns the nullLiteral token.
|
|
GetNullLiteral() antlr.Token
|
|
|
|
// SetNullLiteral sets the nullLiteral token.
|
|
SetNullLiteral(antlr.Token)
|
|
|
|
// Getter signatures
|
|
StringLiteral() IStringLiteralContext
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
MINUS() antlr.TerminalNode
|
|
HexadecimalLiteral() IHexadecimalLiteralContext
|
|
BooleanLiteral() IBooleanLiteralContext
|
|
REAL_LITERAL() antlr.TerminalNode
|
|
BIT_STRING() antlr.TerminalNode
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
NULL_SPEC_LITERAL() antlr.TerminalNode
|
|
NOT() antlr.TerminalNode
|
|
|
|
// IsConstantContext differentiates from other interfaces.
|
|
IsConstantContext()
|
|
}
|
|
|
|
type ConstantContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
nullLiteral antlr.Token
|
|
}
|
|
|
|
func NewEmptyConstantContext() *ConstantContext {
|
|
var p = new(ConstantContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_constant
|
|
return p
|
|
}
|
|
|
|
func InitEmptyConstantContext(p *ConstantContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_constant
|
|
}
|
|
|
|
func (*ConstantContext) IsConstantContext() {}
|
|
|
|
func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext {
|
|
var p = new(ConstantContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_constant
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConstantContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ConstantContext) GetNullLiteral() antlr.Token { return s.nullLiteral }
|
|
|
|
func (s *ConstantContext) SetNullLiteral(v antlr.Token) { s.nullLiteral = v }
|
|
|
|
func (s *ConstantContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *ConstantContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ConstantContext) MINUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) HexadecimalLiteral() IHexadecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IHexadecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IHexadecimalLiteralContext)
|
|
}
|
|
|
|
func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBooleanLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBooleanLiteralContext)
|
|
}
|
|
|
|
func (s *ConstantContext) REAL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) BIT_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_STRING, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) NULL_SPEC_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_SPEC_LITERAL, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *ConstantContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterConstant(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitConstant(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitConstant(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Constant() (localctx IConstantContext) {
|
|
localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 602, MySqlParserRULE_constant)
|
|
var _la int
|
|
|
|
p.SetState(6461)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 952, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6449)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6450)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6451)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6452)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6453)
|
|
p.HexadecimalLiteral()
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6454)
|
|
p.BooleanLiteral()
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6455)
|
|
p.Match(MySqlParserREAL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(6456)
|
|
p.Match(MySqlParserBIT_STRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
p.SetState(6458)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(6457)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6460)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ConstantContext).nullLiteral = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNULL_LITERAL || _la == MySqlParserNULL_SPEC_LITERAL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ConstantContext).nullLiteral = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDataTypeContext is an interface to support dynamic dispatch.
|
|
type IDataTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsDataTypeContext differentiates from other interfaces.
|
|
IsDataTypeContext()
|
|
}
|
|
|
|
type DataTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDataTypeContext() *DataTypeContext {
|
|
var p = new(DataTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dataType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDataTypeContext(p *DataTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dataType
|
|
}
|
|
|
|
func (*DataTypeContext) IsDataTypeContext() {}
|
|
|
|
func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext {
|
|
var p = new(DataTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dataType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DataTypeContext) CopyAll(ctx *DataTypeContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *DataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SpatialDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewSpatialDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpatialDataTypeContext {
|
|
var p = new(SpatialDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *SpatialDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *SpatialDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) GEOMETRYCOLLECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYCOLLECTION, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) GEOMCOLLECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMCOLLECTION, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) LINESTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINESTRING, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) MULTILINESTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTILINESTRING, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) MULTIPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOINT, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) MULTIPOLYGON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOLYGON, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) POINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOINT, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) POLYGON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYGON, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) JSON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) GEOMETRY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRY, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) SRID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSRID, 0)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSpatialDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSpatialDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpatialDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSpatialDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type LongVarbinaryDataTypeContext struct {
|
|
DataTypeContext
|
|
}
|
|
|
|
func NewLongVarbinaryDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarbinaryDataTypeContext {
|
|
var p = new(LongVarbinaryDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) LONG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLONG, 0)
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) VARBINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARBINARY, 0)
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLongVarbinaryDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLongVarbinaryDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *LongVarbinaryDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLongVarbinaryDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CollectionDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewCollectionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollectionDataTypeContext {
|
|
var p = new(CollectionDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *CollectionDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *CollectionDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) CollectionOptions() ICollectionOptionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollectionOptionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollectionOptionsContext)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) ENUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENUM, 0)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET, 0)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCollectionDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCollectionDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollectionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCollectionDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NationalVaryingStringDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewNationalVaryingStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NationalVaryingStringDataTypeContext {
|
|
var p = new(NationalVaryingStringDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) NATIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNATIONAL, 0)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) VARYING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARYING, 0)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthOneDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthOneDimensionContext)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNationalVaryingStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNationalVaryingStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *NationalVaryingStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNationalVaryingStringDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DimensionDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewDimensionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DimensionDataTypeContext {
|
|
var p = new(DimensionDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *DimensionDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *DimensionDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) TINYINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTINYINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) SMALLINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSMALLINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) MEDIUMINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEDIUMINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INTEGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTEGER, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) BIGINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIGINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) MIDDLEINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIDDLEINT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT1() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT1, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT2, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT3() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT3, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT4() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT4, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) INT8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT8, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) LengthOneDimension() ILengthOneDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthOneDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthOneDimensionContext)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) AllSIGNED() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSIGNED)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) SIGNED(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIGNED, i)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) AllUNSIGNED() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserUNSIGNED)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) UNSIGNED(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNSIGNED, i)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) AllZEROFILL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserZEROFILL)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) ZEROFILL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserZEROFILL, i)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) REAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREAL, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) LengthTwoDimension() ILengthTwoDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthTwoDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthTwoDimensionContext)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) DOUBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOUBLE, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) PRECISION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRECISION, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECIMAL, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) DEC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEC, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) FIXED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIXED, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) NUMERIC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMERIC, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) FLOAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLOAT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) FLOAT4() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLOAT4, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) FLOAT8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLOAT8, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthTwoOptionalDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthTwoOptionalDimensionContext)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) BIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) DATETIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATETIME, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) VARBINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARBINARY, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) BLOB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBLOB, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) YEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR, 0)
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDimensionDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDimensionDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *DimensionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDimensionDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type StringDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringDataTypeContext {
|
|
var p = new(StringDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *StringDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *StringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *StringDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *StringDataTypeContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) VARCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARCHAR, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) TINYTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTINYTEXT, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) TEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEXT, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) MEDIUMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEDIUMTEXT, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) LONGTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLONGTEXT, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) NCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNCHAR, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) NVARCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNVARCHAR, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) LONG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLONG, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) VARYING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARYING, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthOneDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthOneDimensionContext)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) AllBINARY() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserBINARY)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) BINARY(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, i)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *StringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *StringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitStringDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type LongVarcharDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewLongVarcharDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarcharDataTypeContext {
|
|
var p = new(LongVarcharDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *LongVarcharDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *LongVarcharDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) LONG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLONG, 0)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) VARCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARCHAR, 0)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLongVarcharDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLongVarcharDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *LongVarcharDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLongVarcharDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NationalStringDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewNationalStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NationalStringDataTypeContext {
|
|
var p = new(NationalStringDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *NationalStringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *NationalStringDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) NATIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNATIONAL, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) VARCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARCHAR, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) CHARACTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthOneDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthOneDimensionContext)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) NCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNCHAR, 0)
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNationalStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNationalStringDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *NationalStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNationalStringDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SimpleDataTypeContext struct {
|
|
DataTypeContext
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewSimpleDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleDataTypeContext {
|
|
var p = new(SimpleDataTypeContext)
|
|
|
|
InitEmptyDataTypeContext(&p.DataTypeContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*DataTypeContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *SimpleDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *SimpleDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) TINYBLOB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTINYBLOB, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) MEDIUMBLOB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEDIUMBLOB, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) LONGBLOB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLONGBLOB, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) BOOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBOOL, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) BOOLEAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBOOLEAN, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) SERIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERIAL, 0)
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DataType() (localctx IDataTypeContext) {
|
|
localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 604, MySqlParserRULE_dataType)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.SetState(6589)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 981, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewStringDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6463)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*StringDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHARACTER || ((int64((_la-222)) & ^0x3f) == 0 && ((int64(1)<<(_la-222))&31239) != 0) || _la == MySqlParserNCHAR) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*StringDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6465)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVARYING {
|
|
{
|
|
p.SetState(6464)
|
|
p.Match(MySqlParserVARYING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6468)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 954, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6467)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6471)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 955, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6470)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6476)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6473)
|
|
p.CharSet()
|
|
}
|
|
{
|
|
p.SetState(6474)
|
|
p.CharsetName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6481)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 957, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6478)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6479)
|
|
p.CollationName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 957, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(6480)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewNationalVaryingStringDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6483)
|
|
p.Match(MySqlParserNATIONAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6484)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*NationalVaryingStringDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHARACTER || _la == MySqlParserCHAR) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*NationalVaryingStringDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6485)
|
|
p.Match(MySqlParserVARYING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6487)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6486)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6490)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 959, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6489)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewNationalStringDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6492)
|
|
p.Match(MySqlParserNATIONAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6493)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*NationalStringDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHARACTER || _la == MySqlParserCHAR || _la == MySqlParserVARCHAR) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*NationalStringDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6495)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 960, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6494)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6498)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6497)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewNationalStringDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6500)
|
|
p.Match(MySqlParserNCHAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6501)
|
|
|
|
var _m = p.Match(MySqlParserVARCHAR)
|
|
|
|
localctx.(*NationalStringDataTypeContext).typeName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6503)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 962, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6502)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6506)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 963, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6505)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewDimensionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6508)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&4095) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6510)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 964, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6509)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6515)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6512)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6517)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewDimensionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6518)
|
|
|
|
var _m = p.Match(MySqlParserREAL)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6520)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 966, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6519)
|
|
p.LengthTwoDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6525)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6522)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6527)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewDimensionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(6528)
|
|
|
|
var _m = p.Match(MySqlParserDOUBLE)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6530)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPRECISION {
|
|
{
|
|
p.SetState(6529)
|
|
p.Match(MySqlParserPRECISION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6533)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 969, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6532)
|
|
p.LengthTwoDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6538)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6535)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6540)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewDimensionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(6541)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&63) != 0) || _la == MySqlParserFIXED) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6543)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 971, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6542)
|
|
p.LengthTwoOptionalDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6548)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6545)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6550)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewSimpleDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(6551)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SimpleDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&4237313) != 0) || _la == MySqlParserBOOL || _la == MySqlParserBOOLEAN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SimpleDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewDimensionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(6552)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-218)) & ^0x3f) == 0 && ((int64(1)<<(_la-218))&2831) != 0) || _la == MySqlParserBIT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*DimensionDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6554)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6553)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewCollectionDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(6556)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*CollectionDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSET || _la == MySqlParserENUM) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*CollectionDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6557)
|
|
p.CollectionOptions()
|
|
}
|
|
p.SetState(6559)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 974, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6558)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6564)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6561)
|
|
p.CharSet()
|
|
}
|
|
{
|
|
p.SetState(6562)
|
|
p.CharsetName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewSpatialDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(6566)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SpatialDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserJSON || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&511) != 0)) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SpatialDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6569)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 976, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6567)
|
|
p.Match(MySqlParserSRID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6568)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewLongVarcharDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(6571)
|
|
|
|
var _m = p.Match(MySqlParserLONG)
|
|
|
|
localctx.(*LongVarcharDataTypeContext).typeName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6573)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserVARCHAR {
|
|
{
|
|
p.SetState(6572)
|
|
p.Match(MySqlParserVARCHAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6576)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 978, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6575)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6581)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 979, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6578)
|
|
p.CharSet()
|
|
}
|
|
{
|
|
p.SetState(6579)
|
|
p.CharsetName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6585)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6583)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6584)
|
|
p.CollationName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewLongVarbinaryDataTypeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(6587)
|
|
p.Match(MySqlParserLONG)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6588)
|
|
p.Match(MySqlParserVARBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICollectionOptionsContext is an interface to support dynamic dispatch.
|
|
type ICollectionOptionsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsCollectionOptionsContext differentiates from other interfaces.
|
|
IsCollectionOptionsContext()
|
|
}
|
|
|
|
type CollectionOptionsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCollectionOptionsContext() *CollectionOptionsContext {
|
|
var p = new(CollectionOptionsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_collectionOptions
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCollectionOptionsContext(p *CollectionOptionsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_collectionOptions
|
|
}
|
|
|
|
func (*CollectionOptionsContext) IsCollectionOptionsContext() {}
|
|
|
|
func NewCollectionOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionOptionsContext {
|
|
var p = new(CollectionOptionsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_collectionOptions
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CollectionOptionsContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCollectionOptions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCollectionOptions(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollectionOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCollectionOptions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CollectionOptions() (localctx ICollectionOptionsContext) {
|
|
localctx = NewCollectionOptionsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 606, MySqlParserRULE_collectionOptions)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6591)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6592)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6597)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6593)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6594)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(6599)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(6600)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IConvertedDataTypeContext is an interface to support dynamic dispatch.
|
|
type IConvertedDataTypeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetTypeName returns the typeName token.
|
|
GetTypeName() antlr.Token
|
|
|
|
// SetTypeName sets the typeName token.
|
|
SetTypeName(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CHAR() antlr.TerminalNode
|
|
SIGNED() antlr.TerminalNode
|
|
UNSIGNED() antlr.TerminalNode
|
|
ARRAY() antlr.TerminalNode
|
|
BINARY() antlr.TerminalNode
|
|
NCHAR() antlr.TerminalNode
|
|
FLOAT() antlr.TerminalNode
|
|
DATE() antlr.TerminalNode
|
|
DATETIME() antlr.TerminalNode
|
|
TIME() antlr.TerminalNode
|
|
YEAR() antlr.TerminalNode
|
|
JSON() antlr.TerminalNode
|
|
INT() antlr.TerminalNode
|
|
INTEGER() antlr.TerminalNode
|
|
DOUBLE() antlr.TerminalNode
|
|
DECIMAL() antlr.TerminalNode
|
|
DEC() antlr.TerminalNode
|
|
LengthOneDimension() ILengthOneDimensionContext
|
|
CharSet() ICharSetContext
|
|
CharsetName() ICharsetNameContext
|
|
LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext
|
|
|
|
// IsConvertedDataTypeContext differentiates from other interfaces.
|
|
IsConvertedDataTypeContext()
|
|
}
|
|
|
|
type ConvertedDataTypeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
typeName antlr.Token
|
|
}
|
|
|
|
func NewEmptyConvertedDataTypeContext() *ConvertedDataTypeContext {
|
|
var p = new(ConvertedDataTypeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_convertedDataType
|
|
return p
|
|
}
|
|
|
|
func InitEmptyConvertedDataTypeContext(p *ConvertedDataTypeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_convertedDataType
|
|
}
|
|
|
|
func (*ConvertedDataTypeContext) IsConvertedDataTypeContext() {}
|
|
|
|
func NewConvertedDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConvertedDataTypeContext {
|
|
var p = new(ConvertedDataTypeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_convertedDataType
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ConvertedDataTypeContext) GetTypeName() antlr.Token { return s.typeName }
|
|
|
|
func (s *ConvertedDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v }
|
|
|
|
func (s *ConvertedDataTypeContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) SIGNED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIGNED, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) UNSIGNED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNSIGNED, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) ARRAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserARRAY, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) NCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNCHAR, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) FLOAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLOAT, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) DATETIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATETIME, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) YEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) JSON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) INT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINT, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) INTEGER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTEGER, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) DOUBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDOUBLE, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) DECIMAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECIMAL, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) DEC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEC, 0)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) LengthOneDimension() ILengthOneDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthOneDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthOneDimensionContext)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) CharSet() ICharSetContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharSetContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharSetContext)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILengthTwoOptionalDimensionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILengthTwoOptionalDimensionContext)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterConvertedDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitConvertedDataType(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConvertedDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitConvertedDataType(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ConvertedDataType() (localctx IConvertedDataTypeContext) {
|
|
localctx = NewConvertedDataTypeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 608, MySqlParserRULE_convertedDataType)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6624)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserFLOAT, MySqlParserBINARY, MySqlParserNCHAR:
|
|
{
|
|
p.SetState(6602)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFLOAT || _la == MySqlParserBINARY || _la == MySqlParserNCHAR) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6604)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(6603)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserCHAR:
|
|
{
|
|
p.SetState(6606)
|
|
|
|
var _m = p.Match(MySqlParserCHAR)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6608)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(6607)
|
|
p.LengthOneDimension()
|
|
}
|
|
|
|
}
|
|
p.SetState(6613)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCHARACTER || _la == MySqlParserCHAR || _la == MySqlParserCHARSET {
|
|
{
|
|
p.SetState(6610)
|
|
p.CharSet()
|
|
}
|
|
{
|
|
p.SetState(6611)
|
|
p.CharsetName()
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserINT, MySqlParserINTEGER, MySqlParserDOUBLE, MySqlParserDATE, MySqlParserTIME, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserJSON:
|
|
{
|
|
p.SetState(6615)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64((_la-200)) & ^0x3f) == 0 && ((int64(1)<<(_la-200))&3539521) != 0) || _la == MySqlParserJSON) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case MySqlParserDECIMAL, MySqlParserDEC:
|
|
{
|
|
p.SetState(6616)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDECIMAL || _la == MySqlParserDEC) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*ConvertedDataTypeContext).typeName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6618)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLR_BRACKET {
|
|
{
|
|
p.SetState(6617)
|
|
p.LengthTwoOptionalDimension()
|
|
}
|
|
|
|
}
|
|
|
|
case MySqlParserUNSIGNED, MySqlParserSIGNED:
|
|
{
|
|
p.SetState(6620)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserUNSIGNED || _la == MySqlParserSIGNED) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6622)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserINT || _la == MySqlParserINTEGER {
|
|
{
|
|
p.SetState(6621)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserINT || _la == MySqlParserINTEGER) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.SetState(6627)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserARRAY {
|
|
{
|
|
p.SetState(6626)
|
|
p.Match(MySqlParserARRAY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILengthOneDimensionContext is an interface to support dynamic dispatch.
|
|
type ILengthOneDimensionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsLengthOneDimensionContext differentiates from other interfaces.
|
|
IsLengthOneDimensionContext()
|
|
}
|
|
|
|
type LengthOneDimensionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLengthOneDimensionContext() *LengthOneDimensionContext {
|
|
var p = new(LengthOneDimensionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthOneDimension
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLengthOneDimensionContext(p *LengthOneDimensionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthOneDimension
|
|
}
|
|
|
|
func (*LengthOneDimensionContext) IsLengthOneDimensionContext() {}
|
|
|
|
func NewLengthOneDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthOneDimensionContext {
|
|
var p = new(LengthOneDimensionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lengthOneDimension
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LengthOneDimensionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLengthOneDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLengthOneDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthOneDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLengthOneDimension(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LengthOneDimension() (localctx ILengthOneDimensionContext) {
|
|
localctx = NewLengthOneDimensionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 610, MySqlParserRULE_lengthOneDimension)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6629)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6630)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6631)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILengthTwoDimensionContext is an interface to support dynamic dispatch.
|
|
type ILengthTwoDimensionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllDecimalLiteral() []IDecimalLiteralContext
|
|
DecimalLiteral(i int) IDecimalLiteralContext
|
|
COMMA() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
|
|
// IsLengthTwoDimensionContext differentiates from other interfaces.
|
|
IsLengthTwoDimensionContext()
|
|
}
|
|
|
|
type LengthTwoDimensionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLengthTwoDimensionContext() *LengthTwoDimensionContext {
|
|
var p = new(LengthTwoDimensionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoDimension
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLengthTwoDimensionContext(p *LengthTwoDimensionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoDimension
|
|
}
|
|
|
|
func (*LengthTwoDimensionContext) IsLengthTwoDimensionContext() {}
|
|
|
|
func NewLengthTwoDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoDimensionContext {
|
|
var p = new(LengthTwoDimensionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoDimension
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LengthTwoDimensionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLengthTwoDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLengthTwoDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthTwoDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLengthTwoDimension(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LengthTwoDimension() (localctx ILengthTwoDimensionContext) {
|
|
localctx = NewLengthTwoDimensionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 612, MySqlParserRULE_lengthTwoDimension)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6633)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6634)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6635)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6636)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6637)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILengthTwoOptionalDimensionContext is an interface to support dynamic dispatch.
|
|
type ILengthTwoOptionalDimensionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllDecimalLiteral() []IDecimalLiteralContext
|
|
DecimalLiteral(i int) IDecimalLiteralContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
COMMA() antlr.TerminalNode
|
|
|
|
// IsLengthTwoOptionalDimensionContext differentiates from other interfaces.
|
|
IsLengthTwoOptionalDimensionContext()
|
|
}
|
|
|
|
type LengthTwoOptionalDimensionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLengthTwoOptionalDimensionContext() *LengthTwoOptionalDimensionContext {
|
|
var p = new(LengthTwoOptionalDimensionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLengthTwoOptionalDimensionContext(p *LengthTwoOptionalDimensionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension
|
|
}
|
|
|
|
func (*LengthTwoOptionalDimensionContext) IsLengthTwoOptionalDimensionContext() {}
|
|
|
|
func NewLengthTwoOptionalDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoOptionalDimensionContext {
|
|
var p = new(LengthTwoOptionalDimensionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLengthTwoOptionalDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLengthTwoOptionalDimension(s)
|
|
}
|
|
}
|
|
|
|
func (s *LengthTwoOptionalDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLengthTwoOptionalDimension(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LengthTwoOptionalDimension() (localctx ILengthTwoOptionalDimensionContext) {
|
|
localctx = NewLengthTwoOptionalDimensionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 614, MySqlParserRULE_lengthTwoOptionalDimension)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6639)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6640)
|
|
p.DecimalLiteral()
|
|
}
|
|
p.SetState(6643)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6641)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6642)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6645)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUidListContext is an interface to support dynamic dispatch.
|
|
type IUidListContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllUid() []IUidContext
|
|
Uid(i int) IUidContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsUidListContext differentiates from other interfaces.
|
|
IsUidListContext()
|
|
}
|
|
|
|
type UidListContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUidListContext() *UidListContext {
|
|
var p = new(UidListContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uidList
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUidListContext(p *UidListContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_uidList
|
|
}
|
|
|
|
func (*UidListContext) IsUidListContext() {}
|
|
|
|
func NewUidListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidListContext {
|
|
var p = new(UidListContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_uidList
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UidListContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UidListContext) AllUid() []IUidContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IUidContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IUidContext); ok {
|
|
tst[i] = t.(IUidContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *UidListContext) Uid(i int) IUidContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *UidListContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *UidListContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *UidListContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UidListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UidListContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUidList(s)
|
|
}
|
|
}
|
|
|
|
func (s *UidListContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUidList(s)
|
|
}
|
|
}
|
|
|
|
func (s *UidListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUidList(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UidList() (localctx IUidListContext) {
|
|
localctx = NewUidListContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 616, MySqlParserRULE_uidList)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6647)
|
|
p.Uid()
|
|
}
|
|
p.SetState(6652)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 991, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6648)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6649)
|
|
p.Uid()
|
|
}
|
|
|
|
}
|
|
p.SetState(6654)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 991, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFullColumnNameListContext is an interface to support dynamic dispatch.
|
|
type IFullColumnNameListContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllFullColumnName() []IFullColumnNameContext
|
|
FullColumnName(i int) IFullColumnNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsFullColumnNameListContext differentiates from other interfaces.
|
|
IsFullColumnNameListContext()
|
|
}
|
|
|
|
type FullColumnNameListContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFullColumnNameListContext() *FullColumnNameListContext {
|
|
var p = new(FullColumnNameListContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullColumnNameList
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFullColumnNameListContext(p *FullColumnNameListContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_fullColumnNameList
|
|
}
|
|
|
|
func (*FullColumnNameListContext) IsFullColumnNameListContext() {}
|
|
|
|
func NewFullColumnNameListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullColumnNameListContext {
|
|
var p = new(FullColumnNameListContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_fullColumnNameList
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FullColumnNameListContext) AllFullColumnName() []IFullColumnNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullColumnNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullColumnNameContext); ok {
|
|
tst[i] = t.(IFullColumnNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) FullColumnName(i int) IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFullColumnNameList(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFullColumnNameList(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFullColumnNameList(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FullColumnNameList() (localctx IFullColumnNameListContext) {
|
|
localctx = NewFullColumnNameListContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 618, MySqlParserRULE_fullColumnNameList)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6655)
|
|
p.FullColumnName()
|
|
}
|
|
p.SetState(6660)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6656)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6657)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
p.SetState(6662)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITablesContext is an interface to support dynamic dispatch.
|
|
type ITablesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllTableName() []ITableNameContext
|
|
TableName(i int) ITableNameContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsTablesContext differentiates from other interfaces.
|
|
IsTablesContext()
|
|
}
|
|
|
|
type TablesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTablesContext() *TablesContext {
|
|
var p = new(TablesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tables
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTablesContext(p *TablesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_tables
|
|
}
|
|
|
|
func (*TablesContext) IsTablesContext() {}
|
|
|
|
func NewTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablesContext {
|
|
var p = new(TablesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_tables
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TablesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TablesContext) AllTableName() []ITableNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ITableNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ITableNameContext); ok {
|
|
tst[i] = t.(ITableNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TablesContext) TableName(i int) ITableNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ITableNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ITableNameContext)
|
|
}
|
|
|
|
func (s *TablesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *TablesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *TablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTables(s)
|
|
}
|
|
}
|
|
|
|
func (s *TablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Tables() (localctx ITablesContext) {
|
|
localctx = NewTablesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 620, MySqlParserRULE_tables)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6663)
|
|
p.TableName()
|
|
}
|
|
p.SetState(6668)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 993, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(6664)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6665)
|
|
p.TableName()
|
|
}
|
|
|
|
}
|
|
p.SetState(6670)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 993, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIndexColumnNamesContext is an interface to support dynamic dispatch.
|
|
type IIndexColumnNamesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
AllIndexColumnName() []IIndexColumnNameContext
|
|
IndexColumnName(i int) IIndexColumnNameContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsIndexColumnNamesContext differentiates from other interfaces.
|
|
IsIndexColumnNamesContext()
|
|
}
|
|
|
|
type IndexColumnNamesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIndexColumnNamesContext() *IndexColumnNamesContext {
|
|
var p = new(IndexColumnNamesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnNames
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIndexColumnNamesContext(p *IndexColumnNamesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_indexColumnNames
|
|
}
|
|
|
|
func (*IndexColumnNamesContext) IsIndexColumnNamesContext() {}
|
|
|
|
func NewIndexColumnNamesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNamesContext {
|
|
var p = new(IndexColumnNamesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_indexColumnNames
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IndexColumnNamesContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) AllIndexColumnName() []IIndexColumnNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIndexColumnNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIndexColumnNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIndexColumnNameContext); ok {
|
|
tst[i] = t.(IIndexColumnNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) IndexColumnName(i int) IIndexColumnNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIndexColumnNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIndexColumnNameContext)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIndexColumnNames(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIndexColumnNames(s)
|
|
}
|
|
}
|
|
|
|
func (s *IndexColumnNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIndexColumnNames(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IndexColumnNames() (localctx IIndexColumnNamesContext) {
|
|
localctx = NewIndexColumnNamesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 622, MySqlParserRULE_indexColumnNames)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6671)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6672)
|
|
p.IndexColumnName()
|
|
}
|
|
p.SetState(6677)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6673)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6674)
|
|
p.IndexColumnName()
|
|
}
|
|
|
|
p.SetState(6679)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(6680)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExpressionsContext is an interface to support dynamic dispatch.
|
|
type IExpressionsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllExpression() []IExpressionContext
|
|
Expression(i int) IExpressionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsExpressionsContext differentiates from other interfaces.
|
|
IsExpressionsContext()
|
|
}
|
|
|
|
type ExpressionsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExpressionsContext() *ExpressionsContext {
|
|
var p = new(ExpressionsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressions
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExpressionsContext(p *ExpressionsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressions
|
|
}
|
|
|
|
func (*ExpressionsContext) IsExpressionsContext() {}
|
|
|
|
func NewExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsContext {
|
|
var p = new(ExpressionsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_expressions
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExpressionsContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ExpressionsContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ExpressionsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ExpressionsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ExpressionsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ExpressionsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExpressions(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExpressions(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExpressions(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Expressions() (localctx IExpressionsContext) {
|
|
localctx = NewExpressionsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 624, MySqlParserRULE_expressions)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6682)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(6687)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6683)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6684)
|
|
p.expression(0)
|
|
}
|
|
|
|
p.SetState(6689)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExpressionsWithDefaultsContext is an interface to support dynamic dispatch.
|
|
type IExpressionsWithDefaultsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllExpressionOrDefault() []IExpressionOrDefaultContext
|
|
ExpressionOrDefault(i int) IExpressionOrDefaultContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsExpressionsWithDefaultsContext differentiates from other interfaces.
|
|
IsExpressionsWithDefaultsContext()
|
|
}
|
|
|
|
type ExpressionsWithDefaultsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExpressionsWithDefaultsContext() *ExpressionsWithDefaultsContext {
|
|
var p = new(ExpressionsWithDefaultsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionsWithDefaults
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExpressionsWithDefaultsContext(p *ExpressionsWithDefaultsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionsWithDefaults
|
|
}
|
|
|
|
func (*ExpressionsWithDefaultsContext) IsExpressionsWithDefaultsContext() {}
|
|
|
|
func NewExpressionsWithDefaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsWithDefaultsContext {
|
|
var p = new(ExpressionsWithDefaultsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_expressionsWithDefaults
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExpressionsWithDefaultsContext) AllExpressionOrDefault() []IExpressionOrDefaultContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionOrDefaultContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionOrDefaultContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionOrDefaultContext); ok {
|
|
tst[i] = t.(IExpressionOrDefaultContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) ExpressionOrDefault(i int) IExpressionOrDefaultContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionOrDefaultContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionOrDefaultContext)
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExpressionsWithDefaults(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExpressionsWithDefaults(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionsWithDefaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExpressionsWithDefaults(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ExpressionsWithDefaults() (localctx IExpressionsWithDefaultsContext) {
|
|
localctx = NewExpressionsWithDefaultsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 626, MySqlParserRULE_expressionsWithDefaults)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6690)
|
|
p.ExpressionOrDefault()
|
|
}
|
|
p.SetState(6695)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6691)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6692)
|
|
p.ExpressionOrDefault()
|
|
}
|
|
|
|
p.SetState(6697)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IConstantsContext is an interface to support dynamic dispatch.
|
|
type IConstantsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllConstant() []IConstantContext
|
|
Constant(i int) IConstantContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsConstantsContext differentiates from other interfaces.
|
|
IsConstantsContext()
|
|
}
|
|
|
|
type ConstantsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyConstantsContext() *ConstantsContext {
|
|
var p = new(ConstantsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_constants
|
|
return p
|
|
}
|
|
|
|
func InitEmptyConstantsContext(p *ConstantsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_constants
|
|
}
|
|
|
|
func (*ConstantsContext) IsConstantsContext() {}
|
|
|
|
func NewConstantsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantsContext {
|
|
var p = new(ConstantsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_constants
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConstantsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ConstantsContext) AllConstant() []IConstantContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IConstantContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IConstantContext); ok {
|
|
tst[i] = t.(IConstantContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ConstantsContext) Constant(i int) IConstantContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *ConstantsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *ConstantsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *ConstantsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConstantsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ConstantsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterConstants(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitConstants(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitConstants(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Constants() (localctx IConstantsContext) {
|
|
localctx = NewConstantsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 628, MySqlParserRULE_constants)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6698)
|
|
p.Constant()
|
|
}
|
|
p.SetState(6703)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6699)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6700)
|
|
p.Constant()
|
|
}
|
|
|
|
p.SetState(6705)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISimpleStringsContext is an interface to support dynamic dispatch.
|
|
type ISimpleStringsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllSTRING_LITERAL() []antlr.TerminalNode
|
|
STRING_LITERAL(i int) antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsSimpleStringsContext differentiates from other interfaces.
|
|
IsSimpleStringsContext()
|
|
}
|
|
|
|
type SimpleStringsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySimpleStringsContext() *SimpleStringsContext {
|
|
var p = new(SimpleStringsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleStrings
|
|
return p
|
|
}
|
|
|
|
func InitEmptySimpleStringsContext(p *SimpleStringsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_simpleStrings
|
|
}
|
|
|
|
func (*SimpleStringsContext) IsSimpleStringsContext() {}
|
|
|
|
func NewSimpleStringsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleStringsContext {
|
|
var p = new(SimpleStringsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_simpleStrings
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleStringsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SimpleStringsContext) AllSTRING_LITERAL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserSTRING_LITERAL)
|
|
}
|
|
|
|
func (s *SimpleStringsContext) STRING_LITERAL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, i)
|
|
}
|
|
|
|
func (s *SimpleStringsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *SimpleStringsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *SimpleStringsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleStringsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SimpleStringsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleStrings(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleStringsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleStrings(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleStringsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleStrings(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SimpleStrings() (localctx ISimpleStringsContext) {
|
|
localctx = NewSimpleStringsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 630, MySqlParserRULE_simpleStrings)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6706)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6711)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6707)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6708)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(6713)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUserVariablesContext is an interface to support dynamic dispatch.
|
|
type IUserVariablesContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllLOCAL_ID() []antlr.TerminalNode
|
|
LOCAL_ID(i int) antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsUserVariablesContext differentiates from other interfaces.
|
|
IsUserVariablesContext()
|
|
}
|
|
|
|
type UserVariablesContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUserVariablesContext() *UserVariablesContext {
|
|
var p = new(UserVariablesContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userVariables
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUserVariablesContext(p *UserVariablesContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_userVariables
|
|
}
|
|
|
|
func (*UserVariablesContext) IsUserVariablesContext() {}
|
|
|
|
func NewUserVariablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserVariablesContext {
|
|
var p = new(UserVariablesContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_userVariables
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UserVariablesContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UserVariablesContext) AllLOCAL_ID() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLOCAL_ID)
|
|
}
|
|
|
|
func (s *UserVariablesContext) LOCAL_ID(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, i)
|
|
}
|
|
|
|
func (s *UserVariablesContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *UserVariablesContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *UserVariablesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UserVariablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UserVariablesContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUserVariables(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserVariablesContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUserVariables(s)
|
|
}
|
|
}
|
|
|
|
func (s *UserVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUserVariables(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UserVariables() (localctx IUserVariablesContext) {
|
|
localctx = NewUserVariablesContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 632, MySqlParserRULE_userVariables)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6714)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6719)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6715)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6716)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
p.SetState(6721)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDefaultValueContext is an interface to support dynamic dispatch.
|
|
type IDefaultValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
NULL_LITERAL() antlr.TerminalNode
|
|
CAST() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
AS() antlr.TerminalNode
|
|
ConvertedDataType() IConvertedDataTypeContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
Constant() IConstantContext
|
|
UnaryOperator() IUnaryOperatorContext
|
|
AllCurrentTimestamp() []ICurrentTimestampContext
|
|
CurrentTimestamp(i int) ICurrentTimestampContext
|
|
ON() antlr.TerminalNode
|
|
UPDATE() antlr.TerminalNode
|
|
FullId() IFullIdContext
|
|
|
|
// IsDefaultValueContext differentiates from other interfaces.
|
|
IsDefaultValueContext()
|
|
}
|
|
|
|
type DefaultValueContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDefaultValueContext() *DefaultValueContext {
|
|
var p = new(DefaultValueContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_defaultValue
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDefaultValueContext(p *DefaultValueContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_defaultValue
|
|
}
|
|
|
|
func (*DefaultValueContext) IsDefaultValueContext() {}
|
|
|
|
func NewDefaultValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultValueContext {
|
|
var p = new(DefaultValueContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_defaultValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DefaultValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DefaultValueContext) NULL_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULL_LITERAL, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) CAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCAST, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) ConvertedDataType() IConvertedDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConvertedDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConvertedDataTypeContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) Constant() IConstantContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) UnaryOperator() IUnaryOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnaryOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnaryOperatorContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) AllCurrentTimestamp() []ICurrentTimestampContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICurrentTimestampContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICurrentTimestampContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICurrentTimestampContext); ok {
|
|
tst[i] = t.(ICurrentTimestampContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *DefaultValueContext) CurrentTimestamp(i int) ICurrentTimestampContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICurrentTimestampContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICurrentTimestampContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) ON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserON, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) UPDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATE, 0)
|
|
}
|
|
|
|
func (s *DefaultValueContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *DefaultValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DefaultValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DefaultValueContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDefaultValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultValueContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDefaultValue(s)
|
|
}
|
|
}
|
|
|
|
func (s *DefaultValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDefaultValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DefaultValue() (localctx IDefaultValueContext) {
|
|
localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 634, MySqlParserRULE_defaultValue)
|
|
p.SetState(6748)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1002, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6722)
|
|
p.Match(MySqlParserNULL_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6723)
|
|
p.Match(MySqlParserCAST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6724)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6725)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6726)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6727)
|
|
p.ConvertedDataType()
|
|
}
|
|
{
|
|
p.SetState(6728)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
p.SetState(6731)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1000, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6730)
|
|
p.UnaryOperator()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6733)
|
|
p.Constant()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6734)
|
|
p.CurrentTimestamp()
|
|
}
|
|
p.SetState(6738)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6735)
|
|
p.Match(MySqlParserON)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6736)
|
|
p.Match(MySqlParserUPDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6737)
|
|
p.CurrentTimestamp()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6740)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6741)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6742)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6744)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6745)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(6746)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICurrentTimestampContext is an interface to support dynamic dispatch.
|
|
type ICurrentTimestampContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
NOW() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
RR_BRACKET() antlr.TerminalNode
|
|
CURRENT_TIMESTAMP() antlr.TerminalNode
|
|
LOCALTIME() antlr.TerminalNode
|
|
LOCALTIMESTAMP() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
|
|
// IsCurrentTimestampContext differentiates from other interfaces.
|
|
IsCurrentTimestampContext()
|
|
}
|
|
|
|
type CurrentTimestampContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCurrentTimestampContext() *CurrentTimestampContext {
|
|
var p = new(CurrentTimestampContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_currentTimestamp
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCurrentTimestampContext(p *CurrentTimestampContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_currentTimestamp
|
|
}
|
|
|
|
func (*CurrentTimestampContext) IsCurrentTimestampContext() {}
|
|
|
|
func NewCurrentTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CurrentTimestampContext {
|
|
var p = new(CurrentTimestampContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_currentTimestamp
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CurrentTimestampContext) NOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOW, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) LOCALTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCALTIME, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) LOCALTIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCALTIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCurrentTimestamp(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCurrentTimestamp(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCurrentTimestamp(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CurrentTimestamp() (localctx ICurrentTimestampContext) {
|
|
localctx = NewCurrentTimestampContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 636, MySqlParserRULE_currentTimestamp)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(6764)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserLOCALTIMESTAMP:
|
|
{
|
|
p.SetState(6750)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-315)) & ^0x3f) == 0 && ((int64(1)<<(_la-315))&131) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6756)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1004, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6751)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6753)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if (int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&10247) != 0 {
|
|
{
|
|
p.SetState(6752)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6755)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserNOW:
|
|
{
|
|
p.SetState(6758)
|
|
p.Match(MySqlParserNOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6759)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6761)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if (int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&10247) != 0 {
|
|
{
|
|
p.SetState(6760)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6763)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExpressionOrDefaultContext is an interface to support dynamic dispatch.
|
|
type IExpressionOrDefaultContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Expression() IExpressionContext
|
|
DEFAULT() antlr.TerminalNode
|
|
|
|
// IsExpressionOrDefaultContext differentiates from other interfaces.
|
|
IsExpressionOrDefaultContext()
|
|
}
|
|
|
|
type ExpressionOrDefaultContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExpressionOrDefaultContext() *ExpressionOrDefaultContext {
|
|
var p = new(ExpressionOrDefaultContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionOrDefault
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExpressionOrDefaultContext(p *ExpressionOrDefaultContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionOrDefault
|
|
}
|
|
|
|
func (*ExpressionOrDefaultContext) IsExpressionOrDefaultContext() {}
|
|
|
|
func NewExpressionOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionOrDefaultContext {
|
|
var p = new(ExpressionOrDefaultContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_expressionOrDefault
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExpressionOrDefaultContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExpressionOrDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExpressionOrDefault(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExpressionOrDefault(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext) {
|
|
localctx = NewExpressionOrDefaultContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 638, MySqlParserRULE_expressionOrDefault)
|
|
p.SetState(6768)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6766)
|
|
p.expression(0)
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6767)
|
|
p.Match(MySqlParserDEFAULT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIfExistsContext is an interface to support dynamic dispatch.
|
|
type IIfExistsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
IF() antlr.TerminalNode
|
|
EXISTS() antlr.TerminalNode
|
|
|
|
// IsIfExistsContext differentiates from other interfaces.
|
|
IsIfExistsContext()
|
|
}
|
|
|
|
type IfExistsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIfExistsContext() *IfExistsContext {
|
|
var p = new(IfExistsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifExists
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIfExistsContext(p *IfExistsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifExists
|
|
}
|
|
|
|
func (*IfExistsContext) IsIfExistsContext() {}
|
|
|
|
func NewIfExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExistsContext {
|
|
var p = new(IfExistsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_ifExists
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IfExistsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IfExistsContext) IF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIF, 0)
|
|
}
|
|
|
|
func (s *IfExistsContext) EXISTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXISTS, 0)
|
|
}
|
|
|
|
func (s *IfExistsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IfExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IfExistsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIfExists(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfExistsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIfExists(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIfExists(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IfExists() (localctx IIfExistsContext) {
|
|
localctx = NewIfExistsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 640, MySqlParserRULE_ifExists)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6770)
|
|
p.Match(MySqlParserIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6771)
|
|
p.Match(MySqlParserEXISTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIfNotExistsContext is an interface to support dynamic dispatch.
|
|
type IIfNotExistsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
IF() antlr.TerminalNode
|
|
NOT() antlr.TerminalNode
|
|
EXISTS() antlr.TerminalNode
|
|
|
|
// IsIfNotExistsContext differentiates from other interfaces.
|
|
IsIfNotExistsContext()
|
|
}
|
|
|
|
type IfNotExistsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIfNotExistsContext() *IfNotExistsContext {
|
|
var p = new(IfNotExistsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifNotExists
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIfNotExistsContext(p *IfNotExistsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_ifNotExists
|
|
}
|
|
|
|
func (*IfNotExistsContext) IsIfNotExistsContext() {}
|
|
|
|
func NewIfNotExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfNotExistsContext {
|
|
var p = new(IfNotExistsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_ifNotExists
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IfNotExistsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IfNotExistsContext) IF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIF, 0)
|
|
}
|
|
|
|
func (s *IfNotExistsContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *IfNotExistsContext) EXISTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXISTS, 0)
|
|
}
|
|
|
|
func (s *IfNotExistsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IfNotExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IfNotExistsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIfNotExists(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfNotExistsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIfNotExists(s)
|
|
}
|
|
}
|
|
|
|
func (s *IfNotExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIfNotExists(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IfNotExists() (localctx IIfNotExistsContext) {
|
|
localctx = NewIfNotExistsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 642, MySqlParserRULE_ifNotExists)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6773)
|
|
p.Match(MySqlParserIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6774)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6775)
|
|
p.Match(MySqlParserEXISTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOrReplaceContext is an interface to support dynamic dispatch.
|
|
type IOrReplaceContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
OR() antlr.TerminalNode
|
|
REPLACE() antlr.TerminalNode
|
|
|
|
// IsOrReplaceContext differentiates from other interfaces.
|
|
IsOrReplaceContext()
|
|
}
|
|
|
|
type OrReplaceContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyOrReplaceContext() *OrReplaceContext {
|
|
var p = new(OrReplaceContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orReplace
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOrReplaceContext(p *OrReplaceContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_orReplace
|
|
}
|
|
|
|
func (*OrReplaceContext) IsOrReplaceContext() {}
|
|
|
|
func NewOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrReplaceContext {
|
|
var p = new(OrReplaceContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_orReplace
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OrReplaceContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OrReplaceContext) OR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOR, 0)
|
|
}
|
|
|
|
func (s *OrReplaceContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *OrReplaceContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OrReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OrReplaceContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOrReplace(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrReplaceContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOrReplace(s)
|
|
}
|
|
}
|
|
|
|
func (s *OrReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOrReplace(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OrReplace() (localctx IOrReplaceContext) {
|
|
localctx = NewOrReplaceContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 644, MySqlParserRULE_orReplace)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6777)
|
|
p.Match(MySqlParserOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6778)
|
|
p.Match(MySqlParserREPLACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWaitNowaitClauseContext is an interface to support dynamic dispatch.
|
|
type IWaitNowaitClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WAIT() antlr.TerminalNode
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
NOWAIT() antlr.TerminalNode
|
|
|
|
// IsWaitNowaitClauseContext differentiates from other interfaces.
|
|
IsWaitNowaitClauseContext()
|
|
}
|
|
|
|
type WaitNowaitClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWaitNowaitClauseContext() *WaitNowaitClauseContext {
|
|
var p = new(WaitNowaitClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_waitNowaitClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWaitNowaitClauseContext(p *WaitNowaitClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_waitNowaitClause
|
|
}
|
|
|
|
func (*WaitNowaitClauseContext) IsWaitNowaitClauseContext() {}
|
|
|
|
func NewWaitNowaitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitNowaitClauseContext {
|
|
var p = new(WaitNowaitClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_waitNowaitClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WaitNowaitClauseContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) NOWAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOWAIT, 0)
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWaitNowaitClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWaitNowaitClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *WaitNowaitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWaitNowaitClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WaitNowaitClause() (localctx IWaitNowaitClauseContext) {
|
|
localctx = NewWaitNowaitClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 646, MySqlParserRULE_waitNowaitClause)
|
|
p.SetState(6783)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserWAIT:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6780)
|
|
p.Match(MySqlParserWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6781)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
case MySqlParserNOWAIT:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6782)
|
|
p.Match(MySqlParserNOWAIT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFunctionCallContext is an interface to support dynamic dispatch.
|
|
type IFunctionCallContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsFunctionCallContext differentiates from other interfaces.
|
|
IsFunctionCallContext()
|
|
}
|
|
|
|
type FunctionCallContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFunctionCallContext() *FunctionCallContext {
|
|
var p = new(FunctionCallContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionCall
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFunctionCallContext(p *FunctionCallContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionCall
|
|
}
|
|
|
|
func (*FunctionCallContext) IsFunctionCallContext() {}
|
|
|
|
func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext {
|
|
var p = new(FunctionCallContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_functionCall
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionCallContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FunctionCallContext) CopyAll(ctx *FunctionCallContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SpecificFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewSpecificFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpecificFunctionCallContext {
|
|
var p = new(SpecificFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SpecificFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SpecificFunctionCallContext) SpecificFunction() ISpecificFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISpecificFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISpecificFunctionContext)
|
|
}
|
|
|
|
func (s *SpecificFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSpecificFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpecificFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSpecificFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SpecificFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSpecificFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PasswordFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewPasswordFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordFunctionCallContext {
|
|
var p = new(PasswordFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PasswordFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PasswordFunctionCallContext) PasswordFunctionClause() IPasswordFunctionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPasswordFunctionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPasswordFunctionClauseContext)
|
|
}
|
|
|
|
func (s *PasswordFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPasswordFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPasswordFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPasswordFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type UdfFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewUdfFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UdfFunctionCallContext {
|
|
var p = new(UdfFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) FullId() IFullIdContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullIdContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullIdContext)
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) FunctionArgs() IFunctionArgsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgsContext)
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUdfFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUdfFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *UdfFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUdfFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NonAggregateFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewNonAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NonAggregateFunctionCallContext {
|
|
var p = new(NonAggregateFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NonAggregateFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NonAggregateFunctionCallContext) NonAggregateWindowedFunction() INonAggregateWindowedFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(INonAggregateWindowedFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(INonAggregateWindowedFunctionContext)
|
|
}
|
|
|
|
func (s *NonAggregateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNonAggregateFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *NonAggregateFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNonAggregateFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *NonAggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNonAggregateFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type AggregateFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AggregateFunctionCallContext {
|
|
var p = new(AggregateFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AggregateFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AggregateFunctionCallContext) AggregateWindowedFunction() IAggregateWindowedFunctionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAggregateWindowedFunctionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAggregateWindowedFunctionContext)
|
|
}
|
|
|
|
func (s *AggregateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAggregateFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *AggregateFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAggregateFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *AggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAggregateFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ScalarFunctionCallContext struct {
|
|
FunctionCallContext
|
|
}
|
|
|
|
func NewScalarFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ScalarFunctionCallContext {
|
|
var p = new(ScalarFunctionCallContext)
|
|
|
|
InitEmptyFunctionCallContext(&p.FunctionCallContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*FunctionCallContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) ScalarFunctionName() IScalarFunctionNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IScalarFunctionNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IScalarFunctionNameContext)
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) FunctionArgs() IFunctionArgsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgsContext)
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterScalarFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitScalarFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ScalarFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitScalarFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FunctionCall() (localctx IFunctionCallContext) {
|
|
localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 648, MySqlParserRULE_functionCall)
|
|
p.SetState(6803)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1011, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSpecificFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6785)
|
|
p.SpecificFunction()
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewAggregateFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6786)
|
|
p.AggregateWindowedFunction()
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewNonAggregateFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6787)
|
|
p.NonAggregateWindowedFunction()
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewScalarFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6788)
|
|
p.ScalarFunctionName()
|
|
}
|
|
{
|
|
p.SetState(6789)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6791)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1009, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6790)
|
|
p.FunctionArgs()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6793)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewUdfFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6795)
|
|
p.FullId()
|
|
}
|
|
{
|
|
p.SetState(6796)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6798)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1010, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6797)
|
|
p.FunctionArgs()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6800)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewPasswordFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6802)
|
|
p.PasswordFunctionClause()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISpecificFunctionContext is an interface to support dynamic dispatch.
|
|
type ISpecificFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsSpecificFunctionContext differentiates from other interfaces.
|
|
IsSpecificFunctionContext()
|
|
}
|
|
|
|
type SpecificFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySpecificFunctionContext() *SpecificFunctionContext {
|
|
var p = new(SpecificFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_specificFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptySpecificFunctionContext(p *SpecificFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_specificFunction
|
|
}
|
|
|
|
func (*SpecificFunctionContext) IsSpecificFunctionContext() {}
|
|
|
|
func NewSpecificFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecificFunctionContext {
|
|
var p = new(SpecificFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_specificFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SpecificFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SpecificFunctionContext) CopyAll(ctx *SpecificFunctionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *SpecificFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SpecificFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type PositionFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
positionString IStringLiteralContext
|
|
positionExpression IExpressionContext
|
|
inString IStringLiteralContext
|
|
inExpression IExpressionContext
|
|
}
|
|
|
|
func NewPositionFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PositionFunctionCallContext {
|
|
var p = new(PositionFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) GetPositionString() IStringLiteralContext {
|
|
return s.positionString
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) GetPositionExpression() IExpressionContext {
|
|
return s.positionExpression
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) GetInString() IStringLiteralContext { return s.inString }
|
|
|
|
func (s *PositionFunctionCallContext) GetInExpression() IExpressionContext { return s.inExpression }
|
|
|
|
func (s *PositionFunctionCallContext) SetPositionString(v IStringLiteralContext) {
|
|
s.positionString = v
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) SetPositionExpression(v IExpressionContext) {
|
|
s.positionExpression = v
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) SetInString(v IStringLiteralContext) { s.inString = v }
|
|
|
|
func (s *PositionFunctionCallContext) SetInExpression(v IExpressionContext) { s.inExpression = v }
|
|
|
|
func (s *PositionFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) POSITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOSITION, 0)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) AllStringLiteral() []IStringLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IStringLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IStringLiteralContext); ok {
|
|
tst[i] = t.(IStringLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) StringLiteral(i int) IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPositionFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPositionFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *PositionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPositionFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type TrimFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
positioinForm antlr.Token
|
|
sourceString IStringLiteralContext
|
|
sourceExpression IExpressionContext
|
|
fromString IStringLiteralContext
|
|
fromExpression IExpressionContext
|
|
}
|
|
|
|
func NewTrimFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TrimFunctionCallContext {
|
|
var p = new(TrimFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) GetPositioinForm() antlr.Token { return s.positioinForm }
|
|
|
|
func (s *TrimFunctionCallContext) SetPositioinForm(v antlr.Token) { s.positioinForm = v }
|
|
|
|
func (s *TrimFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString }
|
|
|
|
func (s *TrimFunctionCallContext) GetSourceExpression() IExpressionContext { return s.sourceExpression }
|
|
|
|
func (s *TrimFunctionCallContext) GetFromString() IStringLiteralContext { return s.fromString }
|
|
|
|
func (s *TrimFunctionCallContext) GetFromExpression() IExpressionContext { return s.fromExpression }
|
|
|
|
func (s *TrimFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v }
|
|
|
|
func (s *TrimFunctionCallContext) SetSourceExpression(v IExpressionContext) { s.sourceExpression = v }
|
|
|
|
func (s *TrimFunctionCallContext) SetFromString(v IStringLiteralContext) { s.fromString = v }
|
|
|
|
func (s *TrimFunctionCallContext) SetFromExpression(v IExpressionContext) { s.fromExpression = v }
|
|
|
|
func (s *TrimFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) TRIM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIM, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) BOTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBOTH, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) LEADING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEADING, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) TRAILING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRAILING, 0)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) AllStringLiteral() []IStringLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IStringLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IStringLiteralContext); ok {
|
|
tst[i] = t.(IStringLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) StringLiteral(i int) IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTrimFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTrimFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *TrimFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTrimFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type JsonValueFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
}
|
|
|
|
func NewJsonValueFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonValueFunctionCallContext {
|
|
var p = new(JsonValueFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) JSON_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_VALUE, 0)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) RETURNING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNING, 0)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) ConvertedDataType() IConvertedDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConvertedDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConvertedDataTypeContext)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) JsonOnEmpty() IJsonOnEmptyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonOnEmptyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonOnEmptyContext)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) JsonOnError() IJsonOnErrorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonOnErrorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonOnErrorContext)
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonValueFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonValueFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonValueFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonValueFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CaseFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
elseArg IFunctionArgContext
|
|
}
|
|
|
|
func NewCaseFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseFunctionCallContext {
|
|
var p = new(CaseFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) GetElseArg() IFunctionArgContext { return s.elseArg }
|
|
|
|
func (s *CaseFunctionCallContext) SetElseArg(v IFunctionArgContext) { s.elseArg = v }
|
|
|
|
func (s *CaseFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) CASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASE, 0)
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICaseFuncAlternativeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
tst[i] = t.(ICaseFuncAlternativeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) CaseFuncAlternative(i int) ICaseFuncAlternativeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICaseFuncAlternativeContext)
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) ELSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELSE, 0)
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) FunctionArg() IFunctionArgContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgContext)
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCaseFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCaseFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCaseFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ExtractFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
sourceString IStringLiteralContext
|
|
sourceExpression IExpressionContext
|
|
}
|
|
|
|
func NewExtractFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExtractFunctionCallContext {
|
|
var p = new(ExtractFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString }
|
|
|
|
func (s *ExtractFunctionCallContext) GetSourceExpression() IExpressionContext {
|
|
return s.sourceExpression
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v }
|
|
|
|
func (s *ExtractFunctionCallContext) SetSourceExpression(v IExpressionContext) {
|
|
s.sourceExpression = v
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) EXTRACT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTRACT, 0)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) IntervalType() IIntervalTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeContext)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExtractFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExtractFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExtractFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExtractFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type DataTypeFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
separator antlr.Token
|
|
}
|
|
|
|
func NewDataTypeFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DataTypeFunctionCallContext {
|
|
var p = new(DataTypeFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) GetSeparator() antlr.Token { return s.separator }
|
|
|
|
func (s *DataTypeFunctionCallContext) SetSeparator(v antlr.Token) { s.separator = v }
|
|
|
|
func (s *DataTypeFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) CONVERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONVERT, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) ConvertedDataType() IConvertedDataTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConvertedDataTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConvertedDataTypeContext)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) CAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCAST, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDataTypeFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDataTypeFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *DataTypeFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDataTypeFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ValuesFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
}
|
|
|
|
func NewValuesFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValuesFunctionCallContext {
|
|
var p = new(ValuesFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) VALUES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUES, 0)
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterValuesFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitValuesFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *ValuesFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitValuesFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CaseExpressionFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
elseArg IFunctionArgContext
|
|
}
|
|
|
|
func NewCaseExpressionFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseExpressionFunctionCallContext {
|
|
var p = new(CaseExpressionFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) GetElseArg() IFunctionArgContext { return s.elseArg }
|
|
|
|
func (s *CaseExpressionFunctionCallContext) SetElseArg(v IFunctionArgContext) { s.elseArg = v }
|
|
|
|
func (s *CaseExpressionFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) CASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASE, 0)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ICaseFuncAlternativeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
tst[i] = t.(ICaseFuncAlternativeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) CaseFuncAlternative(i int) ICaseFuncAlternativeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICaseFuncAlternativeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICaseFuncAlternativeContext)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) ELSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELSE, 0)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) FunctionArg() IFunctionArgContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgContext)
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCaseExpressionFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCaseExpressionFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseExpressionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCaseExpressionFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CurrentUserContext struct {
|
|
SpecificFunctionContext
|
|
}
|
|
|
|
func NewCurrentUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentUserContext {
|
|
var p = new(CurrentUserContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CurrentUserContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CurrentUserContext) CurrentUserExpression() ICurrentUserExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICurrentUserExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICurrentUserExpressionContext)
|
|
}
|
|
|
|
func (s *CurrentUserContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCurrentUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentUserContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCurrentUser(s)
|
|
}
|
|
}
|
|
|
|
func (s *CurrentUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCurrentUser(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SimpleFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
}
|
|
|
|
func NewSimpleFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleFunctionCallContext {
|
|
var p = new(SimpleFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) CURRENT_DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_DATE, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) CURRENT_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIME, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) LOCALTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCALTIME, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) UTC_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTC_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSimpleFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSimpleFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SimpleFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSimpleFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CharFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
}
|
|
|
|
func NewCharFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CharFunctionCallContext {
|
|
var p = new(CharFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) FunctionArgs() IFunctionArgsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgsContext)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) USING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSING, 0)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) CharsetName() ICharsetNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICharsetNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICharsetNameContext)
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCharFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCharFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCharFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type WeightFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
stringFormat antlr.Token
|
|
}
|
|
|
|
func NewWeightFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WeightFunctionCallContext {
|
|
var p = new(WeightFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) GetStringFormat() antlr.Token { return s.stringFormat }
|
|
|
|
func (s *WeightFunctionCallContext) SetStringFormat(v antlr.Token) { s.stringFormat = v }
|
|
|
|
func (s *WeightFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) WEIGHT_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEIGHT_STRING, 0)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) AllLR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLR_BRACKET)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) LR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, i)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) AllRR_BRACKET() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserRR_BRACKET)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) RR_BRACKET(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, i)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAS, 0)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) LevelsInWeightString() ILevelsInWeightStringContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILevelsInWeightStringContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILevelsInWeightStringContext)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) CHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR, 0)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWeightFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWeightFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *WeightFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWeightFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type GetFormatFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
datetimeFormat antlr.Token
|
|
}
|
|
|
|
func NewGetFormatFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GetFormatFunctionCallContext {
|
|
var p = new(GetFormatFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) GetDatetimeFormat() antlr.Token { return s.datetimeFormat }
|
|
|
|
func (s *GetFormatFunctionCallContext) SetDatetimeFormat(v antlr.Token) { s.datetimeFormat = v }
|
|
|
|
func (s *GetFormatFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) GET_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGET_FORMAT, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) COMMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) DATETIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATETIME, 0)
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterGetFormatFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitGetFormatFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *GetFormatFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitGetFormatFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SubstrFunctionCallContext struct {
|
|
SpecificFunctionContext
|
|
sourceString IStringLiteralContext
|
|
sourceExpression IExpressionContext
|
|
fromDecimal IDecimalLiteralContext
|
|
fromExpression IExpressionContext
|
|
forDecimal IDecimalLiteralContext
|
|
forExpression IExpressionContext
|
|
}
|
|
|
|
func NewSubstrFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubstrFunctionCallContext {
|
|
var p = new(SubstrFunctionCallContext)
|
|
|
|
InitEmptySpecificFunctionContext(&p.SpecificFunctionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*SpecificFunctionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString }
|
|
|
|
func (s *SubstrFunctionCallContext) GetSourceExpression() IExpressionContext {
|
|
return s.sourceExpression
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) GetFromDecimal() IDecimalLiteralContext { return s.fromDecimal }
|
|
|
|
func (s *SubstrFunctionCallContext) GetFromExpression() IExpressionContext { return s.fromExpression }
|
|
|
|
func (s *SubstrFunctionCallContext) GetForDecimal() IDecimalLiteralContext { return s.forDecimal }
|
|
|
|
func (s *SubstrFunctionCallContext) GetForExpression() IExpressionContext { return s.forExpression }
|
|
|
|
func (s *SubstrFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v }
|
|
|
|
func (s *SubstrFunctionCallContext) SetSourceExpression(v IExpressionContext) { s.sourceExpression = v }
|
|
|
|
func (s *SubstrFunctionCallContext) SetFromDecimal(v IDecimalLiteralContext) { s.fromDecimal = v }
|
|
|
|
func (s *SubstrFunctionCallContext) SetFromExpression(v IExpressionContext) { s.fromExpression = v }
|
|
|
|
func (s *SubstrFunctionCallContext) SetForDecimal(v IDecimalLiteralContext) { s.forDecimal = v }
|
|
|
|
func (s *SubstrFunctionCallContext) SetForExpression(v IExpressionContext) { s.forExpression = v }
|
|
|
|
func (s *SubstrFunctionCallContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) SUBSTR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBSTR, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) SUBSTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBSTRING, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) StringLiteral() IStringLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IStringLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IStringLiteralContext)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) FOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOR, 0)
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubstrFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubstrFunctionCall(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubstrFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubstrFunctionCall(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) SpecificFunction() (localctx ISpecificFunctionContext) {
|
|
localctx = NewSpecificFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 650, MySqlParserRULE_specificFunction)
|
|
var _la int
|
|
|
|
p.SetState(6984)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1035, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewSimpleFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6805)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSCHEMA || ((int64((_la-313)) & ^0x3f) == 0 && ((int64(1)<<(_la-313))&262159) != 0)) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6808)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1012, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6806)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6807)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewCurrentUserContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(6810)
|
|
p.CurrentUserExpression()
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewDataTypeFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(6811)
|
|
p.Match(MySqlParserCONVERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6812)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6813)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6814)
|
|
|
|
var _m = p.Match(MySqlParserCOMMA)
|
|
|
|
localctx.(*DataTypeFunctionCallContext).separator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6815)
|
|
p.ConvertedDataType()
|
|
}
|
|
{
|
|
p.SetState(6816)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewDataTypeFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(6818)
|
|
p.Match(MySqlParserCONVERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6819)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6820)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6821)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6822)
|
|
p.CharsetName()
|
|
}
|
|
{
|
|
p.SetState(6823)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewDataTypeFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(6825)
|
|
p.Match(MySqlParserCAST)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6826)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6827)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6828)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6829)
|
|
p.ConvertedDataType()
|
|
}
|
|
{
|
|
p.SetState(6830)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewValuesFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(6832)
|
|
p.Match(MySqlParserVALUES)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6833)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6834)
|
|
p.FullColumnName()
|
|
}
|
|
{
|
|
p.SetState(6835)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewCaseExpressionFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(6837)
|
|
p.Match(MySqlParserCASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6838)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(6840)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserWHEN {
|
|
{
|
|
p.SetState(6839)
|
|
p.CaseFuncAlternative()
|
|
}
|
|
|
|
p.SetState(6842)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(6846)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserELSE {
|
|
{
|
|
p.SetState(6844)
|
|
p.Match(MySqlParserELSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6845)
|
|
|
|
var _x = p.FunctionArg()
|
|
|
|
localctx.(*CaseExpressionFunctionCallContext).elseArg = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6848)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewCaseFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(6850)
|
|
p.Match(MySqlParserCASE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6852)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserWHEN {
|
|
{
|
|
p.SetState(6851)
|
|
p.CaseFuncAlternative()
|
|
}
|
|
|
|
p.SetState(6854)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(6858)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserELSE {
|
|
{
|
|
p.SetState(6856)
|
|
p.Match(MySqlParserELSE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6857)
|
|
|
|
var _x = p.FunctionArg()
|
|
|
|
localctx.(*CaseFunctionCallContext).elseArg = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6860)
|
|
p.Match(MySqlParserEND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewCharFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(6862)
|
|
p.Match(MySqlParserCHAR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6863)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6864)
|
|
p.FunctionArgs()
|
|
}
|
|
p.SetState(6867)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserUSING {
|
|
{
|
|
p.SetState(6865)
|
|
p.Match(MySqlParserUSING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6866)
|
|
p.CharsetName()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6869)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewPositionFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(6871)
|
|
p.Match(MySqlParserPOSITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6872)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6875)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1018, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6873)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*PositionFunctionCallContext).positionString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6874)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*PositionFunctionCallContext).positionExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6877)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6880)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1019, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6878)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*PositionFunctionCallContext).inString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6879)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*PositionFunctionCallContext).inExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6882)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewSubstrFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(6884)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserSUBSTR || _la == MySqlParserSUBSTRING) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6885)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6888)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1020, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6886)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*SubstrFunctionCallContext).sourceString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6887)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*SubstrFunctionCallContext).sourceExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6890)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6893)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1021, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6891)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*SubstrFunctionCallContext).fromDecimal = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6892)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*SubstrFunctionCallContext).fromExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(6900)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserFOR {
|
|
{
|
|
p.SetState(6895)
|
|
p.Match(MySqlParserFOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6898)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1022, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6896)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*SubstrFunctionCallContext).forDecimal = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6897)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*SubstrFunctionCallContext).forExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6902)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewTrimFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(6904)
|
|
p.Match(MySqlParserTRIM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6905)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6906)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*TrimFunctionCallContext).positioinForm = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBOTH || _la == MySqlParserLEADING || _la == MySqlParserTRAILING) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*TrimFunctionCallContext).positioinForm = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
p.SetState(6909)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1024, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6907)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*TrimFunctionCallContext).sourceString = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1024, p.GetParserRuleContext()) == 2 {
|
|
{
|
|
p.SetState(6908)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*TrimFunctionCallContext).sourceExpression = _x
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6911)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6914)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1025, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6912)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*TrimFunctionCallContext).fromString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6913)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*TrimFunctionCallContext).fromExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6916)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewTrimFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(6918)
|
|
p.Match(MySqlParserTRIM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6919)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6922)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1026, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6920)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*TrimFunctionCallContext).sourceString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6921)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*TrimFunctionCallContext).sourceExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6924)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6927)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1027, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6925)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*TrimFunctionCallContext).fromString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6926)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*TrimFunctionCallContext).fromExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6929)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewWeightFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(6931)
|
|
p.Match(MySqlParserWEIGHT_STRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6932)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6935)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1028, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6933)
|
|
p.StringLiteral()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6934)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(6943)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserAS {
|
|
{
|
|
p.SetState(6937)
|
|
p.Match(MySqlParserAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6938)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*WeightFunctionCallContext).stringFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserCHAR || _la == MySqlParserBINARY) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*WeightFunctionCallContext).stringFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6939)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6940)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(6941)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(6946)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserLEVEL {
|
|
{
|
|
p.SetState(6945)
|
|
p.LevelsInWeightString()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6948)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewExtractFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(6950)
|
|
p.Match(MySqlParserEXTRACT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6951)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6952)
|
|
p.IntervalType()
|
|
}
|
|
{
|
|
p.SetState(6953)
|
|
p.Match(MySqlParserFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(6956)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1031, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(6954)
|
|
|
|
var _x = p.StringLiteral()
|
|
|
|
localctx.(*ExtractFunctionCallContext).sourceString = _x
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(6955)
|
|
|
|
var _x = p.expression(0)
|
|
|
|
localctx.(*ExtractFunctionCallContext).sourceExpression = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(6958)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 16:
|
|
localctx = NewGetFormatFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(6960)
|
|
p.Match(MySqlParserGET_FORMAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6961)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6962)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*GetFormatFunctionCallContext).datetimeFormat = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&11) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*GetFormatFunctionCallContext).datetimeFormat = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6963)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6964)
|
|
p.StringLiteral()
|
|
}
|
|
{
|
|
p.SetState(6965)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 17:
|
|
localctx = NewJsonValueFunctionCallContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(6967)
|
|
p.Match(MySqlParserJSON_VALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6968)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6969)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(6970)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6971)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(6974)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserRETURNING {
|
|
{
|
|
p.SetState(6972)
|
|
p.Match(MySqlParserRETURNING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6973)
|
|
p.ConvertedDataType()
|
|
}
|
|
|
|
}
|
|
p.SetState(6977)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(6976)
|
|
p.JsonOnEmpty()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(6980)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserDEFAULT || _la == MySqlParserNULL_LITERAL || _la == MySqlParserERROR {
|
|
{
|
|
p.SetState(6979)
|
|
p.JsonOnError()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(6982)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICaseFuncAlternativeContext is an interface to support dynamic dispatch.
|
|
type ICaseFuncAlternativeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCondition returns the condition rule contexts.
|
|
GetCondition() IFunctionArgContext
|
|
|
|
// GetConsequent returns the consequent rule contexts.
|
|
GetConsequent() IFunctionArgContext
|
|
|
|
// SetCondition sets the condition rule contexts.
|
|
SetCondition(IFunctionArgContext)
|
|
|
|
// SetConsequent sets the consequent rule contexts.
|
|
SetConsequent(IFunctionArgContext)
|
|
|
|
// Getter signatures
|
|
WHEN() antlr.TerminalNode
|
|
THEN() antlr.TerminalNode
|
|
AllFunctionArg() []IFunctionArgContext
|
|
FunctionArg(i int) IFunctionArgContext
|
|
|
|
// IsCaseFuncAlternativeContext differentiates from other interfaces.
|
|
IsCaseFuncAlternativeContext()
|
|
}
|
|
|
|
type CaseFuncAlternativeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
condition IFunctionArgContext
|
|
consequent IFunctionArgContext
|
|
}
|
|
|
|
func NewEmptyCaseFuncAlternativeContext() *CaseFuncAlternativeContext {
|
|
var p = new(CaseFuncAlternativeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseFuncAlternative
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCaseFuncAlternativeContext(p *CaseFuncAlternativeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_caseFuncAlternative
|
|
}
|
|
|
|
func (*CaseFuncAlternativeContext) IsCaseFuncAlternativeContext() {}
|
|
|
|
func NewCaseFuncAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseFuncAlternativeContext {
|
|
var p = new(CaseFuncAlternativeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_caseFuncAlternative
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CaseFuncAlternativeContext) GetCondition() IFunctionArgContext { return s.condition }
|
|
|
|
func (s *CaseFuncAlternativeContext) GetConsequent() IFunctionArgContext { return s.consequent }
|
|
|
|
func (s *CaseFuncAlternativeContext) SetCondition(v IFunctionArgContext) { s.condition = v }
|
|
|
|
func (s *CaseFuncAlternativeContext) SetConsequent(v IFunctionArgContext) { s.consequent = v }
|
|
|
|
func (s *CaseFuncAlternativeContext) WHEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWHEN, 0)
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) THEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHEN, 0)
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) AllFunctionArg() []IFunctionArgContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFunctionArgContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFunctionArgContext); ok {
|
|
tst[i] = t.(IFunctionArgContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) FunctionArg(i int) IFunctionArgContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgContext)
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCaseFuncAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCaseFuncAlternative(s)
|
|
}
|
|
}
|
|
|
|
func (s *CaseFuncAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCaseFuncAlternative(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CaseFuncAlternative() (localctx ICaseFuncAlternativeContext) {
|
|
localctx = NewCaseFuncAlternativeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 652, MySqlParserRULE_caseFuncAlternative)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6986)
|
|
p.Match(MySqlParserWHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6987)
|
|
|
|
var _x = p.FunctionArg()
|
|
|
|
localctx.(*CaseFuncAlternativeContext).condition = _x
|
|
}
|
|
{
|
|
p.SetState(6988)
|
|
p.Match(MySqlParserTHEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6989)
|
|
|
|
var _x = p.FunctionArg()
|
|
|
|
localctx.(*CaseFuncAlternativeContext).consequent = _x
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILevelsInWeightStringContext is an interface to support dynamic dispatch.
|
|
type ILevelsInWeightStringContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsLevelsInWeightStringContext differentiates from other interfaces.
|
|
IsLevelsInWeightStringContext()
|
|
}
|
|
|
|
type LevelsInWeightStringContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLevelsInWeightStringContext() *LevelsInWeightStringContext {
|
|
var p = new(LevelsInWeightStringContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_levelsInWeightString
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLevelsInWeightStringContext(p *LevelsInWeightStringContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_levelsInWeightString
|
|
}
|
|
|
|
func (*LevelsInWeightStringContext) IsLevelsInWeightStringContext() {}
|
|
|
|
func NewLevelsInWeightStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelsInWeightStringContext {
|
|
var p = new(LevelsInWeightStringContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_levelsInWeightString
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LevelsInWeightStringContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LevelsInWeightStringContext) CopyAll(ctx *LevelsInWeightStringContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *LevelsInWeightStringContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LevelsInWeightStringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type LevelWeightRangeContext struct {
|
|
LevelsInWeightStringContext
|
|
firstLevel IDecimalLiteralContext
|
|
lastLevel IDecimalLiteralContext
|
|
}
|
|
|
|
func NewLevelWeightRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightRangeContext {
|
|
var p = new(LevelWeightRangeContext)
|
|
|
|
InitEmptyLevelsInWeightStringContext(&p.LevelsInWeightStringContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*LevelsInWeightStringContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) GetFirstLevel() IDecimalLiteralContext { return s.firstLevel }
|
|
|
|
func (s *LevelWeightRangeContext) GetLastLevel() IDecimalLiteralContext { return s.lastLevel }
|
|
|
|
func (s *LevelWeightRangeContext) SetFirstLevel(v IDecimalLiteralContext) { s.firstLevel = v }
|
|
|
|
func (s *LevelWeightRangeContext) SetLastLevel(v IDecimalLiteralContext) { s.lastLevel = v }
|
|
|
|
func (s *LevelWeightRangeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) LEVEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEVEL, 0)
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) MINUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, 0)
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLevelWeightRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLevelWeightRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelWeightRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLevelWeightRange(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type LevelWeightListContext struct {
|
|
LevelsInWeightStringContext
|
|
}
|
|
|
|
func NewLevelWeightListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightListContext {
|
|
var p = new(LevelWeightListContext)
|
|
|
|
InitEmptyLevelsInWeightStringContext(&p.LevelsInWeightStringContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*LevelsInWeightStringContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LevelWeightListContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LevelWeightListContext) LEVEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEVEL, 0)
|
|
}
|
|
|
|
func (s *LevelWeightListContext) AllLevelInWeightListElement() []ILevelInWeightListElementContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ILevelInWeightListElementContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ILevelInWeightListElementContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ILevelInWeightListElementContext); ok {
|
|
tst[i] = t.(ILevelInWeightListElementContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LevelWeightListContext) LevelInWeightListElement(i int) ILevelInWeightListElementContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILevelInWeightListElementContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILevelInWeightListElementContext)
|
|
}
|
|
|
|
func (s *LevelWeightListContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *LevelWeightListContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *LevelWeightListContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLevelWeightList(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelWeightListContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLevelWeightList(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelWeightListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLevelWeightList(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LevelsInWeightString() (localctx ILevelsInWeightStringContext) {
|
|
localctx = NewLevelsInWeightStringContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 654, MySqlParserRULE_levelsInWeightString)
|
|
var _la int
|
|
|
|
p.SetState(7005)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1037, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewLevelWeightListContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(6991)
|
|
p.Match(MySqlParserLEVEL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6992)
|
|
p.LevelInWeightListElement()
|
|
}
|
|
p.SetState(6997)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(6993)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(6994)
|
|
p.LevelInWeightListElement()
|
|
}
|
|
|
|
p.SetState(6999)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewLevelWeightRangeContext(p, localctx)
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7000)
|
|
p.Match(MySqlParserLEVEL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7001)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*LevelWeightRangeContext).firstLevel = _x
|
|
}
|
|
{
|
|
p.SetState(7002)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7003)
|
|
|
|
var _x = p.DecimalLiteral()
|
|
|
|
localctx.(*LevelWeightRangeContext).lastLevel = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILevelInWeightListElementContext is an interface to support dynamic dispatch.
|
|
type ILevelInWeightListElementContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOrderType returns the orderType token.
|
|
GetOrderType() antlr.Token
|
|
|
|
// SetOrderType sets the orderType token.
|
|
SetOrderType(antlr.Token)
|
|
|
|
// Getter signatures
|
|
DecimalLiteral() IDecimalLiteralContext
|
|
ASC() antlr.TerminalNode
|
|
DESC() antlr.TerminalNode
|
|
REVERSE() antlr.TerminalNode
|
|
|
|
// IsLevelInWeightListElementContext differentiates from other interfaces.
|
|
IsLevelInWeightListElementContext()
|
|
}
|
|
|
|
type LevelInWeightListElementContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
orderType antlr.Token
|
|
}
|
|
|
|
func NewEmptyLevelInWeightListElementContext() *LevelInWeightListElementContext {
|
|
var p = new(LevelInWeightListElementContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_levelInWeightListElement
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLevelInWeightListElementContext(p *LevelInWeightListElementContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_levelInWeightListElement
|
|
}
|
|
|
|
func (*LevelInWeightListElementContext) IsLevelInWeightListElementContext() {}
|
|
|
|
func NewLevelInWeightListElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelInWeightListElementContext {
|
|
var p = new(LevelInWeightListElementContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_levelInWeightListElement
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LevelInWeightListElementContext) GetOrderType() antlr.Token { return s.orderType }
|
|
|
|
func (s *LevelInWeightListElementContext) SetOrderType(v antlr.Token) { s.orderType = v }
|
|
|
|
func (s *LevelInWeightListElementContext) DecimalLiteral() IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) ASC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASC, 0)
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) DESC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDESC, 0)
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) REVERSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVERSE, 0)
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLevelInWeightListElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLevelInWeightListElement(s)
|
|
}
|
|
}
|
|
|
|
func (s *LevelInWeightListElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLevelInWeightListElement(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LevelInWeightListElement() (localctx ILevelInWeightListElementContext) {
|
|
localctx = NewLevelInWeightListElementContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 656, MySqlParserRULE_levelInWeightListElement)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7007)
|
|
p.DecimalLiteral()
|
|
}
|
|
p.SetState(7009)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserASC || _la == MySqlParserDESC || _la == MySqlParserREVERSE {
|
|
{
|
|
p.SetState(7008)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*LevelInWeightListElementContext).orderType = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserASC || _la == MySqlParserDESC || _la == MySqlParserREVERSE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*LevelInWeightListElementContext).orderType = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAggregateWindowedFunctionContext is an interface to support dynamic dispatch.
|
|
type IAggregateWindowedFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetAggregator returns the aggregator token.
|
|
GetAggregator() antlr.Token
|
|
|
|
// GetStarArg returns the starArg token.
|
|
GetStarArg() antlr.Token
|
|
|
|
// GetSeparator returns the separator token.
|
|
GetSeparator() antlr.Token
|
|
|
|
// SetAggregator sets the aggregator token.
|
|
SetAggregator(antlr.Token)
|
|
|
|
// SetStarArg sets the starArg token.
|
|
SetStarArg(antlr.Token)
|
|
|
|
// SetSeparator sets the separator token.
|
|
SetSeparator(antlr.Token)
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
FunctionArg() IFunctionArgContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
AVG() antlr.TerminalNode
|
|
MAX() antlr.TerminalNode
|
|
MIN() antlr.TerminalNode
|
|
SUM() antlr.TerminalNode
|
|
OverClause() IOverClauseContext
|
|
ALL() antlr.TerminalNode
|
|
DISTINCT() antlr.TerminalNode
|
|
COUNT() antlr.TerminalNode
|
|
FunctionArgs() IFunctionArgsContext
|
|
STAR() antlr.TerminalNode
|
|
BIT_AND() antlr.TerminalNode
|
|
BIT_OR() antlr.TerminalNode
|
|
BIT_XOR() antlr.TerminalNode
|
|
STD() antlr.TerminalNode
|
|
STDDEV() antlr.TerminalNode
|
|
STDDEV_POP() antlr.TerminalNode
|
|
STDDEV_SAMP() antlr.TerminalNode
|
|
VAR_POP() antlr.TerminalNode
|
|
VAR_SAMP() antlr.TerminalNode
|
|
VARIANCE() antlr.TerminalNode
|
|
GROUP_CONCAT() antlr.TerminalNode
|
|
ORDER() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
AllOrderByExpression() []IOrderByExpressionContext
|
|
OrderByExpression(i int) IOrderByExpressionContext
|
|
SEPARATOR() antlr.TerminalNode
|
|
STRING_LITERAL() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsAggregateWindowedFunctionContext differentiates from other interfaces.
|
|
IsAggregateWindowedFunctionContext()
|
|
}
|
|
|
|
type AggregateWindowedFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
aggregator antlr.Token
|
|
starArg antlr.Token
|
|
separator antlr.Token
|
|
}
|
|
|
|
func NewEmptyAggregateWindowedFunctionContext() *AggregateWindowedFunctionContext {
|
|
var p = new(AggregateWindowedFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAggregateWindowedFunctionContext(p *AggregateWindowedFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction
|
|
}
|
|
|
|
func (*AggregateWindowedFunctionContext) IsAggregateWindowedFunctionContext() {}
|
|
|
|
func NewAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateWindowedFunctionContext {
|
|
var p = new(AggregateWindowedFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AggregateWindowedFunctionContext) GetAggregator() antlr.Token { return s.aggregator }
|
|
|
|
func (s *AggregateWindowedFunctionContext) GetStarArg() antlr.Token { return s.starArg }
|
|
|
|
func (s *AggregateWindowedFunctionContext) GetSeparator() antlr.Token { return s.separator }
|
|
|
|
func (s *AggregateWindowedFunctionContext) SetAggregator(v antlr.Token) { s.aggregator = v }
|
|
|
|
func (s *AggregateWindowedFunctionContext) SetStarArg(v antlr.Token) { s.starArg = v }
|
|
|
|
func (s *AggregateWindowedFunctionContext) SetSeparator(v antlr.Token) { s.separator = v }
|
|
|
|
func (s *AggregateWindowedFunctionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) FunctionArg() IFunctionArgContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgContext)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) AVG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAVG, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) MAX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) MIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIN, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) SUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUM, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) OverClause() IOverClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOverClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOverClauseContext)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISTINCT, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOUNT, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) FunctionArgs() IFunctionArgsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgsContext)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) BIT_AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_AND, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) BIT_OR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_OR, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) BIT_XOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_XOR, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTD, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STDDEV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STDDEV_POP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV_POP, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STDDEV_SAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV_SAMP, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) VAR_POP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_POP, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) VAR_SAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_SAMP, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) VARIANCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARIANCE, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) GROUP_CONCAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_CONCAT, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) ORDER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDER, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) AllOrderByExpression() []IOrderByExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IOrderByExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IOrderByExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IOrderByExpressionContext); ok {
|
|
tst[i] = t.(IOrderByExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) OrderByExpression(i int) IOrderByExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByExpressionContext)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) SEPARATOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEPARATOR, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAggregateWindowedFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAggregateWindowedFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *AggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAggregateWindowedFunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AggregateWindowedFunction() (localctx IAggregateWindowedFunctionContext) {
|
|
localctx = NewAggregateWindowedFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 658, MySqlParserRULE_aggregateWindowedFunction)
|
|
var _la int
|
|
|
|
p.SetState(7070)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserAVG, MySqlParserMAX, MySqlParserMIN, MySqlParserSUM:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7011)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-286)) & ^0x3f) == 0 && ((int64(1)<<(_la-286))&8400897) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7012)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7014)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7013)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7016)
|
|
p.FunctionArg()
|
|
}
|
|
{
|
|
p.SetState(7017)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7019)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7018)
|
|
p.OverClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserCOUNT:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7021)
|
|
p.Match(MySqlParserCOUNT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7022)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7030)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1042, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(7023)
|
|
|
|
var _m = p.Match(MySqlParserSTAR)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).starArg = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.SetState(7025)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7024)
|
|
|
|
var _m = p.Match(MySqlParserALL)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7027)
|
|
p.FunctionArg()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(7028)
|
|
|
|
var _m = p.Match(MySqlParserDISTINCT)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7029)
|
|
p.FunctionArgs()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7032)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7034)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1043, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7033)
|
|
p.OverClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7036)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-287)) & ^0x3f) == 0 && ((int64(1)<<(_la-287))&62652423) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7037)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7039)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1044, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7038)
|
|
|
|
var _m = p.Match(MySqlParserALL)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7041)
|
|
p.FunctionArg()
|
|
}
|
|
{
|
|
p.SetState(7042)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7044)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1045, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7043)
|
|
p.OverClause()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case MySqlParserGROUP_CONCAT:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7046)
|
|
p.Match(MySqlParserGROUP_CONCAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7047)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7049)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1046, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7048)
|
|
|
|
var _m = p.Match(MySqlParserDISTINCT)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).aggregator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7051)
|
|
p.FunctionArgs()
|
|
}
|
|
p.SetState(7062)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserORDER {
|
|
{
|
|
p.SetState(7052)
|
|
p.Match(MySqlParserORDER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7053)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7054)
|
|
p.OrderByExpression()
|
|
}
|
|
p.SetState(7059)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7055)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7056)
|
|
p.OrderByExpression()
|
|
}
|
|
|
|
p.SetState(7061)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
}
|
|
p.SetState(7066)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserSEPARATOR {
|
|
{
|
|
p.SetState(7064)
|
|
p.Match(MySqlParserSEPARATOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7065)
|
|
|
|
var _m = p.Match(MySqlParserSTRING_LITERAL)
|
|
|
|
localctx.(*AggregateWindowedFunctionContext).separator = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7068)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// INonAggregateWindowedFunctionContext is an interface to support dynamic dispatch.
|
|
type INonAggregateWindowedFunctionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
OverClause() IOverClauseContext
|
|
LAG() antlr.TerminalNode
|
|
LEAD() antlr.TerminalNode
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
AllDecimalLiteral() []IDecimalLiteralContext
|
|
DecimalLiteral(i int) IDecimalLiteralContext
|
|
FIRST_VALUE() antlr.TerminalNode
|
|
LAST_VALUE() antlr.TerminalNode
|
|
CUME_DIST() antlr.TerminalNode
|
|
DENSE_RANK() antlr.TerminalNode
|
|
PERCENT_RANK() antlr.TerminalNode
|
|
RANK() antlr.TerminalNode
|
|
ROW_NUMBER() antlr.TerminalNode
|
|
NTH_VALUE() antlr.TerminalNode
|
|
NTILE() antlr.TerminalNode
|
|
|
|
// IsNonAggregateWindowedFunctionContext differentiates from other interfaces.
|
|
IsNonAggregateWindowedFunctionContext()
|
|
}
|
|
|
|
type NonAggregateWindowedFunctionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyNonAggregateWindowedFunctionContext() *NonAggregateWindowedFunctionContext {
|
|
var p = new(NonAggregateWindowedFunctionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction
|
|
return p
|
|
}
|
|
|
|
func InitEmptyNonAggregateWindowedFunctionContext(p *NonAggregateWindowedFunctionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction
|
|
}
|
|
|
|
func (*NonAggregateWindowedFunctionContext) IsNonAggregateWindowedFunctionContext() {}
|
|
|
|
func NewNonAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonAggregateWindowedFunctionContext {
|
|
var p = new(NonAggregateWindowedFunctionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) OverClause() IOverClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOverClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOverClauseContext)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) LAG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAG, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) LEAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAD, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) AllDecimalLiteral() []IDecimalLiteralContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IDecimalLiteralContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IDecimalLiteralContext); ok {
|
|
tst[i] = t.(IDecimalLiteralContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) DecimalLiteral(i int) IDecimalLiteralContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IDecimalLiteralContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IDecimalLiteralContext)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) FIRST_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST_VALUE, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) LAST_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST_VALUE, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) CUME_DIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCUME_DIST, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) DENSE_RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDENSE_RANK, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) PERCENT_RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERCENT_RANK, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANK, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) ROW_NUMBER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_NUMBER, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) NTH_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNTH_VALUE, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) NTILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNTILE, 0)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNonAggregateWindowedFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNonAggregateWindowedFunction(s)
|
|
}
|
|
}
|
|
|
|
func (s *NonAggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNonAggregateWindowedFunction(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) NonAggregateWindowedFunction() (localctx INonAggregateWindowedFunctionContext) {
|
|
localctx = NewNonAggregateWindowedFunctionContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 660, MySqlParserRULE_nonAggregateWindowedFunction)
|
|
var _la int
|
|
|
|
p.SetState(7110)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLAG, MySqlParserLEAD:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7072)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserLAG || _la == MySqlParserLEAD) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7073)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7074)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(7077)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1051, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7075)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7076)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(7081)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7079)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7080)
|
|
p.DecimalLiteral()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7083)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7084)
|
|
p.OverClause()
|
|
}
|
|
|
|
case MySqlParserFIRST_VALUE, MySqlParserLAST_VALUE:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7086)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFIRST_VALUE || _la == MySqlParserLAST_VALUE) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7087)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7088)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(7089)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7090)
|
|
p.OverClause()
|
|
}
|
|
|
|
case MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7092)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-291)) & ^0x3f) == 0 && ((int64(1)<<(_la-291))&14339) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7093)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7094)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7095)
|
|
p.OverClause()
|
|
}
|
|
|
|
case MySqlParserNTH_VALUE:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7096)
|
|
p.Match(MySqlParserNTH_VALUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7097)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7098)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(7099)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7100)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(7101)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7102)
|
|
p.OverClause()
|
|
}
|
|
|
|
case MySqlParserNTILE:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(7104)
|
|
p.Match(MySqlParserNTILE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7105)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7106)
|
|
p.DecimalLiteral()
|
|
}
|
|
{
|
|
p.SetState(7107)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7108)
|
|
p.OverClause()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IOverClauseContext is an interface to support dynamic dispatch.
|
|
type IOverClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
OVER() antlr.TerminalNode
|
|
LR_BRACKET() antlr.TerminalNode
|
|
WindowSpec() IWindowSpecContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
WindowName() IWindowNameContext
|
|
|
|
// IsOverClauseContext differentiates from other interfaces.
|
|
IsOverClauseContext()
|
|
}
|
|
|
|
type OverClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyOverClauseContext() *OverClauseContext {
|
|
var p = new(OverClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_overClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyOverClauseContext(p *OverClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_overClause
|
|
}
|
|
|
|
func (*OverClauseContext) IsOverClauseContext() {}
|
|
|
|
func NewOverClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OverClauseContext {
|
|
var p = new(OverClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_overClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *OverClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *OverClauseContext) OVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOVER, 0)
|
|
}
|
|
|
|
func (s *OverClauseContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *OverClauseContext) WindowSpec() IWindowSpecContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowSpecContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowSpecContext)
|
|
}
|
|
|
|
func (s *OverClauseContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *OverClauseContext) WindowName() IWindowNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowNameContext)
|
|
}
|
|
|
|
func (s *OverClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *OverClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *OverClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterOverClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *OverClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitOverClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *OverClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitOverClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) OverClause() (localctx IOverClauseContext) {
|
|
localctx = NewOverClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 662, MySqlParserRULE_overClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7112)
|
|
p.Match(MySqlParserOVER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7118)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLR_BRACKET:
|
|
{
|
|
p.SetState(7113)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7114)
|
|
p.WindowSpec()
|
|
}
|
|
{
|
|
p.SetState(7115)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID:
|
|
{
|
|
p.SetState(7117)
|
|
p.WindowName()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWindowSpecContext is an interface to support dynamic dispatch.
|
|
type IWindowSpecContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
WindowName() IWindowNameContext
|
|
PartitionClause() IPartitionClauseContext
|
|
OrderByClause() IOrderByClauseContext
|
|
FrameClause() IFrameClauseContext
|
|
|
|
// IsWindowSpecContext differentiates from other interfaces.
|
|
IsWindowSpecContext()
|
|
}
|
|
|
|
type WindowSpecContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWindowSpecContext() *WindowSpecContext {
|
|
var p = new(WindowSpecContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowSpec
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWindowSpecContext(p *WindowSpecContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowSpec
|
|
}
|
|
|
|
func (*WindowSpecContext) IsWindowSpecContext() {}
|
|
|
|
func NewWindowSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowSpecContext {
|
|
var p = new(WindowSpecContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_windowSpec
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WindowSpecContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WindowSpecContext) WindowName() IWindowNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IWindowNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IWindowNameContext)
|
|
}
|
|
|
|
func (s *WindowSpecContext) PartitionClause() IPartitionClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPartitionClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPartitionClauseContext)
|
|
}
|
|
|
|
func (s *WindowSpecContext) OrderByClause() IOrderByClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IOrderByClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IOrderByClauseContext)
|
|
}
|
|
|
|
func (s *WindowSpecContext) FrameClause() IFrameClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameClauseContext)
|
|
}
|
|
|
|
func (s *WindowSpecContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WindowSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WindowSpecContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWindowSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowSpecContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWindowSpec(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWindowSpec(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WindowSpec() (localctx IWindowSpecContext) {
|
|
localctx = NewWindowSpecContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 664, MySqlParserRULE_windowSpec)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(7121)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1055, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7120)
|
|
p.WindowName()
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
p.SetState(7124)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserPARTITION {
|
|
{
|
|
p.SetState(7123)
|
|
p.PartitionClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(7127)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserORDER {
|
|
{
|
|
p.SetState(7126)
|
|
p.OrderByClause()
|
|
}
|
|
|
|
}
|
|
p.SetState(7130)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserRANGE || _la == MySqlParserROWS {
|
|
{
|
|
p.SetState(7129)
|
|
p.FrameClause()
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IWindowNameContext is an interface to support dynamic dispatch.
|
|
type IWindowNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Uid() IUidContext
|
|
|
|
// IsWindowNameContext differentiates from other interfaces.
|
|
IsWindowNameContext()
|
|
}
|
|
|
|
type WindowNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyWindowNameContext() *WindowNameContext {
|
|
var p = new(WindowNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyWindowNameContext(p *WindowNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_windowName
|
|
}
|
|
|
|
func (*WindowNameContext) IsWindowNameContext() {}
|
|
|
|
func NewWindowNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowNameContext {
|
|
var p = new(WindowNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_windowName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *WindowNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *WindowNameContext) Uid() IUidContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUidContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUidContext)
|
|
}
|
|
|
|
func (s *WindowNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *WindowNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *WindowNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterWindowName(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitWindowName(s)
|
|
}
|
|
}
|
|
|
|
func (s *WindowNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitWindowName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) WindowName() (localctx IWindowNameContext) {
|
|
localctx = NewWindowNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 666, MySqlParserRULE_windowName)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7132)
|
|
p.Uid()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFrameClauseContext is an interface to support dynamic dispatch.
|
|
type IFrameClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FrameUnits() IFrameUnitsContext
|
|
FrameExtent() IFrameExtentContext
|
|
|
|
// IsFrameClauseContext differentiates from other interfaces.
|
|
IsFrameClauseContext()
|
|
}
|
|
|
|
type FrameClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFrameClauseContext() *FrameClauseContext {
|
|
var p = new(FrameClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFrameClauseContext(p *FrameClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameClause
|
|
}
|
|
|
|
func (*FrameClauseContext) IsFrameClauseContext() {}
|
|
|
|
func NewFrameClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameClauseContext {
|
|
var p = new(FrameClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_frameClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FrameClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FrameClauseContext) FrameUnits() IFrameUnitsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameUnitsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameUnitsContext)
|
|
}
|
|
|
|
func (s *FrameClauseContext) FrameExtent() IFrameExtentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameExtentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameExtentContext)
|
|
}
|
|
|
|
func (s *FrameClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FrameClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FrameClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFrameClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFrameClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFrameClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FrameClause() (localctx IFrameClauseContext) {
|
|
localctx = NewFrameClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 668, MySqlParserRULE_frameClause)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7134)
|
|
p.FrameUnits()
|
|
}
|
|
{
|
|
p.SetState(7135)
|
|
p.FrameExtent()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFrameUnitsContext is an interface to support dynamic dispatch.
|
|
type IFrameUnitsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ROWS() antlr.TerminalNode
|
|
RANGE() antlr.TerminalNode
|
|
|
|
// IsFrameUnitsContext differentiates from other interfaces.
|
|
IsFrameUnitsContext()
|
|
}
|
|
|
|
type FrameUnitsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFrameUnitsContext() *FrameUnitsContext {
|
|
var p = new(FrameUnitsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameUnits
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFrameUnitsContext(p *FrameUnitsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameUnits
|
|
}
|
|
|
|
func (*FrameUnitsContext) IsFrameUnitsContext() {}
|
|
|
|
func NewFrameUnitsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameUnitsContext {
|
|
var p = new(FrameUnitsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_frameUnits
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FrameUnitsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FrameUnitsContext) ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROWS, 0)
|
|
}
|
|
|
|
func (s *FrameUnitsContext) RANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANGE, 0)
|
|
}
|
|
|
|
func (s *FrameUnitsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FrameUnitsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FrameUnitsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFrameUnits(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameUnitsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFrameUnits(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameUnitsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFrameUnits(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FrameUnits() (localctx IFrameUnitsContext) {
|
|
localctx = NewFrameUnitsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 670, MySqlParserRULE_frameUnits)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7137)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserRANGE || _la == MySqlParserROWS) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFrameExtentContext is an interface to support dynamic dispatch.
|
|
type IFrameExtentContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FrameRange() IFrameRangeContext
|
|
FrameBetween() IFrameBetweenContext
|
|
|
|
// IsFrameExtentContext differentiates from other interfaces.
|
|
IsFrameExtentContext()
|
|
}
|
|
|
|
type FrameExtentContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFrameExtentContext() *FrameExtentContext {
|
|
var p = new(FrameExtentContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameExtent
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFrameExtentContext(p *FrameExtentContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameExtent
|
|
}
|
|
|
|
func (*FrameExtentContext) IsFrameExtentContext() {}
|
|
|
|
func NewFrameExtentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameExtentContext {
|
|
var p = new(FrameExtentContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_frameExtent
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FrameExtentContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FrameExtentContext) FrameRange() IFrameRangeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameRangeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameRangeContext)
|
|
}
|
|
|
|
func (s *FrameExtentContext) FrameBetween() IFrameBetweenContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameBetweenContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameBetweenContext)
|
|
}
|
|
|
|
func (s *FrameExtentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FrameExtentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FrameExtentContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFrameExtent(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameExtentContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFrameExtent(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameExtentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFrameExtent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FrameExtent() (localctx IFrameExtentContext) {
|
|
localctx = NewFrameExtentContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 672, MySqlParserRULE_frameExtent)
|
|
p.SetState(7141)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7139)
|
|
p.FrameRange()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7140)
|
|
p.FrameBetween()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFrameBetweenContext is an interface to support dynamic dispatch.
|
|
type IFrameBetweenContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
BETWEEN() antlr.TerminalNode
|
|
AllFrameRange() []IFrameRangeContext
|
|
FrameRange(i int) IFrameRangeContext
|
|
AND() antlr.TerminalNode
|
|
|
|
// IsFrameBetweenContext differentiates from other interfaces.
|
|
IsFrameBetweenContext()
|
|
}
|
|
|
|
type FrameBetweenContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFrameBetweenContext() *FrameBetweenContext {
|
|
var p = new(FrameBetweenContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameBetween
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFrameBetweenContext(p *FrameBetweenContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameBetween
|
|
}
|
|
|
|
func (*FrameBetweenContext) IsFrameBetweenContext() {}
|
|
|
|
func NewFrameBetweenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameBetweenContext {
|
|
var p = new(FrameBetweenContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_frameBetween
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FrameBetweenContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FrameBetweenContext) BETWEEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBETWEEN, 0)
|
|
}
|
|
|
|
func (s *FrameBetweenContext) AllFrameRange() []IFrameRangeContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFrameRangeContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFrameRangeContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFrameRangeContext); ok {
|
|
tst[i] = t.(IFrameRangeContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FrameBetweenContext) FrameRange(i int) IFrameRangeContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFrameRangeContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFrameRangeContext)
|
|
}
|
|
|
|
func (s *FrameBetweenContext) AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, 0)
|
|
}
|
|
|
|
func (s *FrameBetweenContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FrameBetweenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FrameBetweenContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFrameBetween(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameBetweenContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFrameBetween(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameBetweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFrameBetween(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FrameBetween() (localctx IFrameBetweenContext) {
|
|
localctx = NewFrameBetweenContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 674, MySqlParserRULE_frameBetween)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7143)
|
|
p.Match(MySqlParserBETWEEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7144)
|
|
p.FrameRange()
|
|
}
|
|
{
|
|
p.SetState(7145)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7146)
|
|
p.FrameRange()
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFrameRangeContext is an interface to support dynamic dispatch.
|
|
type IFrameRangeContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CURRENT() antlr.TerminalNode
|
|
ROW() antlr.TerminalNode
|
|
UNBOUNDED() antlr.TerminalNode
|
|
PRECEDING() antlr.TerminalNode
|
|
FOLLOWING() antlr.TerminalNode
|
|
Expression() IExpressionContext
|
|
|
|
// IsFrameRangeContext differentiates from other interfaces.
|
|
IsFrameRangeContext()
|
|
}
|
|
|
|
type FrameRangeContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFrameRangeContext() *FrameRangeContext {
|
|
var p = new(FrameRangeContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameRange
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFrameRangeContext(p *FrameRangeContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_frameRange
|
|
}
|
|
|
|
func (*FrameRangeContext) IsFrameRangeContext() {}
|
|
|
|
func NewFrameRangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameRangeContext {
|
|
var p = new(FrameRangeContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_frameRange
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FrameRangeContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FrameRangeContext) CURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT, 0)
|
|
}
|
|
|
|
func (s *FrameRangeContext) ROW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW, 0)
|
|
}
|
|
|
|
func (s *FrameRangeContext) UNBOUNDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNBOUNDED, 0)
|
|
}
|
|
|
|
func (s *FrameRangeContext) PRECEDING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRECEDING, 0)
|
|
}
|
|
|
|
func (s *FrameRangeContext) FOLLOWING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOLLOWING, 0)
|
|
}
|
|
|
|
func (s *FrameRangeContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *FrameRangeContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FrameRangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FrameRangeContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFrameRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameRangeContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFrameRange(s)
|
|
}
|
|
}
|
|
|
|
func (s *FrameRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFrameRange(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FrameRange() (localctx IFrameRangeContext) {
|
|
localctx = NewFrameRangeContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 676, MySqlParserRULE_frameRange)
|
|
var _la int
|
|
|
|
p.SetState(7155)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1060, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7148)
|
|
p.Match(MySqlParserCURRENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7149)
|
|
p.Match(MySqlParserROW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7150)
|
|
p.Match(MySqlParserUNBOUNDED)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7151)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFOLLOWING || _la == MySqlParserPRECEDING) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7152)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(7153)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFOLLOWING || _la == MySqlParserPRECEDING) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPartitionClauseContext is an interface to support dynamic dispatch.
|
|
type IPartitionClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
PARTITION() antlr.TerminalNode
|
|
BY() antlr.TerminalNode
|
|
AllExpression() []IExpressionContext
|
|
Expression(i int) IExpressionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsPartitionClauseContext differentiates from other interfaces.
|
|
IsPartitionClauseContext()
|
|
}
|
|
|
|
type PartitionClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPartitionClauseContext() *PartitionClauseContext {
|
|
var p = new(PartitionClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPartitionClauseContext(p *PartitionClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_partitionClause
|
|
}
|
|
|
|
func (*PartitionClauseContext) IsPartitionClauseContext() {}
|
|
|
|
func NewPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionClauseContext {
|
|
var p = new(PartitionClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_partitionClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PartitionClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PartitionClauseContext) PARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITION, 0)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) BY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBY, 0)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PartitionClauseContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PartitionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPartitionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPartitionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPartitionClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PartitionClause() (localctx IPartitionClauseContext) {
|
|
localctx = NewPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 678, MySqlParserRULE_partitionClause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7157)
|
|
p.Match(MySqlParserPARTITION)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7158)
|
|
p.Match(MySqlParserBY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7159)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(7164)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7160)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7161)
|
|
p.expression(0)
|
|
}
|
|
|
|
p.SetState(7166)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IScalarFunctionNameContext is an interface to support dynamic dispatch.
|
|
type IScalarFunctionNameContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
FunctionNameBase() IFunctionNameBaseContext
|
|
ASCII() antlr.TerminalNode
|
|
CURDATE() antlr.TerminalNode
|
|
CURRENT_DATE() antlr.TerminalNode
|
|
CURRENT_TIME() antlr.TerminalNode
|
|
CURRENT_TIMESTAMP() antlr.TerminalNode
|
|
CURTIME() antlr.TerminalNode
|
|
DATE_ADD() antlr.TerminalNode
|
|
DATE_SUB() antlr.TerminalNode
|
|
IF() antlr.TerminalNode
|
|
INSERT() antlr.TerminalNode
|
|
LOCALTIME() antlr.TerminalNode
|
|
LOCALTIMESTAMP() antlr.TerminalNode
|
|
MID() antlr.TerminalNode
|
|
NOW() antlr.TerminalNode
|
|
REPEAT() antlr.TerminalNode
|
|
REPLACE() antlr.TerminalNode
|
|
SUBSTR() antlr.TerminalNode
|
|
SUBSTRING() antlr.TerminalNode
|
|
SYSDATE() antlr.TerminalNode
|
|
TRIM() antlr.TerminalNode
|
|
UTC_DATE() antlr.TerminalNode
|
|
UTC_TIME() antlr.TerminalNode
|
|
UTC_TIMESTAMP() antlr.TerminalNode
|
|
|
|
// IsScalarFunctionNameContext differentiates from other interfaces.
|
|
IsScalarFunctionNameContext()
|
|
}
|
|
|
|
type ScalarFunctionNameContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyScalarFunctionNameContext() *ScalarFunctionNameContext {
|
|
var p = new(ScalarFunctionNameContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_scalarFunctionName
|
|
return p
|
|
}
|
|
|
|
func InitEmptyScalarFunctionNameContext(p *ScalarFunctionNameContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_scalarFunctionName
|
|
}
|
|
|
|
func (*ScalarFunctionNameContext) IsScalarFunctionNameContext() {}
|
|
|
|
func NewScalarFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScalarFunctionNameContext {
|
|
var p = new(ScalarFunctionNameContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_scalarFunctionName
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ScalarFunctionNameContext) FunctionNameBase() IFunctionNameBaseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionNameBaseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionNameBaseContext)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) ASCII() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASCII, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) CURDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURDATE, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) CURRENT_DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_DATE, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) CURRENT_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIME, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) CURTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURTIME, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) DATE_ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE_ADD, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) DATE_SUB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE_SUB, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) IF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIF, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) LOCALTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCALTIME, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) LOCALTIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCALTIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) MID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMID, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) NOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOW, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) REPEAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPEAT, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLACE, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) SUBSTR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBSTR, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) SUBSTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBSTRING, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) SYSDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSYSDATE, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) TRIM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIM, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) UTC_DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTC_DATE, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) UTC_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTC_TIME, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) UTC_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTC_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterScalarFunctionName(s)
|
|
}
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitScalarFunctionName(s)
|
|
}
|
|
}
|
|
|
|
func (s *ScalarFunctionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitScalarFunctionName(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ScalarFunctionName() (localctx IScalarFunctionNameContext) {
|
|
localctx = NewScalarFunctionNameContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 680, MySqlParserRULE_scalarFunctionName)
|
|
p.SetState(7191)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserDATABASE, MySqlParserLEFT, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserYEAR, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserPOSITION, MySqlParserINVISIBLE, MySqlParserVISIBLE, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7167)
|
|
p.FunctionNameBase()
|
|
}
|
|
|
|
case MySqlParserASCII:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7168)
|
|
p.Match(MySqlParserASCII)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCURDATE:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7169)
|
|
p.Match(MySqlParserCURDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCURRENT_DATE:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7170)
|
|
p.Match(MySqlParserCURRENT_DATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCURRENT_TIME:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(7171)
|
|
p.Match(MySqlParserCURRENT_TIME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCURRENT_TIMESTAMP:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(7172)
|
|
p.Match(MySqlParserCURRENT_TIMESTAMP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserCURTIME:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(7173)
|
|
p.Match(MySqlParserCURTIME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDATE_ADD:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(7174)
|
|
p.Match(MySqlParserDATE_ADD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserDATE_SUB:
|
|
p.EnterOuterAlt(localctx, 9)
|
|
{
|
|
p.SetState(7175)
|
|
p.Match(MySqlParserDATE_SUB)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserIF:
|
|
p.EnterOuterAlt(localctx, 10)
|
|
{
|
|
p.SetState(7176)
|
|
p.Match(MySqlParserIF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserINSERT:
|
|
p.EnterOuterAlt(localctx, 11)
|
|
{
|
|
p.SetState(7177)
|
|
p.Match(MySqlParserINSERT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCALTIME:
|
|
p.EnterOuterAlt(localctx, 12)
|
|
{
|
|
p.SetState(7178)
|
|
p.Match(MySqlParserLOCALTIME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserLOCALTIMESTAMP:
|
|
p.EnterOuterAlt(localctx, 13)
|
|
{
|
|
p.SetState(7179)
|
|
p.Match(MySqlParserLOCALTIMESTAMP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserMID:
|
|
p.EnterOuterAlt(localctx, 14)
|
|
{
|
|
p.SetState(7180)
|
|
p.Match(MySqlParserMID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserNOW:
|
|
p.EnterOuterAlt(localctx, 15)
|
|
{
|
|
p.SetState(7181)
|
|
p.Match(MySqlParserNOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPEAT:
|
|
p.EnterOuterAlt(localctx, 16)
|
|
{
|
|
p.SetState(7182)
|
|
p.Match(MySqlParserREPEAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserREPLACE:
|
|
p.EnterOuterAlt(localctx, 17)
|
|
{
|
|
p.SetState(7183)
|
|
p.Match(MySqlParserREPLACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSUBSTR:
|
|
p.EnterOuterAlt(localctx, 18)
|
|
{
|
|
p.SetState(7184)
|
|
p.Match(MySqlParserSUBSTR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSUBSTRING:
|
|
p.EnterOuterAlt(localctx, 19)
|
|
{
|
|
p.SetState(7185)
|
|
p.Match(MySqlParserSUBSTRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserSYSDATE:
|
|
p.EnterOuterAlt(localctx, 20)
|
|
{
|
|
p.SetState(7186)
|
|
p.Match(MySqlParserSYSDATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserTRIM:
|
|
p.EnterOuterAlt(localctx, 21)
|
|
{
|
|
p.SetState(7187)
|
|
p.Match(MySqlParserTRIM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUTC_DATE:
|
|
p.EnterOuterAlt(localctx, 22)
|
|
{
|
|
p.SetState(7188)
|
|
p.Match(MySqlParserUTC_DATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUTC_TIME:
|
|
p.EnterOuterAlt(localctx, 23)
|
|
{
|
|
p.SetState(7189)
|
|
p.Match(MySqlParserUTC_TIME)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserUTC_TIMESTAMP:
|
|
p.EnterOuterAlt(localctx, 24)
|
|
{
|
|
p.SetState(7190)
|
|
p.Match(MySqlParserUTC_TIMESTAMP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPasswordFunctionClauseContext is an interface to support dynamic dispatch.
|
|
type IPasswordFunctionClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFunctionName returns the functionName token.
|
|
GetFunctionName() antlr.Token
|
|
|
|
// SetFunctionName sets the functionName token.
|
|
SetFunctionName(antlr.Token)
|
|
|
|
// Getter signatures
|
|
LR_BRACKET() antlr.TerminalNode
|
|
FunctionArg() IFunctionArgContext
|
|
RR_BRACKET() antlr.TerminalNode
|
|
PASSWORD() antlr.TerminalNode
|
|
OLD_PASSWORD() antlr.TerminalNode
|
|
|
|
// IsPasswordFunctionClauseContext differentiates from other interfaces.
|
|
IsPasswordFunctionClauseContext()
|
|
}
|
|
|
|
type PasswordFunctionClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
functionName antlr.Token
|
|
}
|
|
|
|
func NewEmptyPasswordFunctionClauseContext() *PasswordFunctionClauseContext {
|
|
var p = new(PasswordFunctionClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_passwordFunctionClause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPasswordFunctionClauseContext(p *PasswordFunctionClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_passwordFunctionClause
|
|
}
|
|
|
|
func (*PasswordFunctionClauseContext) IsPasswordFunctionClauseContext() {}
|
|
|
|
func NewPasswordFunctionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PasswordFunctionClauseContext {
|
|
var p = new(PasswordFunctionClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_passwordFunctionClause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PasswordFunctionClauseContext) GetFunctionName() antlr.Token { return s.functionName }
|
|
|
|
func (s *PasswordFunctionClauseContext) SetFunctionName(v antlr.Token) { s.functionName = v }
|
|
|
|
func (s *PasswordFunctionClauseContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) FunctionArg() IFunctionArgContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionArgContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionArgContext)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) OLD_PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOLD_PASSWORD, 0)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPasswordFunctionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPasswordFunctionClause(s)
|
|
}
|
|
}
|
|
|
|
func (s *PasswordFunctionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPasswordFunctionClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PasswordFunctionClause() (localctx IPasswordFunctionClauseContext) {
|
|
localctx = NewPasswordFunctionClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 682, MySqlParserRULE_passwordFunctionClause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7193)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*PasswordFunctionClauseContext).functionName = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserOLD_PASSWORD || _la == MySqlParserPASSWORD) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*PasswordFunctionClauseContext).functionName = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7194)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7195)
|
|
p.FunctionArg()
|
|
}
|
|
{
|
|
p.SetState(7196)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFunctionArgsContext is an interface to support dynamic dispatch.
|
|
type IFunctionArgsContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllConstant() []IConstantContext
|
|
Constant(i int) IConstantContext
|
|
AllFullColumnName() []IFullColumnNameContext
|
|
FullColumnName(i int) IFullColumnNameContext
|
|
AllFunctionCall() []IFunctionCallContext
|
|
FunctionCall(i int) IFunctionCallContext
|
|
AllExpression() []IExpressionContext
|
|
Expression(i int) IExpressionContext
|
|
AllCOMMA() []antlr.TerminalNode
|
|
COMMA(i int) antlr.TerminalNode
|
|
|
|
// IsFunctionArgsContext differentiates from other interfaces.
|
|
IsFunctionArgsContext()
|
|
}
|
|
|
|
type FunctionArgsContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFunctionArgsContext() *FunctionArgsContext {
|
|
var p = new(FunctionArgsContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionArgs
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFunctionArgsContext(p *FunctionArgsContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionArgs
|
|
}
|
|
|
|
func (*FunctionArgsContext) IsFunctionArgsContext() {}
|
|
|
|
func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext {
|
|
var p = new(FunctionArgsContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_functionArgs
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionArgsContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FunctionArgsContext) AllConstant() []IConstantContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IConstantContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IConstantContext); ok {
|
|
tst[i] = t.(IConstantContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FunctionArgsContext) Constant(i int) IConstantContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) AllFullColumnName() []IFullColumnNameContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFullColumnNameContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFullColumnNameContext); ok {
|
|
tst[i] = t.(IFullColumnNameContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FunctionArgsContext) FullColumnName(i int) IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFunctionCallContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFunctionCallContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFunctionCallContext); ok {
|
|
tst[i] = t.(IFunctionCallContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionCallContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionCallContext)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FunctionArgsContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFunctionArgs(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFunctionArgs(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFunctionArgs(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FunctionArgs() (localctx IFunctionArgsContext) {
|
|
localctx = NewFunctionArgsContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 684, MySqlParserRULE_functionArgs)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(7202)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1063, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(7198)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(7199)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(7200)
|
|
p.FunctionCall()
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
p.SetState(7201)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.SetState(7213)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7204)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7209)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1064, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(7205)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(7206)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
p.SetState(7207)
|
|
p.FunctionCall()
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
p.SetState(7208)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
p.SetState(7215)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFunctionArgContext is an interface to support dynamic dispatch.
|
|
type IFunctionArgContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Constant() IConstantContext
|
|
FullColumnName() IFullColumnNameContext
|
|
FunctionCall() IFunctionCallContext
|
|
Expression() IExpressionContext
|
|
|
|
// IsFunctionArgContext differentiates from other interfaces.
|
|
IsFunctionArgContext()
|
|
}
|
|
|
|
type FunctionArgContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFunctionArgContext() *FunctionArgContext {
|
|
var p = new(FunctionArgContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionArg
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFunctionArgContext(p *FunctionArgContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionArg
|
|
}
|
|
|
|
func (*FunctionArgContext) IsFunctionArgContext() {}
|
|
|
|
func NewFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgContext {
|
|
var p = new(FunctionArgContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_functionArg
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionArgContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FunctionArgContext) Constant() IConstantContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *FunctionArgContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *FunctionArgContext) FunctionCall() IFunctionCallContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionCallContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionCallContext)
|
|
}
|
|
|
|
func (s *FunctionArgContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *FunctionArgContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FunctionArgContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFunctionArg(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionArgContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFunctionArg(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFunctionArg(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FunctionArg() (localctx IFunctionArgContext) {
|
|
localctx = NewFunctionArgContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 686, MySqlParserRULE_functionArg)
|
|
p.SetState(7220)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1066, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7216)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7217)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7218)
|
|
p.FunctionCall()
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7219)
|
|
p.expression(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExpressionContext is an interface to support dynamic dispatch.
|
|
type IExpressionContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsExpressionContext differentiates from other interfaces.
|
|
IsExpressionContext()
|
|
}
|
|
|
|
type ExpressionContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExpressionContext() *ExpressionContext {
|
|
var p = new(ExpressionContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expression
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExpressionContext(p *ExpressionContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expression
|
|
}
|
|
|
|
func (*ExpressionContext) IsExpressionContext() {}
|
|
|
|
func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext {
|
|
var p = new(ExpressionContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_expression
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExpressionContext) CopyAll(ctx *ExpressionContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type IsExpressionContext struct {
|
|
ExpressionContext
|
|
testValue antlr.Token
|
|
}
|
|
|
|
func NewIsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsExpressionContext {
|
|
var p = new(IsExpressionContext)
|
|
|
|
InitEmptyExpressionContext(&p.ExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IsExpressionContext) GetTestValue() antlr.Token { return s.testValue }
|
|
|
|
func (s *IsExpressionContext) SetTestValue(v antlr.Token) { s.testValue = v }
|
|
|
|
func (s *IsExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IsExpressionContext) Predicate() IPredicateContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *IsExpressionContext) IS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS, 0)
|
|
}
|
|
|
|
func (s *IsExpressionContext) TRUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRUE, 0)
|
|
}
|
|
|
|
func (s *IsExpressionContext) FALSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFALSE, 0)
|
|
}
|
|
|
|
func (s *IsExpressionContext) UNKNOWN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNKNOWN, 0)
|
|
}
|
|
|
|
func (s *IsExpressionContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *IsExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIsExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *IsExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIsExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *IsExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIsExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NotExpressionContext struct {
|
|
ExpressionContext
|
|
notOperator antlr.Token
|
|
}
|
|
|
|
func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext {
|
|
var p = new(NotExpressionContext)
|
|
|
|
InitEmptyExpressionContext(&p.ExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NotExpressionContext) GetNotOperator() antlr.Token { return s.notOperator }
|
|
|
|
func (s *NotExpressionContext) SetNotOperator(v antlr.Token) { s.notOperator = v }
|
|
|
|
func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NotExpressionContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *NotExpressionContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *NotExpressionContext) EXCLAMATION_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *NotExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNotExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNotExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNotExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type LogicalExpressionContext struct {
|
|
ExpressionContext
|
|
}
|
|
|
|
func NewLogicalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalExpressionContext {
|
|
var p = new(LogicalExpressionContext)
|
|
|
|
InitEmptyExpressionContext(&p.ExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) LogicalOperator() ILogicalOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ILogicalOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ILogicalOperatorContext)
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLogicalExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLogicalExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *LogicalExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLogicalExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type PredicateExpressionContext struct {
|
|
ExpressionContext
|
|
}
|
|
|
|
func NewPredicateExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PredicateExpressionContext {
|
|
var p = new(PredicateExpressionContext)
|
|
|
|
InitEmptyExpressionContext(&p.ExpressionContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PredicateExpressionContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PredicateExpressionContext) Predicate() IPredicateContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *PredicateExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPredicateExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *PredicateExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPredicateExpression(s)
|
|
}
|
|
}
|
|
|
|
func (s *PredicateExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPredicateExpression(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Expression() (localctx IExpressionContext) {
|
|
return p.expression(0)
|
|
}
|
|
|
|
func (p *MySqlParser) expression(_p int) (localctx IExpressionContext) {
|
|
var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
|
|
|
|
_parentState := p.GetState()
|
|
localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState)
|
|
var _prevctx IExpressionContext = localctx
|
|
var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
|
|
_startState := 688
|
|
p.EnterRecursionRule(localctx, 688, MySqlParserRULE_expression, _p)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(7233)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1068, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewNotExpressionContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
|
|
{
|
|
p.SetState(7223)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*NotExpressionContext).notOperator = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNOT || _la == MySqlParserEXCLAMATION_SYMBOL) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*NotExpressionContext).notOperator = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7224)
|
|
p.expression(4)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewIsExpressionContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7225)
|
|
p.predicate(0)
|
|
}
|
|
{
|
|
p.SetState(7226)
|
|
p.Match(MySqlParserIS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7228)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(7227)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7230)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*IsExpressionContext).testValue = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserFALSE || _la == MySqlParserTRUE || _la == MySqlParserUNKNOWN) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*IsExpressionContext).testValue = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewPredicateExpressionContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7232)
|
|
p.predicate(0)
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
|
|
p.SetState(7241)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1069, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
if p.GetParseListeners() != nil {
|
|
p.TriggerExitRuleEvent()
|
|
}
|
|
_prevctx = localctx
|
|
localctx = NewLogicalExpressionContext(p, NewExpressionContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expression)
|
|
p.SetState(7235)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7236)
|
|
p.LogicalOperator()
|
|
}
|
|
{
|
|
p.SetState(7237)
|
|
p.expression(4)
|
|
}
|
|
|
|
}
|
|
p.SetState(7243)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1069, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.UnrollRecursionContexts(_parentctx)
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPredicateContext is an interface to support dynamic dispatch.
|
|
type IPredicateContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsPredicateContext differentiates from other interfaces.
|
|
IsPredicateContext()
|
|
}
|
|
|
|
type PredicateContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPredicateContext() *PredicateContext {
|
|
var p = new(PredicateContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_predicate
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPredicateContext(p *PredicateContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_predicate
|
|
}
|
|
|
|
func (*PredicateContext) IsPredicateContext() {}
|
|
|
|
func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext {
|
|
var p = new(PredicateContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_predicate
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PredicateContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PredicateContext) CopyAll(ctx *PredicateContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *PredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type SoundsLikePredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewSoundsLikePredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SoundsLikePredicateContext {
|
|
var p = new(SoundsLikePredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) SOUNDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOUNDS, 0)
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) LIKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIKE, 0)
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSoundsLikePredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSoundsLikePredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *SoundsLikePredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSoundsLikePredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ExpressionAtomPredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewExpressionAtomPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpressionAtomPredicateContext {
|
|
var p = new(ExpressionAtomPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionAtomPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionAtomPredicateContext) ExpressionAtom() IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *ExpressionAtomPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExpressionAtomPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionAtomPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExpressionAtomPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExpressionAtomPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExpressionAtomPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SubqueryComparisonPredicateContext struct {
|
|
PredicateContext
|
|
quantifier antlr.Token
|
|
}
|
|
|
|
func NewSubqueryComparisonPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryComparisonPredicateContext {
|
|
var p = new(SubqueryComparisonPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) GetQuantifier() antlr.Token { return s.quantifier }
|
|
|
|
func (s *SubqueryComparisonPredicateContext) SetQuantifier(v antlr.Token) { s.quantifier = v }
|
|
|
|
func (s *SubqueryComparisonPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) Predicate() IPredicateContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) ComparisonOperator() IComparisonOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IComparisonOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IComparisonOperatorContext)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) ALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALL, 0)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) ANY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserANY, 0)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) SOME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOME, 0)
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubqueryComparisonPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubqueryComparisonPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubqueryComparisonPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type JsonMemberOfPredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewJsonMemberOfPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonMemberOfPredicateContext {
|
|
var p = new(JsonMemberOfPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) MEMBER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMBER, 0)
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) OF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOF, 0)
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonMemberOfPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonMemberOfPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonMemberOfPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonMemberOfPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type BinaryComparisonPredicateContext struct {
|
|
PredicateContext
|
|
left IPredicateContext
|
|
right IPredicateContext
|
|
}
|
|
|
|
func NewBinaryComparisonPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryComparisonPredicateContext {
|
|
var p = new(BinaryComparisonPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) GetLeft() IPredicateContext { return s.left }
|
|
|
|
func (s *BinaryComparisonPredicateContext) GetRight() IPredicateContext { return s.right }
|
|
|
|
func (s *BinaryComparisonPredicateContext) SetLeft(v IPredicateContext) { s.left = v }
|
|
|
|
func (s *BinaryComparisonPredicateContext) SetRight(v IPredicateContext) { s.right = v }
|
|
|
|
func (s *BinaryComparisonPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) ComparisonOperator() IComparisonOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IComparisonOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IComparisonOperatorContext)
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBinaryComparisonPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBinaryComparisonPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinaryComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBinaryComparisonPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type InPredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewInPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InPredicateContext {
|
|
var p = new(InPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *InPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *InPredicateContext) Predicate() IPredicateContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *InPredicateContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIN, 0)
|
|
}
|
|
|
|
func (s *InPredicateContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *InPredicateContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *InPredicateContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *InPredicateContext) Expressions() IExpressionsContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionsContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionsContext)
|
|
}
|
|
|
|
func (s *InPredicateContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *InPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterInPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *InPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitInPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *InPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitInPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type BetweenPredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewBetweenPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BetweenPredicateContext {
|
|
var p = new(BetweenPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) BETWEEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBETWEEN, 0)
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, 0)
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBetweenPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBetweenPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *BetweenPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBetweenPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IsNullPredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewIsNullPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsNullPredicateContext {
|
|
var p = new(IsNullPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) Predicate() IPredicateContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) IS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS, 0)
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) NullNotnull() INullNotnullContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(INullNotnullContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(INullNotnullContext)
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIsNullPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIsNullPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *IsNullPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIsNullPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type LikePredicateContext struct {
|
|
PredicateContext
|
|
}
|
|
|
|
func NewLikePredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LikePredicateContext {
|
|
var p = new(LikePredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LikePredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LikePredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *LikePredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *LikePredicateContext) LIKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIKE, 0)
|
|
}
|
|
|
|
func (s *LikePredicateContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *LikePredicateContext) ESCAPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserESCAPE, 0)
|
|
}
|
|
|
|
func (s *LikePredicateContext) STRING_LITERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING_LITERAL, 0)
|
|
}
|
|
|
|
func (s *LikePredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLikePredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *LikePredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLikePredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *LikePredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLikePredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type RegexpPredicateContext struct {
|
|
PredicateContext
|
|
regex antlr.Token
|
|
}
|
|
|
|
func NewRegexpPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RegexpPredicateContext {
|
|
var p = new(RegexpPredicateContext)
|
|
|
|
InitEmptyPredicateContext(&p.PredicateContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*PredicateContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) GetRegex() antlr.Token { return s.regex }
|
|
|
|
func (s *RegexpPredicateContext) SetRegex(v antlr.Token) { s.regex = v }
|
|
|
|
func (s *RegexpPredicateContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) AllPredicate() []IPredicateContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IPredicateContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IPredicateContext); ok {
|
|
tst[i] = t.(IPredicateContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) Predicate(i int) IPredicateContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IPredicateContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IPredicateContext)
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) REGEXP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREGEXP, 0)
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) RLIKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRLIKE, 0)
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterRegexpPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitRegexpPredicate(s)
|
|
}
|
|
}
|
|
|
|
func (s *RegexpPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitRegexpPredicate(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Predicate() (localctx IPredicateContext) {
|
|
return p.predicate(0)
|
|
}
|
|
|
|
func (p *MySqlParser) predicate(_p int) (localctx IPredicateContext) {
|
|
var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
|
|
|
|
_parentState := p.GetState()
|
|
localctx = NewPredicateContext(p, p.GetParserRuleContext(), _parentState)
|
|
var _prevctx IPredicateContext = localctx
|
|
var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
|
|
_startState := 690
|
|
p.EnterRecursionRule(localctx, 690, MySqlParserRULE_predicate, _p)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
localctx = NewExpressionAtomPredicateContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
|
|
{
|
|
p.SetState(7245)
|
|
p.expressionAtom(0)
|
|
}
|
|
|
|
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
|
|
p.SetState(7311)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1077, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
if p.GetParseListeners() != nil {
|
|
p.TriggerExitRuleEvent()
|
|
}
|
|
_prevctx = localctx
|
|
p.SetState(7309)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1076, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewBinaryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
localctx.(*BinaryComparisonPredicateContext).left = _prevctx
|
|
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7247)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 8)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7248)
|
|
p.ComparisonOperator()
|
|
}
|
|
{
|
|
p.SetState(7249)
|
|
|
|
var _x = p.predicate(9)
|
|
|
|
localctx.(*BinaryComparisonPredicateContext).right = _x
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewBetweenPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7251)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 6)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
|
|
goto errorExit
|
|
}
|
|
p.SetState(7253)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(7252)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7255)
|
|
p.Match(MySqlParserBETWEEN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7256)
|
|
p.predicate(0)
|
|
}
|
|
{
|
|
p.SetState(7257)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7258)
|
|
p.predicate(7)
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewSoundsLikePredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7260)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 5)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7261)
|
|
p.Match(MySqlParserSOUNDS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7262)
|
|
p.Match(MySqlParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7263)
|
|
p.predicate(6)
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewRegexpPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7264)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
|
|
goto errorExit
|
|
}
|
|
p.SetState(7266)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(7265)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7268)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*RegexpPredicateContext).regex = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserREGEXP || _la == MySqlParserRLIKE) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*RegexpPredicateContext).regex = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7269)
|
|
p.predicate(4)
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewInPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7270)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 10)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
|
|
goto errorExit
|
|
}
|
|
p.SetState(7272)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(7271)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7274)
|
|
p.Match(MySqlParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7275)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(7278)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) {
|
|
case 1:
|
|
{
|
|
p.SetState(7276)
|
|
p.SelectStatement()
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
p.SetState(7277)
|
|
p.Expressions()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7280)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewIsNullPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7282)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 9)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7283)
|
|
p.Match(MySqlParserIS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7284)
|
|
p.NullNotnull()
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewSubqueryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7285)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 7)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7286)
|
|
p.ComparisonOperator()
|
|
}
|
|
{
|
|
p.SetState(7287)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*SubqueryComparisonPredicateContext).quantifier = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserALL || _la == MySqlParserANY || _la == MySqlParserSOME) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*SubqueryComparisonPredicateContext).quantifier = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7288)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7289)
|
|
p.SelectStatement()
|
|
}
|
|
{
|
|
p.SetState(7290)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewLikePredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7292)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
|
|
goto errorExit
|
|
}
|
|
p.SetState(7294)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == MySqlParserNOT {
|
|
{
|
|
p.SetState(7293)
|
|
p.Match(MySqlParserNOT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(7296)
|
|
p.Match(MySqlParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7297)
|
|
p.predicate(0)
|
|
}
|
|
p.SetState(7300)
|
|
p.GetErrorHandler().Sync(p)
|
|
|
|
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1075, p.GetParserRuleContext()) == 1 {
|
|
{
|
|
p.SetState(7298)
|
|
p.Match(MySqlParserESCAPE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7299)
|
|
p.Match(MySqlParserSTRING_LITERAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
} else if p.HasError() { // JIM
|
|
goto errorExit
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewJsonMemberOfPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
|
|
p.SetState(7302)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 2)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7303)
|
|
p.Match(MySqlParserMEMBER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7304)
|
|
p.Match(MySqlParserOF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7305)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7306)
|
|
p.predicate(0)
|
|
}
|
|
{
|
|
p.SetState(7307)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(7313)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1077, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.UnrollRecursionContexts(_parentctx)
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExpressionAtomContext is an interface to support dynamic dispatch.
|
|
type IExpressionAtomContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
// IsExpressionAtomContext differentiates from other interfaces.
|
|
IsExpressionAtomContext()
|
|
}
|
|
|
|
type ExpressionAtomContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyExpressionAtomContext() *ExpressionAtomContext {
|
|
var p = new(ExpressionAtomContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionAtom
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExpressionAtomContext(p *ExpressionAtomContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_expressionAtom
|
|
}
|
|
|
|
func (*ExpressionAtomContext) IsExpressionAtomContext() {}
|
|
|
|
func NewExpressionAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAtomContext {
|
|
var p = new(ExpressionAtomContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_expressionAtom
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExpressionAtomContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExpressionAtomContext) CopyAll(ctx *ExpressionAtomContext) {
|
|
s.CopyFrom(&ctx.BaseParserRuleContext)
|
|
}
|
|
|
|
func (s *ExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExpressionAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
type UnaryExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewUnaryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryExpressionAtomContext {
|
|
var p = new(UnaryExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) UnaryOperator() IUnaryOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IUnaryOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IUnaryOperatorContext)
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) ExpressionAtom() IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnaryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnaryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnaryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnaryExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type CollateExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewCollateExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollateExpressionAtomContext {
|
|
var p = new(CollateExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) ExpressionAtom() IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) COLLATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATE, 0)
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) CollationName() ICollationNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICollationNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICollationNameContext)
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCollateExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCollateExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *CollateExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCollateExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type VariableAssignExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewVariableAssignExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VariableAssignExpressionAtomContext {
|
|
var p = new(VariableAssignExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) LOCAL_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL_ID, 0)
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) VAR_ASSIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_ASSIGN, 0)
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) ExpressionAtom() IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterVariableAssignExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitVariableAssignExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *VariableAssignExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitVariableAssignExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MysqlVariableExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewMysqlVariableExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MysqlVariableExpressionAtomContext {
|
|
var p = new(MysqlVariableExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MysqlVariableExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MysqlVariableExpressionAtomContext) MysqlVariable() IMysqlVariableContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMysqlVariableContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMysqlVariableContext)
|
|
}
|
|
|
|
func (s *MysqlVariableExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMysqlVariableExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *MysqlVariableExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMysqlVariableExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *MysqlVariableExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMysqlVariableExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NestedExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewNestedExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedExpressionAtomContext {
|
|
var p = new(NestedExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNestedExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNestedExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *NestedExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNestedExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type NestedRowExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewNestedRowExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedRowExpressionAtomContext {
|
|
var p = new(NestedRowExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) ROW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW, 0)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) AllExpression() []IExpressionContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionContext); ok {
|
|
tst[i] = t.(IExpressionContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) Expression(i int) IExpressionContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) AllCOMMA() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserCOMMA)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) COMMA(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMA, i)
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterNestedRowExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitNestedRowExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *NestedRowExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitNestedRowExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type MathExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
left IExpressionAtomContext
|
|
right IExpressionAtomContext
|
|
}
|
|
|
|
func NewMathExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MathExpressionAtomContext {
|
|
var p = new(MathExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left }
|
|
|
|
func (s *MathExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right }
|
|
|
|
func (s *MathExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v }
|
|
|
|
func (s *MathExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v }
|
|
|
|
func (s *MathExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) MultOperator() IMultOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IMultOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IMultOperatorContext)
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionAtomContext); ok {
|
|
tst[i] = t.(IExpressionAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) AddOperator() IAddOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IAddOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IAddOperatorContext)
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMathExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMathExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *MathExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMathExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ExistsExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewExistsExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsExpressionAtomContext {
|
|
var p = new(ExistsExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) EXISTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXISTS, 0)
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterExistsExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitExistsExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *ExistsExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitExistsExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type IntervalExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewIntervalExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntervalExpressionAtomContext {
|
|
var p = new(IntervalExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) INTERVAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERVAL, 0)
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) Expression() IExpressionContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionContext)
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) IntervalType() IIntervalTypeContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIntervalTypeContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIntervalTypeContext)
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIntervalExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIntervalExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIntervalExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type JsonExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
left IExpressionAtomContext
|
|
right IExpressionAtomContext
|
|
}
|
|
|
|
func NewJsonExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonExpressionAtomContext {
|
|
var p = new(JsonExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left }
|
|
|
|
func (s *JsonExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right }
|
|
|
|
func (s *JsonExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v }
|
|
|
|
func (s *JsonExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v }
|
|
|
|
func (s *JsonExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) JsonOperator() IJsonOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IJsonOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IJsonOperatorContext)
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionAtomContext); ok {
|
|
tst[i] = t.(IExpressionAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type SubqueryExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewSubqueryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryExpressionAtomContext {
|
|
var p = new(SubqueryExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) LR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) SelectStatement() ISelectStatementContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStatementContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStatementContext)
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) RR_BRACKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRR_BRACKET, 0)
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterSubqueryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitSubqueryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *SubqueryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitSubqueryExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type ConstantExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewConstantExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantExpressionAtomContext {
|
|
var p = new(ConstantExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ConstantExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ConstantExpressionAtomContext) Constant() IConstantContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IConstantContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IConstantContext)
|
|
}
|
|
|
|
func (s *ConstantExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterConstantExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitConstantExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *ConstantExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitConstantExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type FunctionCallExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewFunctionCallExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionCallExpressionAtomContext {
|
|
var p = new(FunctionCallExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionCallExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionCallExpressionAtomContext) FunctionCall() IFunctionCallContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFunctionCallContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFunctionCallContext)
|
|
}
|
|
|
|
func (s *FunctionCallExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFunctionCallExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionCallExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFunctionCallExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionCallExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFunctionCallExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type BinaryExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewBinaryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryExpressionAtomContext {
|
|
var p = new(BinaryExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) ExpressionAtom() IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBinaryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBinaryExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *BinaryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBinaryExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type FullColumnNameExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
}
|
|
|
|
func NewFullColumnNameExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FullColumnNameExpressionAtomContext {
|
|
var p = new(FullColumnNameExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FullColumnNameExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FullColumnNameExpressionAtomContext) FullColumnName() IFullColumnNameContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFullColumnNameContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFullColumnNameContext)
|
|
}
|
|
|
|
func (s *FullColumnNameExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFullColumnNameExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFullColumnNameExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *FullColumnNameExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFullColumnNameExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type BitExpressionAtomContext struct {
|
|
ExpressionAtomContext
|
|
left IExpressionAtomContext
|
|
right IExpressionAtomContext
|
|
}
|
|
|
|
func NewBitExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitExpressionAtomContext {
|
|
var p = new(BitExpressionAtomContext)
|
|
|
|
InitEmptyExpressionAtomContext(&p.ExpressionAtomContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExpressionAtomContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left }
|
|
|
|
func (s *BitExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right }
|
|
|
|
func (s *BitExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v }
|
|
|
|
func (s *BitExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v }
|
|
|
|
func (s *BitExpressionAtomContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) BitOperator() IBitOperatorContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IBitOperatorContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IBitOperatorContext)
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IExpressionAtomContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IExpressionAtomContext); ok {
|
|
tst[i] = t.(IExpressionAtomContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IExpressionAtomContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IExpressionAtomContext)
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBitExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBitExpressionAtom(s)
|
|
}
|
|
}
|
|
|
|
func (s *BitExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBitExpressionAtom(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ExpressionAtom() (localctx IExpressionAtomContext) {
|
|
return p.expressionAtom(0)
|
|
}
|
|
|
|
func (p *MySqlParser) expressionAtom(_p int) (localctx IExpressionAtomContext) {
|
|
var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
|
|
|
|
_parentState := p.GetState()
|
|
localctx = NewExpressionAtomContext(p, p.GetParserRuleContext(), _parentState)
|
|
var _prevctx IExpressionAtomContext = localctx
|
|
var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
|
|
_startState := 692
|
|
p.EnterRecursionRule(localctx, 692, MySqlParserRULE_expressionAtom, _p)
|
|
var _la int
|
|
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(7362)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1080, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewConstantExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
|
|
{
|
|
p.SetState(7315)
|
|
p.Constant()
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewFullColumnNameExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7316)
|
|
p.FullColumnName()
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewFunctionCallExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7317)
|
|
p.FunctionCall()
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewMysqlVariableExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7318)
|
|
p.MysqlVariable()
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewUnaryExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7319)
|
|
p.UnaryOperator()
|
|
}
|
|
{
|
|
p.SetState(7320)
|
|
p.expressionAtom(12)
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewBinaryExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7322)
|
|
p.Match(MySqlParserBINARY)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7323)
|
|
p.expressionAtom(11)
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewVariableAssignExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7324)
|
|
p.Match(MySqlParserLOCAL_ID)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7325)
|
|
p.Match(MySqlParserVAR_ASSIGN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7326)
|
|
p.expressionAtom(10)
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewNestedExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7327)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7328)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(7333)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7329)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7330)
|
|
p.expression(0)
|
|
}
|
|
|
|
p.SetState(7335)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(7336)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewNestedRowExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7338)
|
|
p.Match(MySqlParserROW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7339)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7340)
|
|
p.expression(0)
|
|
}
|
|
p.SetState(7343)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == MySqlParserCOMMA {
|
|
{
|
|
p.SetState(7341)
|
|
p.Match(MySqlParserCOMMA)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7342)
|
|
p.expression(0)
|
|
}
|
|
|
|
p.SetState(7345)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(7347)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewExistsExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7349)
|
|
p.Match(MySqlParserEXISTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7350)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7351)
|
|
p.SelectStatement()
|
|
}
|
|
{
|
|
p.SetState(7352)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewSubqueryExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7354)
|
|
p.Match(MySqlParserLR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7355)
|
|
p.SelectStatement()
|
|
}
|
|
{
|
|
p.SetState(7356)
|
|
p.Match(MySqlParserRR_BRACKET)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewIntervalExpressionAtomContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7358)
|
|
p.Match(MySqlParserINTERVAL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7359)
|
|
p.expression(0)
|
|
}
|
|
{
|
|
p.SetState(7360)
|
|
p.IntervalType()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
|
|
p.SetState(7385)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1082, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
if p.GetParseListeners() != nil {
|
|
p.TriggerExitRuleEvent()
|
|
}
|
|
_prevctx = localctx
|
|
p.SetState(7383)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewBitExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
|
|
localctx.(*BitExpressionAtomContext).left = _prevctx
|
|
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
|
|
p.SetState(7364)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7365)
|
|
p.BitOperator()
|
|
}
|
|
{
|
|
p.SetState(7366)
|
|
|
|
var _x = p.expressionAtom(5)
|
|
|
|
localctx.(*BitExpressionAtomContext).right = _x
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewMathExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
|
|
localctx.(*MathExpressionAtomContext).left = _prevctx
|
|
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
|
|
p.SetState(7368)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7369)
|
|
p.MultOperator()
|
|
}
|
|
{
|
|
p.SetState(7370)
|
|
|
|
var _x = p.expressionAtom(4)
|
|
|
|
localctx.(*MathExpressionAtomContext).right = _x
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewMathExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
|
|
localctx.(*MathExpressionAtomContext).left = _prevctx
|
|
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
|
|
p.SetState(7372)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 2)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7373)
|
|
p.AddOperator()
|
|
}
|
|
{
|
|
p.SetState(7374)
|
|
|
|
var _x = p.expressionAtom(3)
|
|
|
|
localctx.(*MathExpressionAtomContext).right = _x
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewJsonExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
|
|
localctx.(*JsonExpressionAtomContext).left = _prevctx
|
|
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
|
|
p.SetState(7376)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 1)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7377)
|
|
p.JsonOperator()
|
|
}
|
|
{
|
|
p.SetState(7378)
|
|
|
|
var _x = p.expressionAtom(2)
|
|
|
|
localctx.(*JsonExpressionAtomContext).right = _x
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewCollateExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
|
|
p.SetState(7380)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 14)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(7381)
|
|
p.Match(MySqlParserCOLLATE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7382)
|
|
p.CollationName()
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(7387)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1082, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.UnrollRecursionContexts(_parentctx)
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IUnaryOperatorContext is an interface to support dynamic dispatch.
|
|
type IUnaryOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EXCLAMATION_SYMBOL() antlr.TerminalNode
|
|
BIT_NOT_OP() antlr.TerminalNode
|
|
PLUS() antlr.TerminalNode
|
|
MINUS() antlr.TerminalNode
|
|
NOT() antlr.TerminalNode
|
|
|
|
// IsUnaryOperatorContext differentiates from other interfaces.
|
|
IsUnaryOperatorContext()
|
|
}
|
|
|
|
type UnaryOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyUnaryOperatorContext() *UnaryOperatorContext {
|
|
var p = new(UnaryOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unaryOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyUnaryOperatorContext(p *UnaryOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_unaryOperator
|
|
}
|
|
|
|
func (*UnaryOperatorContext) IsUnaryOperatorContext() {}
|
|
|
|
func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext {
|
|
var p = new(UnaryOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_unaryOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *UnaryOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) BIT_NOT_OP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_NOT_OP, 0)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) PLUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUS, 0)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) MINUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, 0)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) NOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOT, 0)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterUnaryOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitUnaryOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *UnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitUnaryOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) UnaryOperator() (localctx IUnaryOperatorContext) {
|
|
localctx = NewUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 694, MySqlParserRULE_unaryOperator)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7388)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserNOT || ((int64((_la-1120)) & ^0x3f) == 0 && ((int64(1)<<(_la-1120))&387) != 0)) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IComparisonOperatorContext is an interface to support dynamic dispatch.
|
|
type IComparisonOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EQUAL_SYMBOL() antlr.TerminalNode
|
|
GREATER_SYMBOL() antlr.TerminalNode
|
|
LESS_SYMBOL() antlr.TerminalNode
|
|
EXCLAMATION_SYMBOL() antlr.TerminalNode
|
|
|
|
// IsComparisonOperatorContext differentiates from other interfaces.
|
|
IsComparisonOperatorContext()
|
|
}
|
|
|
|
type ComparisonOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext {
|
|
var p = new(ComparisonOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_comparisonOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_comparisonOperator
|
|
}
|
|
|
|
func (*ComparisonOperatorContext) IsComparisonOperatorContext() {}
|
|
|
|
func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext {
|
|
var p = new(ComparisonOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_comparisonOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ComparisonOperatorContext) EQUAL_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUAL_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) GREATER_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREATER_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) LESS_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLESS_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0)
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterComparisonOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitComparisonOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitComparisonOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ComparisonOperator() (localctx IComparisonOperatorContext) {
|
|
localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 696, MySqlParserRULE_comparisonOperator)
|
|
p.SetState(7404)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1083, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7390)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7391)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7392)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7393)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7394)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(7395)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7396)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
p.EnterOuterAlt(localctx, 6)
|
|
{
|
|
p.SetState(7397)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7398)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
p.EnterOuterAlt(localctx, 7)
|
|
{
|
|
p.SetState(7399)
|
|
p.Match(MySqlParserEXCLAMATION_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7400)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
p.EnterOuterAlt(localctx, 8)
|
|
{
|
|
p.SetState(7401)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7402)
|
|
p.Match(MySqlParserEQUAL_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7403)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ILogicalOperatorContext is an interface to support dynamic dispatch.
|
|
type ILogicalOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AND() antlr.TerminalNode
|
|
AllBIT_AND_OP() []antlr.TerminalNode
|
|
BIT_AND_OP(i int) antlr.TerminalNode
|
|
XOR() antlr.TerminalNode
|
|
OR() antlr.TerminalNode
|
|
AllBIT_OR_OP() []antlr.TerminalNode
|
|
BIT_OR_OP(i int) antlr.TerminalNode
|
|
|
|
// IsLogicalOperatorContext differentiates from other interfaces.
|
|
IsLogicalOperatorContext()
|
|
}
|
|
|
|
type LogicalOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyLogicalOperatorContext() *LogicalOperatorContext {
|
|
var p = new(LogicalOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_logicalOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyLogicalOperatorContext(p *LogicalOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_logicalOperator
|
|
}
|
|
|
|
func (*LogicalOperatorContext) IsLogicalOperatorContext() {}
|
|
|
|
func NewLogicalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOperatorContext {
|
|
var p = new(LogicalOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_logicalOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *LogicalOperatorContext) AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAND, 0)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) AllBIT_AND_OP() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserBIT_AND_OP)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) BIT_AND_OP(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_AND_OP, i)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) XOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXOR, 0)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) OR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOR, 0)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) AllBIT_OR_OP() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserBIT_OR_OP)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) BIT_OR_OP(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_OR_OP, i)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterLogicalOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitLogicalOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *LogicalOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitLogicalOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) LogicalOperator() (localctx ILogicalOperatorContext) {
|
|
localctx = NewLogicalOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 698, MySqlParserRULE_logicalOperator)
|
|
p.SetState(7413)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserAND:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7406)
|
|
p.Match(MySqlParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_AND_OP:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7407)
|
|
p.Match(MySqlParserBIT_AND_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7408)
|
|
p.Match(MySqlParserBIT_AND_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserXOR:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7409)
|
|
p.Match(MySqlParserXOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserOR:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7410)
|
|
p.Match(MySqlParserOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_OR_OP:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(7411)
|
|
p.Match(MySqlParserBIT_OR_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7412)
|
|
p.Match(MySqlParserBIT_OR_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IBitOperatorContext is an interface to support dynamic dispatch.
|
|
type IBitOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
AllLESS_SYMBOL() []antlr.TerminalNode
|
|
LESS_SYMBOL(i int) antlr.TerminalNode
|
|
AllGREATER_SYMBOL() []antlr.TerminalNode
|
|
GREATER_SYMBOL(i int) antlr.TerminalNode
|
|
BIT_AND_OP() antlr.TerminalNode
|
|
BIT_XOR_OP() antlr.TerminalNode
|
|
BIT_OR_OP() antlr.TerminalNode
|
|
|
|
// IsBitOperatorContext differentiates from other interfaces.
|
|
IsBitOperatorContext()
|
|
}
|
|
|
|
type BitOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyBitOperatorContext() *BitOperatorContext {
|
|
var p = new(BitOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_bitOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyBitOperatorContext(p *BitOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_bitOperator
|
|
}
|
|
|
|
func (*BitOperatorContext) IsBitOperatorContext() {}
|
|
|
|
func NewBitOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitOperatorContext {
|
|
var p = new(BitOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_bitOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *BitOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *BitOperatorContext) AllLESS_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserLESS_SYMBOL)
|
|
}
|
|
|
|
func (s *BitOperatorContext) LESS_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLESS_SYMBOL, i)
|
|
}
|
|
|
|
func (s *BitOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserGREATER_SYMBOL)
|
|
}
|
|
|
|
func (s *BitOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREATER_SYMBOL, i)
|
|
}
|
|
|
|
func (s *BitOperatorContext) BIT_AND_OP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_AND_OP, 0)
|
|
}
|
|
|
|
func (s *BitOperatorContext) BIT_XOR_OP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_XOR_OP, 0)
|
|
}
|
|
|
|
func (s *BitOperatorContext) BIT_OR_OP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_OR_OP, 0)
|
|
}
|
|
|
|
func (s *BitOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *BitOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *BitOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterBitOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *BitOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitBitOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *BitOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitBitOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) BitOperator() (localctx IBitOperatorContext) {
|
|
localctx = NewBitOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 700, MySqlParserRULE_bitOperator)
|
|
p.SetState(7422)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case MySqlParserLESS_SYMBOL:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7415)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7416)
|
|
p.Match(MySqlParserLESS_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserGREATER_SYMBOL:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7417)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7418)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_AND_OP:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(7419)
|
|
p.Match(MySqlParserBIT_AND_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_XOR_OP:
|
|
p.EnterOuterAlt(localctx, 4)
|
|
{
|
|
p.SetState(7420)
|
|
p.Match(MySqlParserBIT_XOR_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case MySqlParserBIT_OR_OP:
|
|
p.EnterOuterAlt(localctx, 5)
|
|
{
|
|
p.SetState(7421)
|
|
p.Match(MySqlParserBIT_OR_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IMultOperatorContext is an interface to support dynamic dispatch.
|
|
type IMultOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
STAR() antlr.TerminalNode
|
|
DIVIDE() antlr.TerminalNode
|
|
MODULE() antlr.TerminalNode
|
|
DIV() antlr.TerminalNode
|
|
MOD() antlr.TerminalNode
|
|
|
|
// IsMultOperatorContext differentiates from other interfaces.
|
|
IsMultOperatorContext()
|
|
}
|
|
|
|
type MultOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyMultOperatorContext() *MultOperatorContext {
|
|
var p = new(MultOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyMultOperatorContext(p *MultOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_multOperator
|
|
}
|
|
|
|
func (*MultOperatorContext) IsMultOperatorContext() {}
|
|
|
|
func NewMultOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultOperatorContext {
|
|
var p = new(MultOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_multOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *MultOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *MultOperatorContext) STAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTAR, 0)
|
|
}
|
|
|
|
func (s *MultOperatorContext) DIVIDE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIVIDE, 0)
|
|
}
|
|
|
|
func (s *MultOperatorContext) MODULE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODULE, 0)
|
|
}
|
|
|
|
func (s *MultOperatorContext) DIV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIV, 0)
|
|
}
|
|
|
|
func (s *MultOperatorContext) MOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMOD, 0)
|
|
}
|
|
|
|
func (s *MultOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *MultOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *MultOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterMultOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitMultOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *MultOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitMultOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) MultOperator() (localctx IMultOperatorContext) {
|
|
localctx = NewMultOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 702, MySqlParserRULE_multOperator)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7424)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-1117)) & ^0x3f) == 0 && ((int64(1)<<(_la-1117))&103) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IAddOperatorContext is an interface to support dynamic dispatch.
|
|
type IAddOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
PLUS() antlr.TerminalNode
|
|
MINUS() antlr.TerminalNode
|
|
|
|
// IsAddOperatorContext differentiates from other interfaces.
|
|
IsAddOperatorContext()
|
|
}
|
|
|
|
type AddOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyAddOperatorContext() *AddOperatorContext {
|
|
var p = new(AddOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_addOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyAddOperatorContext(p *AddOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_addOperator
|
|
}
|
|
|
|
func (*AddOperatorContext) IsAddOperatorContext() {}
|
|
|
|
func NewAddOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddOperatorContext {
|
|
var p = new(AddOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_addOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *AddOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *AddOperatorContext) PLUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUS, 0)
|
|
}
|
|
|
|
func (s *AddOperatorContext) MINUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, 0)
|
|
}
|
|
|
|
func (s *AddOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *AddOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *AddOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterAddOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *AddOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitAddOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *AddOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitAddOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) AddOperator() (localctx IAddOperatorContext) {
|
|
localctx = NewAddOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 704, MySqlParserRULE_addOperator)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7426)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserPLUS || _la == MySqlParserMINUS) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IJsonOperatorContext is an interface to support dynamic dispatch.
|
|
type IJsonOperatorContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
MINUS() antlr.TerminalNode
|
|
AllGREATER_SYMBOL() []antlr.TerminalNode
|
|
GREATER_SYMBOL(i int) antlr.TerminalNode
|
|
|
|
// IsJsonOperatorContext differentiates from other interfaces.
|
|
IsJsonOperatorContext()
|
|
}
|
|
|
|
type JsonOperatorContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyJsonOperatorContext() *JsonOperatorContext {
|
|
var p = new(JsonOperatorContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOperator
|
|
return p
|
|
}
|
|
|
|
func InitEmptyJsonOperatorContext(p *JsonOperatorContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_jsonOperator
|
|
}
|
|
|
|
func (*JsonOperatorContext) IsJsonOperatorContext() {}
|
|
|
|
func NewJsonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOperatorContext {
|
|
var p = new(JsonOperatorContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_jsonOperator
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *JsonOperatorContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *JsonOperatorContext) MINUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUS, 0)
|
|
}
|
|
|
|
func (s *JsonOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode {
|
|
return s.GetTokens(MySqlParserGREATER_SYMBOL)
|
|
}
|
|
|
|
func (s *JsonOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREATER_SYMBOL, i)
|
|
}
|
|
|
|
func (s *JsonOperatorContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *JsonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *JsonOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterJsonOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitJsonOperator(s)
|
|
}
|
|
}
|
|
|
|
func (s *JsonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitJsonOperator(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) JsonOperator() (localctx IJsonOperatorContext) {
|
|
localctx = NewJsonOperatorContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 706, MySqlParserRULE_jsonOperator)
|
|
p.SetState(7433)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1086, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7428)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7429)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(7430)
|
|
p.Match(MySqlParserMINUS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7431)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(7432)
|
|
p.Match(MySqlParserGREATER_SYMBOL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICharsetNameBaseContext is an interface to support dynamic dispatch.
|
|
type ICharsetNameBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ARMSCII8() antlr.TerminalNode
|
|
ASCII() antlr.TerminalNode
|
|
BIG5() antlr.TerminalNode
|
|
BINARY() antlr.TerminalNode
|
|
CP1250() antlr.TerminalNode
|
|
CP1251() antlr.TerminalNode
|
|
CP1256() antlr.TerminalNode
|
|
CP1257() antlr.TerminalNode
|
|
CP850() antlr.TerminalNode
|
|
CP852() antlr.TerminalNode
|
|
CP866() antlr.TerminalNode
|
|
CP932() antlr.TerminalNode
|
|
DEC8() antlr.TerminalNode
|
|
EUCJPMS() antlr.TerminalNode
|
|
EUCKR() antlr.TerminalNode
|
|
GB18030() antlr.TerminalNode
|
|
GB2312() antlr.TerminalNode
|
|
GBK() antlr.TerminalNode
|
|
GEOSTD8() antlr.TerminalNode
|
|
GREEK() antlr.TerminalNode
|
|
HEBREW() antlr.TerminalNode
|
|
HP8() antlr.TerminalNode
|
|
KEYBCS2() antlr.TerminalNode
|
|
KOI8R() antlr.TerminalNode
|
|
KOI8U() antlr.TerminalNode
|
|
LATIN1() antlr.TerminalNode
|
|
LATIN2() antlr.TerminalNode
|
|
LATIN5() antlr.TerminalNode
|
|
LATIN7() antlr.TerminalNode
|
|
MACCE() antlr.TerminalNode
|
|
MACROMAN() antlr.TerminalNode
|
|
SJIS() antlr.TerminalNode
|
|
SWE7() antlr.TerminalNode
|
|
TIS620() antlr.TerminalNode
|
|
UCS2() antlr.TerminalNode
|
|
UJIS() antlr.TerminalNode
|
|
UTF16() antlr.TerminalNode
|
|
UTF16LE() antlr.TerminalNode
|
|
UTF32() antlr.TerminalNode
|
|
UTF8() antlr.TerminalNode
|
|
UTF8MB3() antlr.TerminalNode
|
|
UTF8MB4() antlr.TerminalNode
|
|
|
|
// IsCharsetNameBaseContext differentiates from other interfaces.
|
|
IsCharsetNameBaseContext()
|
|
}
|
|
|
|
type CharsetNameBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyCharsetNameBaseContext() *CharsetNameBaseContext {
|
|
var p = new(CharsetNameBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charsetNameBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCharsetNameBaseContext(p *CharsetNameBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_charsetNameBase
|
|
}
|
|
|
|
func (*CharsetNameBaseContext) IsCharsetNameBaseContext() {}
|
|
|
|
func NewCharsetNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameBaseContext {
|
|
var p = new(CharsetNameBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_charsetNameBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CharsetNameBaseContext) ARMSCII8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserARMSCII8, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) ASCII() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASCII, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) BIG5() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIG5, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) BINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINARY, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP1250() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP1250, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP1251() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP1251, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP1256() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP1256, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP1257() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP1257, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP850() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP850, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP852() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP852, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP866() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP866, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) CP932() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCP932, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) DEC8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEC8, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) EUCJPMS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEUCJPMS, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) EUCKR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEUCKR, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GB18030() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGB18030, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GB2312() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGB2312, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GBK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGBK, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GEOSTD8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOSTD8, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GREEK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREEK, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) HEBREW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHEBREW, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) HP8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHP8, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) KEYBCS2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEYBCS2, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) KOI8R() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKOI8R, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) KOI8U() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKOI8U, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) LATIN1() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATIN1, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) LATIN2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATIN2, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) LATIN5() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATIN5, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) LATIN7() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATIN7, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) MACCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMACCE, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) MACROMAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMACROMAN, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) SJIS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSJIS, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) SWE7() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSWE7, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) TIS620() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIS620, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UCS2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUCS2, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UJIS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUJIS, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF16() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF16, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF16LE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF16LE, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF32() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF32, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF8() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF8, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF8MB3() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF8MB3, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) UTF8MB4() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUTF8MB4, 0)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterCharsetNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitCharsetNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *CharsetNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitCharsetNameBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) CharsetNameBase() (localctx ICharsetNameBaseContext) {
|
|
localctx = NewCharsetNameBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 708, MySqlParserRULE_charsetNameBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7435)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserBINARY || ((int64((_la-746)) & ^0x3f) == 0 && ((int64(1)<<(_la-746))&2199023255551) != 0)) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ITransactionLevelBaseContext is an interface to support dynamic dispatch.
|
|
type ITransactionLevelBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
REPEATABLE() antlr.TerminalNode
|
|
COMMITTED() antlr.TerminalNode
|
|
UNCOMMITTED() antlr.TerminalNode
|
|
SERIALIZABLE() antlr.TerminalNode
|
|
|
|
// IsTransactionLevelBaseContext differentiates from other interfaces.
|
|
IsTransactionLevelBaseContext()
|
|
}
|
|
|
|
type TransactionLevelBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyTransactionLevelBaseContext() *TransactionLevelBaseContext {
|
|
var p = new(TransactionLevelBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionLevelBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyTransactionLevelBaseContext(p *TransactionLevelBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_transactionLevelBase
|
|
}
|
|
|
|
func (*TransactionLevelBaseContext) IsTransactionLevelBaseContext() {}
|
|
|
|
func NewTransactionLevelBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionLevelBaseContext {
|
|
var p = new(TransactionLevelBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_transactionLevelBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *TransactionLevelBaseContext) REPEATABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPEATABLE, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) COMMITTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMITTED, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) UNCOMMITTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNCOMMITTED, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) SERIALIZABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERIALIZABLE, 0)
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterTransactionLevelBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitTransactionLevelBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *TransactionLevelBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitTransactionLevelBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) TransactionLevelBase() (localctx ITransactionLevelBaseContext) {
|
|
localctx = NewTransactionLevelBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 710, MySqlParserRULE_transactionLevelBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7437)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-799)) & ^0x3f) == 0 && ((int64(1)<<(_la-799))&15) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IPrivilegesBaseContext is an interface to support dynamic dispatch.
|
|
type IPrivilegesBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
TABLES() antlr.TerminalNode
|
|
ROUTINE() antlr.TerminalNode
|
|
EXECUTE() antlr.TerminalNode
|
|
FILE() antlr.TerminalNode
|
|
PROCESS() antlr.TerminalNode
|
|
RELOAD() antlr.TerminalNode
|
|
SHUTDOWN() antlr.TerminalNode
|
|
SUPER() antlr.TerminalNode
|
|
PRIVILEGES() antlr.TerminalNode
|
|
|
|
// IsPrivilegesBaseContext differentiates from other interfaces.
|
|
IsPrivilegesBaseContext()
|
|
}
|
|
|
|
type PrivilegesBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPrivilegesBaseContext() *PrivilegesBaseContext {
|
|
var p = new(PrivilegesBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilegesBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPrivilegesBaseContext(p *PrivilegesBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_privilegesBase
|
|
}
|
|
|
|
func (*PrivilegesBaseContext) IsPrivilegesBaseContext() {}
|
|
|
|
func NewPrivilegesBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesBaseContext {
|
|
var p = new(PrivilegesBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_privilegesBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PrivilegesBaseContext) TABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLES, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) ROUTINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROUTINE, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) EXECUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXECUTE, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILE, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) PROCESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCESS, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) RELOAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELOAD, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) SHUTDOWN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHUTDOWN, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) SUPER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUPER, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) PRIVILEGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIVILEGES, 0)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterPrivilegesBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitPrivilegesBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *PrivilegesBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitPrivilegesBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) PrivilegesBase() (localctx IPrivilegesBaseContext) {
|
|
localctx = NewPrivilegesBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 712, MySqlParserRULE_privilegesBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7439)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-708)) & ^0x3f) == 0 && ((int64(1)<<(_la-708))&23656792067) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIntervalTypeBaseContext is an interface to support dynamic dispatch.
|
|
type IIntervalTypeBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
QUARTER() antlr.TerminalNode
|
|
MONTH() antlr.TerminalNode
|
|
DAY() antlr.TerminalNode
|
|
HOUR() antlr.TerminalNode
|
|
MINUTE() antlr.TerminalNode
|
|
WEEK() antlr.TerminalNode
|
|
SECOND() antlr.TerminalNode
|
|
MICROSECOND() antlr.TerminalNode
|
|
|
|
// IsIntervalTypeBaseContext differentiates from other interfaces.
|
|
IsIntervalTypeBaseContext()
|
|
}
|
|
|
|
type IntervalTypeBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIntervalTypeBaseContext() *IntervalTypeBaseContext {
|
|
var p = new(IntervalTypeBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalTypeBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIntervalTypeBaseContext(p *IntervalTypeBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_intervalTypeBase
|
|
}
|
|
|
|
func (*IntervalTypeBaseContext) IsIntervalTypeBaseContext() {}
|
|
|
|
func NewIntervalTypeBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeBaseContext {
|
|
var p = new(IntervalTypeBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_intervalTypeBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IntervalTypeBaseContext) QUARTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUARTER, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) MONTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMONTH, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) DAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOUR, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) MINUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUTE, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) WEEK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEEK, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) SECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMICROSECOND, 0)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterIntervalTypeBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitIntervalTypeBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *IntervalTypeBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitIntervalTypeBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) IntervalTypeBase() (localctx IIntervalTypeBaseContext) {
|
|
localctx = NewIntervalTypeBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 714, MySqlParserRULE_intervalTypeBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7441)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-689)) & ^0x3f) == 0 && ((int64(1)<<(_la-689))&255) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IDataTypeBaseContext is an interface to support dynamic dispatch.
|
|
type IDataTypeBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
DATE() antlr.TerminalNode
|
|
TIME() antlr.TerminalNode
|
|
TIMESTAMP() antlr.TerminalNode
|
|
DATETIME() antlr.TerminalNode
|
|
YEAR() antlr.TerminalNode
|
|
ENUM() antlr.TerminalNode
|
|
TEXT() antlr.TerminalNode
|
|
|
|
// IsDataTypeBaseContext differentiates from other interfaces.
|
|
IsDataTypeBaseContext()
|
|
}
|
|
|
|
type DataTypeBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyDataTypeBaseContext() *DataTypeBaseContext {
|
|
var p = new(DataTypeBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dataTypeBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyDataTypeBaseContext(p *DataTypeBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_dataTypeBase
|
|
}
|
|
|
|
func (*DataTypeBaseContext) IsDataTypeBaseContext() {}
|
|
|
|
func NewDataTypeBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeBaseContext {
|
|
var p = new(DataTypeBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_dataTypeBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *DataTypeBaseContext) DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) DATETIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATETIME, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) YEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) ENUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENUM, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) TEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEXT, 0)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterDataTypeBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitDataTypeBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *DataTypeBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitDataTypeBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) DataTypeBase() (localctx IDataTypeBaseContext) {
|
|
localctx = NewDataTypeBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 716, MySqlParserRULE_dataTypeBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7443)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&1179679) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IKeywordsCanBeIdContext is an interface to support dynamic dispatch.
|
|
type IKeywordsCanBeIdContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ACCOUNT() antlr.TerminalNode
|
|
ACTION() antlr.TerminalNode
|
|
ADMIN() antlr.TerminalNode
|
|
AFTER() antlr.TerminalNode
|
|
AGGREGATE() antlr.TerminalNode
|
|
ALGORITHM() antlr.TerminalNode
|
|
ANY() antlr.TerminalNode
|
|
ARRAY() antlr.TerminalNode
|
|
AT() antlr.TerminalNode
|
|
AUDIT_ADMIN() antlr.TerminalNode
|
|
AUDIT_ABORT_EXEMPT() antlr.TerminalNode
|
|
AUTHORS() antlr.TerminalNode
|
|
AUTOCOMMIT() antlr.TerminalNode
|
|
AUTOEXTEND_SIZE() antlr.TerminalNode
|
|
AUTO_INCREMENT() antlr.TerminalNode
|
|
AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode
|
|
AVG() antlr.TerminalNode
|
|
AVG_ROW_LENGTH() antlr.TerminalNode
|
|
ATTRIBUTE() antlr.TerminalNode
|
|
BACKUP_ADMIN() antlr.TerminalNode
|
|
BEGIN() antlr.TerminalNode
|
|
BINLOG() antlr.TerminalNode
|
|
BINLOG_ADMIN() antlr.TerminalNode
|
|
BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode
|
|
BIT() antlr.TerminalNode
|
|
BIT_AND() antlr.TerminalNode
|
|
BIT_OR() antlr.TerminalNode
|
|
BIT_XOR() antlr.TerminalNode
|
|
BLOCK() antlr.TerminalNode
|
|
BOOL() antlr.TerminalNode
|
|
BOOLEAN() antlr.TerminalNode
|
|
BTREE() antlr.TerminalNode
|
|
BUCKETS() antlr.TerminalNode
|
|
CACHE() antlr.TerminalNode
|
|
CASCADED() antlr.TerminalNode
|
|
CHAIN() antlr.TerminalNode
|
|
CHANGED() antlr.TerminalNode
|
|
CHANNEL() antlr.TerminalNode
|
|
CHECKSUM() antlr.TerminalNode
|
|
PAGE_CHECKSUM() antlr.TerminalNode
|
|
CATALOG_NAME() antlr.TerminalNode
|
|
CIPHER() antlr.TerminalNode
|
|
CLASS_ORIGIN() antlr.TerminalNode
|
|
CLIENT() antlr.TerminalNode
|
|
CLONE_ADMIN() antlr.TerminalNode
|
|
CLOSE() antlr.TerminalNode
|
|
CLUSTERING() antlr.TerminalNode
|
|
COALESCE() antlr.TerminalNode
|
|
CODE() antlr.TerminalNode
|
|
COLUMNS() antlr.TerminalNode
|
|
COLUMN_FORMAT() antlr.TerminalNode
|
|
COLUMN_NAME() antlr.TerminalNode
|
|
COMMENT() antlr.TerminalNode
|
|
COMMIT() antlr.TerminalNode
|
|
COMPACT() antlr.TerminalNode
|
|
COMPLETION() antlr.TerminalNode
|
|
COMPRESSED() antlr.TerminalNode
|
|
COMPRESSION() antlr.TerminalNode
|
|
CONCURRENT() antlr.TerminalNode
|
|
CONDITION() antlr.TerminalNode
|
|
CONNECT() antlr.TerminalNode
|
|
CONNECTION() antlr.TerminalNode
|
|
CONNECTION_ADMIN() antlr.TerminalNode
|
|
CONSISTENT() antlr.TerminalNode
|
|
CONSTRAINT_CATALOG() antlr.TerminalNode
|
|
CONSTRAINT_NAME() antlr.TerminalNode
|
|
CONSTRAINT_SCHEMA() antlr.TerminalNode
|
|
CONTAINS() antlr.TerminalNode
|
|
CONTEXT() antlr.TerminalNode
|
|
CONTRIBUTORS() antlr.TerminalNode
|
|
COPY() antlr.TerminalNode
|
|
COUNT() antlr.TerminalNode
|
|
CPU() antlr.TerminalNode
|
|
CURRENT() antlr.TerminalNode
|
|
CURRENT_USER() antlr.TerminalNode
|
|
CURSOR_NAME() antlr.TerminalNode
|
|
DATA() antlr.TerminalNode
|
|
DATAFILE() antlr.TerminalNode
|
|
DEALLOCATE() antlr.TerminalNode
|
|
DEFAULT() antlr.TerminalNode
|
|
DEFAULT_AUTH() antlr.TerminalNode
|
|
DEFINER() antlr.TerminalNode
|
|
DELAY_KEY_WRITE() antlr.TerminalNode
|
|
DES_KEY_FILE() antlr.TerminalNode
|
|
DIAGNOSTICS() antlr.TerminalNode
|
|
DIRECTORY() antlr.TerminalNode
|
|
DISABLE() antlr.TerminalNode
|
|
DISCARD() antlr.TerminalNode
|
|
DISK() antlr.TerminalNode
|
|
DO() antlr.TerminalNode
|
|
DUMPFILE() antlr.TerminalNode
|
|
DUPLICATE() antlr.TerminalNode
|
|
DYNAMIC() antlr.TerminalNode
|
|
EMPTY() antlr.TerminalNode
|
|
ENABLE() antlr.TerminalNode
|
|
ENCRYPTION() antlr.TerminalNode
|
|
ENCRYPTION_KEY_ADMIN() antlr.TerminalNode
|
|
END() antlr.TerminalNode
|
|
ENDS() antlr.TerminalNode
|
|
ENGINE() antlr.TerminalNode
|
|
ENGINE_ATTRIBUTE() antlr.TerminalNode
|
|
ENGINES() antlr.TerminalNode
|
|
ENFORCED() antlr.TerminalNode
|
|
ERROR() antlr.TerminalNode
|
|
ERRORS() antlr.TerminalNode
|
|
ESCAPE() antlr.TerminalNode
|
|
EUR() antlr.TerminalNode
|
|
EVEN() antlr.TerminalNode
|
|
EVENT() antlr.TerminalNode
|
|
EVENTS() antlr.TerminalNode
|
|
EVERY() antlr.TerminalNode
|
|
EXCEPT() antlr.TerminalNode
|
|
EXCHANGE() antlr.TerminalNode
|
|
EXCLUSIVE() antlr.TerminalNode
|
|
EXPIRE() antlr.TerminalNode
|
|
EXPORT() antlr.TerminalNode
|
|
EXTENDED() antlr.TerminalNode
|
|
EXTENT_SIZE() antlr.TerminalNode
|
|
FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode
|
|
FAST() antlr.TerminalNode
|
|
FAULTS() antlr.TerminalNode
|
|
FIELDS() antlr.TerminalNode
|
|
FILE_BLOCK_SIZE() antlr.TerminalNode
|
|
FILTER() antlr.TerminalNode
|
|
FIREWALL_ADMIN() antlr.TerminalNode
|
|
FIREWALL_EXEMPT() antlr.TerminalNode
|
|
FIREWALL_USER() antlr.TerminalNode
|
|
FIRST() antlr.TerminalNode
|
|
FIXED() antlr.TerminalNode
|
|
FLUSH() antlr.TerminalNode
|
|
FOLLOWS() antlr.TerminalNode
|
|
FOUND() antlr.TerminalNode
|
|
FULL() antlr.TerminalNode
|
|
FUNCTION() antlr.TerminalNode
|
|
GENERAL() antlr.TerminalNode
|
|
GLOBAL() antlr.TerminalNode
|
|
GRANTS() antlr.TerminalNode
|
|
GROUP() antlr.TerminalNode
|
|
GROUP_CONCAT() antlr.TerminalNode
|
|
GROUP_REPLICATION() antlr.TerminalNode
|
|
GROUP_REPLICATION_ADMIN() antlr.TerminalNode
|
|
HANDLER() antlr.TerminalNode
|
|
HASH() antlr.TerminalNode
|
|
HELP() antlr.TerminalNode
|
|
HISTORY() antlr.TerminalNode
|
|
HOST() antlr.TerminalNode
|
|
HOSTS() antlr.TerminalNode
|
|
IDENTIFIED() antlr.TerminalNode
|
|
IGNORED() antlr.TerminalNode
|
|
IGNORE_SERVER_IDS() antlr.TerminalNode
|
|
IMPORT() antlr.TerminalNode
|
|
INDEXES() antlr.TerminalNode
|
|
INITIAL_SIZE() antlr.TerminalNode
|
|
INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode
|
|
INPLACE() antlr.TerminalNode
|
|
INSERT_METHOD() antlr.TerminalNode
|
|
INSTALL() antlr.TerminalNode
|
|
INSTANCE() antlr.TerminalNode
|
|
INSTANT() antlr.TerminalNode
|
|
INTERNAL() antlr.TerminalNode
|
|
INVOKE() antlr.TerminalNode
|
|
INVOKER() antlr.TerminalNode
|
|
IO() antlr.TerminalNode
|
|
IO_THREAD() antlr.TerminalNode
|
|
IPC() antlr.TerminalNode
|
|
ISO() antlr.TerminalNode
|
|
ISOLATION() antlr.TerminalNode
|
|
ISSUER() antlr.TerminalNode
|
|
JIS() antlr.TerminalNode
|
|
JSON() antlr.TerminalNode
|
|
KEY_BLOCK_SIZE() antlr.TerminalNode
|
|
LAMBDA() antlr.TerminalNode
|
|
LANGUAGE() antlr.TerminalNode
|
|
LAST() antlr.TerminalNode
|
|
LATERAL() antlr.TerminalNode
|
|
LEAVES() antlr.TerminalNode
|
|
LESS() antlr.TerminalNode
|
|
LEVEL() antlr.TerminalNode
|
|
LIST() antlr.TerminalNode
|
|
LOCAL() antlr.TerminalNode
|
|
LOGFILE() antlr.TerminalNode
|
|
LOGS() antlr.TerminalNode
|
|
MASTER() antlr.TerminalNode
|
|
MASTER_AUTO_POSITION() antlr.TerminalNode
|
|
MASTER_CONNECT_RETRY() antlr.TerminalNode
|
|
MASTER_DELAY() antlr.TerminalNode
|
|
MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode
|
|
MASTER_HOST() antlr.TerminalNode
|
|
MASTER_LOG_FILE() antlr.TerminalNode
|
|
MASTER_LOG_POS() antlr.TerminalNode
|
|
MASTER_PASSWORD() antlr.TerminalNode
|
|
MASTER_PORT() antlr.TerminalNode
|
|
MASTER_RETRY_COUNT() antlr.TerminalNode
|
|
MASTER_SSL() antlr.TerminalNode
|
|
MASTER_SSL_CA() antlr.TerminalNode
|
|
MASTER_SSL_CAPATH() antlr.TerminalNode
|
|
MASTER_SSL_CERT() antlr.TerminalNode
|
|
MASTER_SSL_CIPHER() antlr.TerminalNode
|
|
MASTER_SSL_CRL() antlr.TerminalNode
|
|
MASTER_SSL_CRLPATH() antlr.TerminalNode
|
|
MASTER_SSL_KEY() antlr.TerminalNode
|
|
MASTER_TLS_VERSION() antlr.TerminalNode
|
|
MASTER_USER() antlr.TerminalNode
|
|
MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode
|
|
MAX_QUERIES_PER_HOUR() antlr.TerminalNode
|
|
MAX() antlr.TerminalNode
|
|
MAX_ROWS() antlr.TerminalNode
|
|
MAX_SIZE() antlr.TerminalNode
|
|
MAX_UPDATES_PER_HOUR() antlr.TerminalNode
|
|
MAX_USER_CONNECTIONS() antlr.TerminalNode
|
|
MEDIUM() antlr.TerminalNode
|
|
MEMBER() antlr.TerminalNode
|
|
MEMORY() antlr.TerminalNode
|
|
MERGE() antlr.TerminalNode
|
|
MESSAGE_TEXT() antlr.TerminalNode
|
|
MID() antlr.TerminalNode
|
|
MIGRATE() antlr.TerminalNode
|
|
MIN() antlr.TerminalNode
|
|
MIN_ROWS() antlr.TerminalNode
|
|
MODE() antlr.TerminalNode
|
|
MODIFY() antlr.TerminalNode
|
|
MUTEX() antlr.TerminalNode
|
|
MYSQL() antlr.TerminalNode
|
|
MYSQL_ERRNO() antlr.TerminalNode
|
|
NAME() antlr.TerminalNode
|
|
NAMES() antlr.TerminalNode
|
|
NCHAR() antlr.TerminalNode
|
|
NDB_STORED_USER() antlr.TerminalNode
|
|
NESTED() antlr.TerminalNode
|
|
NEVER() antlr.TerminalNode
|
|
NEXT() antlr.TerminalNode
|
|
NO() antlr.TerminalNode
|
|
NOCOPY() antlr.TerminalNode
|
|
NODEGROUP() antlr.TerminalNode
|
|
NONE() antlr.TerminalNode
|
|
NOWAIT() antlr.TerminalNode
|
|
NUMBER() antlr.TerminalNode
|
|
ODBC() antlr.TerminalNode
|
|
OFFLINE() antlr.TerminalNode
|
|
OFFSET() antlr.TerminalNode
|
|
OF() antlr.TerminalNode
|
|
OJ() antlr.TerminalNode
|
|
OLD_PASSWORD() antlr.TerminalNode
|
|
ONE() antlr.TerminalNode
|
|
ONLINE() antlr.TerminalNode
|
|
ONLY() antlr.TerminalNode
|
|
OPEN() antlr.TerminalNode
|
|
OPTIMIZER_COSTS() antlr.TerminalNode
|
|
OPTIONAL() antlr.TerminalNode
|
|
OPTIONS() antlr.TerminalNode
|
|
ORDER() antlr.TerminalNode
|
|
ORDINALITY() antlr.TerminalNode
|
|
OWNER() antlr.TerminalNode
|
|
PACK_KEYS() antlr.TerminalNode
|
|
PAGE() antlr.TerminalNode
|
|
PARSER() antlr.TerminalNode
|
|
PARTIAL() antlr.TerminalNode
|
|
PARTITIONING() antlr.TerminalNode
|
|
PARTITIONS() antlr.TerminalNode
|
|
PASSWORD() antlr.TerminalNode
|
|
PASSWORDLESS_USER_ADMIN() antlr.TerminalNode
|
|
PASSWORD_LOCK_TIME() antlr.TerminalNode
|
|
PATH() antlr.TerminalNode
|
|
PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode
|
|
PHASE() antlr.TerminalNode
|
|
PLUGINS() antlr.TerminalNode
|
|
PLUGIN_DIR() antlr.TerminalNode
|
|
PLUGIN() antlr.TerminalNode
|
|
PORT() antlr.TerminalNode
|
|
PRECEDES() antlr.TerminalNode
|
|
PREPARE() antlr.TerminalNode
|
|
PRESERVE() antlr.TerminalNode
|
|
PREV() antlr.TerminalNode
|
|
PRIMARY() antlr.TerminalNode
|
|
PROCESSLIST() antlr.TerminalNode
|
|
PROFILE() antlr.TerminalNode
|
|
PROFILES() antlr.TerminalNode
|
|
PROXY() antlr.TerminalNode
|
|
QUERY() antlr.TerminalNode
|
|
QUICK() antlr.TerminalNode
|
|
REBUILD() antlr.TerminalNode
|
|
RECOVER() antlr.TerminalNode
|
|
RECURSIVE() antlr.TerminalNode
|
|
REDO_BUFFER_SIZE() antlr.TerminalNode
|
|
REDUNDANT() antlr.TerminalNode
|
|
RELAY() antlr.TerminalNode
|
|
RELAYLOG() antlr.TerminalNode
|
|
RELAY_LOG_FILE() antlr.TerminalNode
|
|
RELAY_LOG_POS() antlr.TerminalNode
|
|
REMOVE() antlr.TerminalNode
|
|
REORGANIZE() antlr.TerminalNode
|
|
REPAIR() antlr.TerminalNode
|
|
REPLICATE_DO_DB() antlr.TerminalNode
|
|
REPLICATE_DO_TABLE() antlr.TerminalNode
|
|
REPLICATE_IGNORE_DB() antlr.TerminalNode
|
|
REPLICATE_IGNORE_TABLE() antlr.TerminalNode
|
|
REPLICATE_REWRITE_DB() antlr.TerminalNode
|
|
REPLICATE_WILD_DO_TABLE() antlr.TerminalNode
|
|
REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode
|
|
REPLICATION() antlr.TerminalNode
|
|
REPLICATION_APPLIER() antlr.TerminalNode
|
|
REPLICATION_SLAVE_ADMIN() antlr.TerminalNode
|
|
RESET() antlr.TerminalNode
|
|
RESOURCE_GROUP_ADMIN() antlr.TerminalNode
|
|
RESOURCE_GROUP_USER() antlr.TerminalNode
|
|
RESUME() antlr.TerminalNode
|
|
RETURNED_SQLSTATE() antlr.TerminalNode
|
|
RETURNING() antlr.TerminalNode
|
|
RETURNS() antlr.TerminalNode
|
|
REUSE() antlr.TerminalNode
|
|
ROLE() antlr.TerminalNode
|
|
ROLE_ADMIN() antlr.TerminalNode
|
|
ROLLBACK() antlr.TerminalNode
|
|
ROLLUP() antlr.TerminalNode
|
|
ROTATE() antlr.TerminalNode
|
|
ROW() antlr.TerminalNode
|
|
ROWS() antlr.TerminalNode
|
|
ROW_FORMAT() antlr.TerminalNode
|
|
RTREE() antlr.TerminalNode
|
|
S3() antlr.TerminalNode
|
|
SAVEPOINT() antlr.TerminalNode
|
|
SCHEDULE() antlr.TerminalNode
|
|
SCHEMA_NAME() antlr.TerminalNode
|
|
SECURITY() antlr.TerminalNode
|
|
SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode
|
|
SERIAL() antlr.TerminalNode
|
|
SERVER() antlr.TerminalNode
|
|
SESSION() antlr.TerminalNode
|
|
SESSION_VARIABLES_ADMIN() antlr.TerminalNode
|
|
SET_USER_ID() antlr.TerminalNode
|
|
SHARE() antlr.TerminalNode
|
|
SHARED() antlr.TerminalNode
|
|
SHOW_ROUTINE() antlr.TerminalNode
|
|
SIGNED() antlr.TerminalNode
|
|
SIMPLE() antlr.TerminalNode
|
|
SLAVE() antlr.TerminalNode
|
|
SLOW() antlr.TerminalNode
|
|
SKIP_QUERY_REWRITE() antlr.TerminalNode
|
|
SNAPSHOT() antlr.TerminalNode
|
|
SOCKET() antlr.TerminalNode
|
|
SOME() antlr.TerminalNode
|
|
SONAME() antlr.TerminalNode
|
|
SOUNDS() antlr.TerminalNode
|
|
SOURCE() antlr.TerminalNode
|
|
SQL_AFTER_GTIDS() antlr.TerminalNode
|
|
SQL_AFTER_MTS_GAPS() antlr.TerminalNode
|
|
SQL_BEFORE_GTIDS() antlr.TerminalNode
|
|
SQL_BUFFER_RESULT() antlr.TerminalNode
|
|
SQL_CACHE() antlr.TerminalNode
|
|
SQL_NO_CACHE() antlr.TerminalNode
|
|
SQL_THREAD() antlr.TerminalNode
|
|
STACKED() antlr.TerminalNode
|
|
START() antlr.TerminalNode
|
|
STARTS() antlr.TerminalNode
|
|
STATS_AUTO_RECALC() antlr.TerminalNode
|
|
STATS_PERSISTENT() antlr.TerminalNode
|
|
STATS_SAMPLE_PAGES() antlr.TerminalNode
|
|
STATUS() antlr.TerminalNode
|
|
STD() antlr.TerminalNode
|
|
STDDEV() antlr.TerminalNode
|
|
STDDEV_POP() antlr.TerminalNode
|
|
STDDEV_SAMP() antlr.TerminalNode
|
|
STOP() antlr.TerminalNode
|
|
STORAGE() antlr.TerminalNode
|
|
STRING() antlr.TerminalNode
|
|
SUBCLASS_ORIGIN() antlr.TerminalNode
|
|
SUBJECT() antlr.TerminalNode
|
|
SUBPARTITION() antlr.TerminalNode
|
|
SUBPARTITIONS() antlr.TerminalNode
|
|
SUM() antlr.TerminalNode
|
|
SUSPEND() antlr.TerminalNode
|
|
SWAPS() antlr.TerminalNode
|
|
SWITCHES() antlr.TerminalNode
|
|
SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode
|
|
TABLE_NAME() antlr.TerminalNode
|
|
TABLESPACE() antlr.TerminalNode
|
|
TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode
|
|
TABLE_TYPE() antlr.TerminalNode
|
|
TEMPORARY() antlr.TerminalNode
|
|
TEMPTABLE() antlr.TerminalNode
|
|
THAN() antlr.TerminalNode
|
|
TP_CONNECTION_ADMIN() antlr.TerminalNode
|
|
TRADITIONAL() antlr.TerminalNode
|
|
TRANSACTION() antlr.TerminalNode
|
|
TRANSACTIONAL() antlr.TerminalNode
|
|
TRIGGERS() antlr.TerminalNode
|
|
TRUNCATE() antlr.TerminalNode
|
|
UNBOUNDED() antlr.TerminalNode
|
|
UNDEFINED() antlr.TerminalNode
|
|
UNDOFILE() antlr.TerminalNode
|
|
UNDO_BUFFER_SIZE() antlr.TerminalNode
|
|
UNINSTALL() antlr.TerminalNode
|
|
UNKNOWN() antlr.TerminalNode
|
|
UNTIL() antlr.TerminalNode
|
|
UPGRADE() antlr.TerminalNode
|
|
USA() antlr.TerminalNode
|
|
USER() antlr.TerminalNode
|
|
USE_FRM() antlr.TerminalNode
|
|
USER_RESOURCES() antlr.TerminalNode
|
|
VALIDATION() antlr.TerminalNode
|
|
VALUE() antlr.TerminalNode
|
|
VAR_POP() antlr.TerminalNode
|
|
VAR_SAMP() antlr.TerminalNode
|
|
VARIABLES() antlr.TerminalNode
|
|
VARIANCE() antlr.TerminalNode
|
|
VERSION_TOKEN_ADMIN() antlr.TerminalNode
|
|
VIEW() antlr.TerminalNode
|
|
VIRTUAL() antlr.TerminalNode
|
|
WAIT() antlr.TerminalNode
|
|
WARNINGS() antlr.TerminalNode
|
|
WITHOUT() antlr.TerminalNode
|
|
WORK() antlr.TerminalNode
|
|
WRAPPER() antlr.TerminalNode
|
|
X509() antlr.TerminalNode
|
|
XA() antlr.TerminalNode
|
|
XA_RECOVER_ADMIN() antlr.TerminalNode
|
|
XML() antlr.TerminalNode
|
|
YES() antlr.TerminalNode
|
|
|
|
// IsKeywordsCanBeIdContext differentiates from other interfaces.
|
|
IsKeywordsCanBeIdContext()
|
|
}
|
|
|
|
type KeywordsCanBeIdContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyKeywordsCanBeIdContext() *KeywordsCanBeIdContext {
|
|
var p = new(KeywordsCanBeIdContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_keywordsCanBeId
|
|
return p
|
|
}
|
|
|
|
func InitEmptyKeywordsCanBeIdContext(p *KeywordsCanBeIdContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_keywordsCanBeId
|
|
}
|
|
|
|
func (*KeywordsCanBeIdContext) IsKeywordsCanBeIdContext() {}
|
|
|
|
func NewKeywordsCanBeIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordsCanBeIdContext {
|
|
var p = new(KeywordsCanBeIdContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_keywordsCanBeId
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *KeywordsCanBeIdContext) ACCOUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserACCOUNT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserACTION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AFTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAFTER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AGGREGATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAGGREGATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ALGORITHM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserALGORITHM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ANY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserANY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ARRAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserARRAY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUDIT_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUDIT_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUDIT_ABORT_EXEMPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUDIT_ABORT_EXEMPT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUTHORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTHORS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUTOCOMMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTOCOMMIT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUTOEXTEND_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUTO_INCREMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTO_INCREMENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAUTHENTICATION_POLICY_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AVG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAVG, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) AVG_ROW_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAVG_ROW_LENGTH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BACKUP_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBACKUP_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BEGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBEGIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BINLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BINLOG_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBINLOG_ENCRYPTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BIT_AND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_AND, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BIT_OR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_OR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BIT_XOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_XOR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BLOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBLOCK, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BOOL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBOOL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BOOLEAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBOOLEAN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BTREE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBTREE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) BUCKETS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBUCKETS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCACHE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CASCADED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCASCADED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CHAIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CHANGED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANGED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CHANNEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHANNEL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CHECKSUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHECKSUM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PAGE_CHECKSUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE_CHECKSUM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CATALOG_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCATALOG_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CIPHER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCIPHER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CLIENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLIENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CLONE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLONE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CLOSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLOSE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CLUSTERING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCLUSTERING, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COALESCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOALESCE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCODE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COLUMNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMNS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COLUMN_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN_FORMAT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COLUMN_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLUMN_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMMIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMMIT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMPACT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPACT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMPLETION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPLETION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMPRESSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPRESSED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COMPRESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPRESSION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONCURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONCURRENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONDITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONDITION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONNECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONNECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONNECTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONSISTENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSISTENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONSTRAINT_CATALOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONSTRAINT_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONSTRAINT_SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONTAINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTAINS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTEXT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CONTRIBUTORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONTRIBUTORS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COPY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOPY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOUNT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CPU() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCPU, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CURRENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CURRENT_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURRENT_USER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) CURSOR_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCURSOR_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DATA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DATAFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATAFILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DEALLOCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEALLOCATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DEFAULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DEFAULT_AUTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFAULT_AUTH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DEFINER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEFINER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DELAY_KEY_WRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDELAY_KEY_WRITE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DES_KEY_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDES_KEY_FILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DIAGNOSTICS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIAGNOSTICS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DIRECTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIRECTORY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DISABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DISCARD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISCARD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DISK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISK, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDO, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DUMPFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDUMPFILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DUPLICATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDUPLICATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) DYNAMIC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDYNAMIC, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EMPTY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEMPTY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENCRYPTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENCRYPTION_KEY_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPTION_KEY_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) END() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEND, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENGINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENGINES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENGINES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ENFORCED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENFORCED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ERROR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERROR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ERRORS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserERRORS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ESCAPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserESCAPE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEUR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EVEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVEN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EVENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EVENTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVENTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EVERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEVERY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXCEPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCEPT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXCHANGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCHANGE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXCLUSIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXCLUSIVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXPIRE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPIRE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPORT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXTENDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENDED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EXTENT_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTENT_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAILED_LOGIN_ATTEMPTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FAULTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFAULTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIELDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIELDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FILE_BLOCK_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILE_BLOCK_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FILTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFILTER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIREWALL_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIREWALL_EXEMPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_EXEMPT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIREWALL_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIREWALL_USER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIRST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FIXED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIXED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FLUSH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLUSH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FOLLOWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOLLOWS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FOUND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOUND, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFULL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFUNCTION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GENERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGENERAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GLOBAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLOBAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GRANTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGRANTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GROUP_CONCAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_CONCAT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GROUP_REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_REPLICATION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GROUP_REPLICATION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGROUP_REPLICATION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HANDLER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHANDLER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HASH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHASH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HELP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHELP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HISTORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHISTORY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HOST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) HOSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOSTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IDENTIFIED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIDENTIFIED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IGNORED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IGNORE_SERVER_IDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIGNORE_SERVER_IDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IMPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIMPORT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INDEXES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINDEXES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INITIAL_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINITIAL_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINNODB_REDO_LOG_ARCHIVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINPLACE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INSERT_METHOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSERT_METHOD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INSTALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTALL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INSTANCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTANCE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INSTANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTANT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INTERNAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERNAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INVOKE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) INVOKER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVOKER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIO, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IO_THREAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIO_THREAD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) IPC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIPC, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ISO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISO, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ISOLATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISOLATION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ISSUER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISSUER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) JIS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJIS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) JSON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) KEY_BLOCK_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LAMBDA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAMBDA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LANGUAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLANGUAGE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LATERAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLATERAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LEAVES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAVES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLESS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LEVEL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEVEL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLIST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LOCAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LOGFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGFILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) LOGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOGS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_AUTO_POSITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_AUTO_POSITION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_CONNECT_RETRY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_CONNECT_RETRY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_DELAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_DELAY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_HEARTBEAT_PERIOD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_HOST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_HOST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_PASSWORD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_PORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_PORT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_RETRY_COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_RETRY_COUNT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CAPATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CAPATH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CERT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CIPHER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CIPHER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CRL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CRL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_CRLPATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_CRLPATH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_SSL_KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_SSL_KEY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_TLS_VERSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_TLS_VERSION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MASTER_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_USER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_CONNECTIONS_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_QUERIES_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_QUERIES_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_ROWS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_UPDATES_PER_HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_UPDATES_PER_HOUR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MAX_USER_CONNECTIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAX_USER_CONNECTIONS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MEDIUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEDIUM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MEMBER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMBER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MEMORY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMEMORY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MERGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMERGE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MESSAGE_TEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMESSAGE_TEXT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMID, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MIGRATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIGRATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MIN_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMIN_ROWS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MODIFY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMODIFY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MUTEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMUTEX, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MYSQL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) MYSQL_ERRNO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMYSQL_ERRNO, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NAMES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNAMES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NCHAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNCHAR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NDB_STORED_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNDB_STORED_USER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NESTED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNESTED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NEVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEVER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNEXT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NO() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNO, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NOCOPY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOCOPY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NODEGROUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNODEGROUP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNONE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NOWAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNOWAIT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) NUMBER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMBER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ODBC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserODBC, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OFFLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFLINE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OFFSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOFFSET, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOF, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OJ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOJ, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OLD_PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOLD_PASSWORD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ONE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ONLINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLINE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ONLY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserONLY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OPEN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPEN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OPTIMIZER_COSTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIMIZER_COSTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OPTIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OPTIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOPTIONS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ORDER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ORDINALITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORDINALITY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) OWNER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOWNER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PACK_KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPACK_KEYS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPAGE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PARSER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARSER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PARTIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTIAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PARTITIONING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONING, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PARTITIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPARTITIONS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PASSWORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PASSWORDLESS_USER_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORDLESS_USER_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PASSWORD_LOCK_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPASSWORD_LOCK_TIME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPATH, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERSIST_RO_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PHASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPHASE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PLUGINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGINS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PLUGIN_DIR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGIN_DIR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PLUGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPLUGIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPORT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PRECEDES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRECEDES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PREPARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREPARE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PRESERVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRESERVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PREV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPREV, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PRIMARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPRIMARY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PROCESSLIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROCESSLIST, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PROFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROFILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PROFILES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROFILES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) PROXY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPROXY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) QUERY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUERY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) QUICK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUICK, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REBUILD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREBUILD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RECOVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRECOVER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RECURSIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRECURSIVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REDO_BUFFER_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREDO_BUFFER_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REDUNDANT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREDUNDANT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RELAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RELAYLOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAYLOG, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RELAY_LOG_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_FILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RELAY_LOG_POS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELAY_LOG_POS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REMOVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREMOVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REORGANIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREORGANIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPAIR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPAIR, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_DO_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_DO_DB, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_DO_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_DO_TABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_IGNORE_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_IGNORE_DB, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_IGNORE_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_IGNORE_TABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_REWRITE_DB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_REWRITE_DB, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_WILD_DO_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_WILD_DO_TABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATE_WILD_IGNORE_TABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATION_APPLIER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION_APPLIER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REPLICATION_SLAVE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREPLICATION_SLAVE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RESET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESET, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESOURCE_GROUP_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESOURCE_GROUP_USER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RESUME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRESUME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RETURNED_SQLSTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNED_SQLSTATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RETURNING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNING, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RETURNS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRETURNS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) REUSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREUSE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROLE_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLE_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROLLBACK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLBACK, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROLLUP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROLLUP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROTATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROTATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROWS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ROW_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_FORMAT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) RTREE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRTREE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) S3() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserS3, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SAVEPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSAVEPOINT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SCHEDULE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEDULE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SCHEMA_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SECURITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECURITY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SERIAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERIAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SERVER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSERVER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SESSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SET_USER_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSET_USER_ID, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SHARE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SHARED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHARED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SHOW_ROUTINE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHOW_ROUTINE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SIGNED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIGNED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SIMPLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIMPLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SLAVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLAVE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SLOW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLOW, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SKIP_QUERY_REWRITE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSKIP_QUERY_REWRITE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SNAPSHOT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSNAPSHOT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SOCKET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOCKET, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SOME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SONAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSONAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SOUNDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOUNDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SOURCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOURCE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_AFTER_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_AFTER_GTIDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_AFTER_MTS_GAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_AFTER_MTS_GAPS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_BEFORE_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_BEFORE_GTIDS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_BUFFER_RESULT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_BUFFER_RESULT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_CACHE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_NO_CACHE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_NO_CACHE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SQL_THREAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_THREAD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STACKED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTACKED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) START() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTART, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STARTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTARTS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STATS_AUTO_RECALC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_AUTO_RECALC, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STATS_PERSISTENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_PERSISTENT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STATS_SAMPLE_PAGES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATS_SAMPLE_PAGES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STATUS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATUS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTD, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STDDEV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STDDEV_POP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV_POP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STDDEV_SAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTDDEV_SAMP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STOP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTOP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STORAGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTORAGE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRING, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUBCLASS_ORIGIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUBJECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBJECT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUBPARTITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBPARTITION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUBPARTITIONS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBPARTITIONS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SUSPEND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUSPEND, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SWAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSWAPS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SWITCHES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSWITCHES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSYSTEM_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TABLE_NAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_NAME, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TABLESPACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLESPACE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_ENCRYPTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TABLE_TYPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTABLE_TYPE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TEMPORARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPORARY, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TEMPTABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTEMPTABLE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) THAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTHAN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TP_CONNECTION_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTP_CONNECTION_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TRADITIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRADITIONAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TRANSACTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TRANSACTIONAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRANSACTIONAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TRIGGERS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRIGGERS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) TRUNCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTRUNCATE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNBOUNDED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNBOUNDED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNDEFINED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDEFINED, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNDOFILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDOFILE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNDO_BUFFER_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNDO_BUFFER_SIZE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNINSTALL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNINSTALL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNKNOWN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNKNOWN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UNTIL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNTIL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) UPGRADE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPGRADE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) USA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) USE_FRM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSE_FRM, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) USER_RESOURCES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUSER_RESOURCES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VALIDATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALIDATION, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALUE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VAR_POP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_POP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VAR_SAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVAR_SAMP, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VARIABLES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARIABLES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VARIANCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVARIANCE, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VERSION_TOKEN_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVERSION_TOKEN_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VIEW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIEW, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) VIRTUAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVIRTUAL, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) WARNINGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWARNINGS, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) WITHOUT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITHOUT, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) WORK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWORK, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) WRAPPER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWRAPPER, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) X509() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserX509, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) XA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) XA_RECOVER_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXA_RECOVER_ADMIN, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) XML() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserXML, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) YES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYES, 0)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterKeywordsCanBeId(s)
|
|
}
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitKeywordsCanBeId(s)
|
|
}
|
|
}
|
|
|
|
func (s *KeywordsCanBeIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitKeywordsCanBeId(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) KeywordsCanBeId() (localctx IKeywordsCanBeIdContext) {
|
|
localctx = NewKeywordsCanBeIdContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 718, MySqlParserRULE_keywordsCanBeId)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7445)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756890782757308416) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055054393409) != 0) || _la == MySqlParserSKIP_QUERY_REWRITE || _la == MySqlParserSTACKED || ((int64((_la-239)) & ^0x3f) == 0 && ((int64(1)<<(_la-239))&1769897061370560513) != 0) || ((int64((_la-305)) & ^0x3f) == 0 && ((int64(1)<<(_la-305))&-134217473) != 0) || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&-171798822913) != 0) || ((int64((_la-434)) & ^0x3f) == 0 && ((int64(1)<<(_la-434))&-33685505) != 0) || ((int64((_la-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&-2306265222165299201) != 0) || ((int64((_la-562)) & ^0x3f) == 0 && ((int64(1)<<(_la-562))&-35184640524289) != 0) || ((int64((_la-626)) & ^0x3f) == 0 && ((int64(1)<<(_la-626))&9222105399459575807) != 0) || ((int64((_la-697)) & ^0x3f) == 0 && ((int64(1)<<(_la-697))&514225960183805) != 0) || _la == MySqlParserMEMORY || _la == MySqlParserCATALOG_NAME || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserSCHEMA_NAME || _la == MySqlParserTP_CONNECTION_ADMIN) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFunctionNameBaseContext is an interface to support dynamic dispatch.
|
|
type IFunctionNameBaseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ABS() antlr.TerminalNode
|
|
ACOS() antlr.TerminalNode
|
|
ADDDATE() antlr.TerminalNode
|
|
ADDTIME() antlr.TerminalNode
|
|
AES_DECRYPT() antlr.TerminalNode
|
|
AES_ENCRYPT() antlr.TerminalNode
|
|
AREA() antlr.TerminalNode
|
|
ASBINARY() antlr.TerminalNode
|
|
ASIN() antlr.TerminalNode
|
|
ASTEXT() antlr.TerminalNode
|
|
ASWKB() antlr.TerminalNode
|
|
ASWKT() antlr.TerminalNode
|
|
ASYMMETRIC_DECRYPT() antlr.TerminalNode
|
|
ASYMMETRIC_DERIVE() antlr.TerminalNode
|
|
ASYMMETRIC_ENCRYPT() antlr.TerminalNode
|
|
ASYMMETRIC_SIGN() antlr.TerminalNode
|
|
ASYMMETRIC_VERIFY() antlr.TerminalNode
|
|
ATAN() antlr.TerminalNode
|
|
ATAN2() antlr.TerminalNode
|
|
BENCHMARK() antlr.TerminalNode
|
|
BIN() antlr.TerminalNode
|
|
BIT_COUNT() antlr.TerminalNode
|
|
BIT_LENGTH() antlr.TerminalNode
|
|
BUFFER() antlr.TerminalNode
|
|
CEIL() antlr.TerminalNode
|
|
CEILING() antlr.TerminalNode
|
|
CENTROID() antlr.TerminalNode
|
|
CHARACTER_LENGTH() antlr.TerminalNode
|
|
CHARSET() antlr.TerminalNode
|
|
CHAR_LENGTH() antlr.TerminalNode
|
|
COERCIBILITY() antlr.TerminalNode
|
|
COLLATION() antlr.TerminalNode
|
|
COMPRESS() antlr.TerminalNode
|
|
CONCAT() antlr.TerminalNode
|
|
CONCAT_WS() antlr.TerminalNode
|
|
CONNECTION_ID() antlr.TerminalNode
|
|
CONV() antlr.TerminalNode
|
|
CONVERT_TZ() antlr.TerminalNode
|
|
COS() antlr.TerminalNode
|
|
COT() antlr.TerminalNode
|
|
COUNT() antlr.TerminalNode
|
|
CRC32() antlr.TerminalNode
|
|
CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode
|
|
CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode
|
|
CREATE_DH_PARAMETERS() antlr.TerminalNode
|
|
CREATE_DIGEST() antlr.TerminalNode
|
|
CROSSES() antlr.TerminalNode
|
|
CUME_DIST() antlr.TerminalNode
|
|
DATABASE() antlr.TerminalNode
|
|
DATE() antlr.TerminalNode
|
|
DATEDIFF() antlr.TerminalNode
|
|
DATE_FORMAT() antlr.TerminalNode
|
|
DAY() antlr.TerminalNode
|
|
DAYNAME() antlr.TerminalNode
|
|
DAYOFMONTH() antlr.TerminalNode
|
|
DAYOFWEEK() antlr.TerminalNode
|
|
DAYOFYEAR() antlr.TerminalNode
|
|
DECODE() antlr.TerminalNode
|
|
DEGREES() antlr.TerminalNode
|
|
DENSE_RANK() antlr.TerminalNode
|
|
DES_DECRYPT() antlr.TerminalNode
|
|
DES_ENCRYPT() antlr.TerminalNode
|
|
DIMENSION() antlr.TerminalNode
|
|
DISJOINT() antlr.TerminalNode
|
|
ELT() antlr.TerminalNode
|
|
ENCODE() antlr.TerminalNode
|
|
ENCRYPT() antlr.TerminalNode
|
|
ENDPOINT() antlr.TerminalNode
|
|
ENVELOPE() antlr.TerminalNode
|
|
EQUALS() antlr.TerminalNode
|
|
EXP() antlr.TerminalNode
|
|
EXPORT_SET() antlr.TerminalNode
|
|
EXTERIORRING() antlr.TerminalNode
|
|
EXTRACTVALUE() antlr.TerminalNode
|
|
FIELD() antlr.TerminalNode
|
|
FIND_IN_SET() antlr.TerminalNode
|
|
FIRST_VALUE() antlr.TerminalNode
|
|
FLOOR() antlr.TerminalNode
|
|
FORMAT() antlr.TerminalNode
|
|
FOUND_ROWS() antlr.TerminalNode
|
|
FROM_BASE64() antlr.TerminalNode
|
|
FROM_DAYS() antlr.TerminalNode
|
|
FROM_UNIXTIME() antlr.TerminalNode
|
|
GEOMCOLLFROMTEXT() antlr.TerminalNode
|
|
GEOMCOLLFROMWKB() antlr.TerminalNode
|
|
GEOMETRYCOLLECTION() antlr.TerminalNode
|
|
GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode
|
|
GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode
|
|
GEOMETRYFROMTEXT() antlr.TerminalNode
|
|
GEOMETRYFROMWKB() antlr.TerminalNode
|
|
GEOMETRYN() antlr.TerminalNode
|
|
GEOMETRYTYPE() antlr.TerminalNode
|
|
GEOMFROMTEXT() antlr.TerminalNode
|
|
GEOMFROMWKB() antlr.TerminalNode
|
|
GET_FORMAT() antlr.TerminalNode
|
|
GET_LOCK() antlr.TerminalNode
|
|
GLENGTH() antlr.TerminalNode
|
|
GREATEST() antlr.TerminalNode
|
|
GTID_SUBSET() antlr.TerminalNode
|
|
GTID_SUBTRACT() antlr.TerminalNode
|
|
HEX() antlr.TerminalNode
|
|
HOUR() antlr.TerminalNode
|
|
IFNULL() antlr.TerminalNode
|
|
INET6_ATON() antlr.TerminalNode
|
|
INET6_NTOA() antlr.TerminalNode
|
|
INET_ATON() antlr.TerminalNode
|
|
INET_NTOA() antlr.TerminalNode
|
|
INSTR() antlr.TerminalNode
|
|
INTERIORRINGN() antlr.TerminalNode
|
|
INTERSECTS() antlr.TerminalNode
|
|
INVISIBLE() antlr.TerminalNode
|
|
ISCLOSED() antlr.TerminalNode
|
|
ISEMPTY() antlr.TerminalNode
|
|
ISNULL() antlr.TerminalNode
|
|
ISSIMPLE() antlr.TerminalNode
|
|
IS_FREE_LOCK() antlr.TerminalNode
|
|
IS_IPV4() antlr.TerminalNode
|
|
IS_IPV4_COMPAT() antlr.TerminalNode
|
|
IS_IPV4_MAPPED() antlr.TerminalNode
|
|
IS_IPV6() antlr.TerminalNode
|
|
IS_USED_LOCK() antlr.TerminalNode
|
|
LAG() antlr.TerminalNode
|
|
LAST_INSERT_ID() antlr.TerminalNode
|
|
LAST_VALUE() antlr.TerminalNode
|
|
LCASE() antlr.TerminalNode
|
|
LEAD() antlr.TerminalNode
|
|
LEAST() antlr.TerminalNode
|
|
LEFT() antlr.TerminalNode
|
|
LENGTH() antlr.TerminalNode
|
|
LINEFROMTEXT() antlr.TerminalNode
|
|
LINEFROMWKB() antlr.TerminalNode
|
|
LINESTRING() antlr.TerminalNode
|
|
LINESTRINGFROMTEXT() antlr.TerminalNode
|
|
LINESTRINGFROMWKB() antlr.TerminalNode
|
|
LN() antlr.TerminalNode
|
|
LOAD_FILE() antlr.TerminalNode
|
|
LOCATE() antlr.TerminalNode
|
|
LOG() antlr.TerminalNode
|
|
LOG10() antlr.TerminalNode
|
|
LOG2() antlr.TerminalNode
|
|
LOWER() antlr.TerminalNode
|
|
LPAD() antlr.TerminalNode
|
|
LTRIM() antlr.TerminalNode
|
|
MAKEDATE() antlr.TerminalNode
|
|
MAKETIME() antlr.TerminalNode
|
|
MAKE_SET() antlr.TerminalNode
|
|
MASTER_POS_WAIT() antlr.TerminalNode
|
|
MBRCONTAINS() antlr.TerminalNode
|
|
MBRDISJOINT() antlr.TerminalNode
|
|
MBREQUAL() antlr.TerminalNode
|
|
MBRINTERSECTS() antlr.TerminalNode
|
|
MBROVERLAPS() antlr.TerminalNode
|
|
MBRTOUCHES() antlr.TerminalNode
|
|
MBRWITHIN() antlr.TerminalNode
|
|
MD5() antlr.TerminalNode
|
|
MICROSECOND() antlr.TerminalNode
|
|
MINUTE() antlr.TerminalNode
|
|
MLINEFROMTEXT() antlr.TerminalNode
|
|
MLINEFROMWKB() antlr.TerminalNode
|
|
MOD() antlr.TerminalNode
|
|
MONTH() antlr.TerminalNode
|
|
MONTHNAME() antlr.TerminalNode
|
|
MPOINTFROMTEXT() antlr.TerminalNode
|
|
MPOINTFROMWKB() antlr.TerminalNode
|
|
MPOLYFROMTEXT() antlr.TerminalNode
|
|
MPOLYFROMWKB() antlr.TerminalNode
|
|
MULTILINESTRING() antlr.TerminalNode
|
|
MULTILINESTRINGFROMTEXT() antlr.TerminalNode
|
|
MULTILINESTRINGFROMWKB() antlr.TerminalNode
|
|
MULTIPOINT() antlr.TerminalNode
|
|
MULTIPOINTFROMTEXT() antlr.TerminalNode
|
|
MULTIPOINTFROMWKB() antlr.TerminalNode
|
|
MULTIPOLYGON() antlr.TerminalNode
|
|
MULTIPOLYGONFROMTEXT() antlr.TerminalNode
|
|
MULTIPOLYGONFROMWKB() antlr.TerminalNode
|
|
NAME_CONST() antlr.TerminalNode
|
|
NTH_VALUE() antlr.TerminalNode
|
|
NTILE() antlr.TerminalNode
|
|
NULLIF() antlr.TerminalNode
|
|
NUMGEOMETRIES() antlr.TerminalNode
|
|
NUMINTERIORRINGS() antlr.TerminalNode
|
|
NUMPOINTS() antlr.TerminalNode
|
|
OCT() antlr.TerminalNode
|
|
OCTET_LENGTH() antlr.TerminalNode
|
|
ORD() antlr.TerminalNode
|
|
OVERLAPS() antlr.TerminalNode
|
|
PERCENT_RANK() antlr.TerminalNode
|
|
PERIOD_ADD() antlr.TerminalNode
|
|
PERIOD_DIFF() antlr.TerminalNode
|
|
PI() antlr.TerminalNode
|
|
POINT() antlr.TerminalNode
|
|
POINTFROMTEXT() antlr.TerminalNode
|
|
POINTFROMWKB() antlr.TerminalNode
|
|
POINTN() antlr.TerminalNode
|
|
POLYFROMTEXT() antlr.TerminalNode
|
|
POLYFROMWKB() antlr.TerminalNode
|
|
POLYGON() antlr.TerminalNode
|
|
POLYGONFROMTEXT() antlr.TerminalNode
|
|
POLYGONFROMWKB() antlr.TerminalNode
|
|
POSITION() antlr.TerminalNode
|
|
POW() antlr.TerminalNode
|
|
POWER() antlr.TerminalNode
|
|
QUARTER() antlr.TerminalNode
|
|
QUOTE() antlr.TerminalNode
|
|
RADIANS() antlr.TerminalNode
|
|
RAND() antlr.TerminalNode
|
|
RANDOM() antlr.TerminalNode
|
|
RANK() antlr.TerminalNode
|
|
RANDOM_BYTES() antlr.TerminalNode
|
|
RELEASE_LOCK() antlr.TerminalNode
|
|
REVERSE() antlr.TerminalNode
|
|
RIGHT() antlr.TerminalNode
|
|
ROUND() antlr.TerminalNode
|
|
ROW_COUNT() antlr.TerminalNode
|
|
ROW_NUMBER() antlr.TerminalNode
|
|
RPAD() antlr.TerminalNode
|
|
RTRIM() antlr.TerminalNode
|
|
SCHEMA() antlr.TerminalNode
|
|
SECOND() antlr.TerminalNode
|
|
SEC_TO_TIME() antlr.TerminalNode
|
|
SESSION_USER() antlr.TerminalNode
|
|
SESSION_VARIABLES_ADMIN() antlr.TerminalNode
|
|
SHA() antlr.TerminalNode
|
|
SHA1() antlr.TerminalNode
|
|
SHA2() antlr.TerminalNode
|
|
SIGN() antlr.TerminalNode
|
|
SIN() antlr.TerminalNode
|
|
SLEEP() antlr.TerminalNode
|
|
SOUNDEX() antlr.TerminalNode
|
|
SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode
|
|
SQRT() antlr.TerminalNode
|
|
SRID() antlr.TerminalNode
|
|
STARTPOINT() antlr.TerminalNode
|
|
STRCMP() antlr.TerminalNode
|
|
STR_TO_DATE() antlr.TerminalNode
|
|
ST_AREA() antlr.TerminalNode
|
|
ST_ASBINARY() antlr.TerminalNode
|
|
ST_ASTEXT() antlr.TerminalNode
|
|
ST_ASWKB() antlr.TerminalNode
|
|
ST_ASWKT() antlr.TerminalNode
|
|
ST_BUFFER() antlr.TerminalNode
|
|
ST_CENTROID() antlr.TerminalNode
|
|
ST_CONTAINS() antlr.TerminalNode
|
|
ST_CROSSES() antlr.TerminalNode
|
|
ST_DIFFERENCE() antlr.TerminalNode
|
|
ST_DIMENSION() antlr.TerminalNode
|
|
ST_DISJOINT() antlr.TerminalNode
|
|
ST_DISTANCE() antlr.TerminalNode
|
|
ST_ENDPOINT() antlr.TerminalNode
|
|
ST_ENVELOPE() antlr.TerminalNode
|
|
ST_EQUALS() antlr.TerminalNode
|
|
ST_EXTERIORRING() antlr.TerminalNode
|
|
ST_GEOMCOLLFROMTEXT() antlr.TerminalNode
|
|
ST_GEOMCOLLFROMTXT() antlr.TerminalNode
|
|
ST_GEOMCOLLFROMWKB() antlr.TerminalNode
|
|
ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode
|
|
ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode
|
|
ST_GEOMETRYFROMTEXT() antlr.TerminalNode
|
|
ST_GEOMETRYFROMWKB() antlr.TerminalNode
|
|
ST_GEOMETRYN() antlr.TerminalNode
|
|
ST_GEOMETRYTYPE() antlr.TerminalNode
|
|
ST_GEOMFROMTEXT() antlr.TerminalNode
|
|
ST_GEOMFROMWKB() antlr.TerminalNode
|
|
ST_INTERIORRINGN() antlr.TerminalNode
|
|
ST_INTERSECTION() antlr.TerminalNode
|
|
ST_INTERSECTS() antlr.TerminalNode
|
|
ST_ISCLOSED() antlr.TerminalNode
|
|
ST_ISEMPTY() antlr.TerminalNode
|
|
ST_ISSIMPLE() antlr.TerminalNode
|
|
ST_LINEFROMTEXT() antlr.TerminalNode
|
|
ST_LINEFROMWKB() antlr.TerminalNode
|
|
ST_LINESTRINGFROMTEXT() antlr.TerminalNode
|
|
ST_LINESTRINGFROMWKB() antlr.TerminalNode
|
|
ST_NUMGEOMETRIES() antlr.TerminalNode
|
|
ST_NUMINTERIORRING() antlr.TerminalNode
|
|
ST_NUMINTERIORRINGS() antlr.TerminalNode
|
|
ST_NUMPOINTS() antlr.TerminalNode
|
|
ST_OVERLAPS() antlr.TerminalNode
|
|
ST_POINTFROMTEXT() antlr.TerminalNode
|
|
ST_POINTFROMWKB() antlr.TerminalNode
|
|
ST_POINTN() antlr.TerminalNode
|
|
ST_POLYFROMTEXT() antlr.TerminalNode
|
|
ST_POLYFROMWKB() antlr.TerminalNode
|
|
ST_POLYGONFROMTEXT() antlr.TerminalNode
|
|
ST_POLYGONFROMWKB() antlr.TerminalNode
|
|
ST_SRID() antlr.TerminalNode
|
|
ST_STARTPOINT() antlr.TerminalNode
|
|
ST_SYMDIFFERENCE() antlr.TerminalNode
|
|
ST_TOUCHES() antlr.TerminalNode
|
|
ST_UNION() antlr.TerminalNode
|
|
ST_WITHIN() antlr.TerminalNode
|
|
ST_X() antlr.TerminalNode
|
|
ST_Y() antlr.TerminalNode
|
|
SUBDATE() antlr.TerminalNode
|
|
SUBSTRING_INDEX() antlr.TerminalNode
|
|
SUBTIME() antlr.TerminalNode
|
|
SYSTEM_USER() antlr.TerminalNode
|
|
TAN() antlr.TerminalNode
|
|
TIME() antlr.TerminalNode
|
|
TIMEDIFF() antlr.TerminalNode
|
|
TIMESTAMP() antlr.TerminalNode
|
|
TIMESTAMPADD() antlr.TerminalNode
|
|
TIMESTAMPDIFF() antlr.TerminalNode
|
|
TIME_FORMAT() antlr.TerminalNode
|
|
TIME_TO_SEC() antlr.TerminalNode
|
|
TOUCHES() antlr.TerminalNode
|
|
TO_BASE64() antlr.TerminalNode
|
|
TO_DAYS() antlr.TerminalNode
|
|
TO_SECONDS() antlr.TerminalNode
|
|
UCASE() antlr.TerminalNode
|
|
UNCOMPRESS() antlr.TerminalNode
|
|
UNCOMPRESSED_LENGTH() antlr.TerminalNode
|
|
UNHEX() antlr.TerminalNode
|
|
UNIX_TIMESTAMP() antlr.TerminalNode
|
|
UPDATEXML() antlr.TerminalNode
|
|
UPPER() antlr.TerminalNode
|
|
UUID() antlr.TerminalNode
|
|
UUID_SHORT() antlr.TerminalNode
|
|
VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode
|
|
VERSION() antlr.TerminalNode
|
|
VISIBLE() antlr.TerminalNode
|
|
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode
|
|
WEEK() antlr.TerminalNode
|
|
WEEKDAY() antlr.TerminalNode
|
|
WEEKOFYEAR() antlr.TerminalNode
|
|
WEIGHT_STRING() antlr.TerminalNode
|
|
WITHIN() antlr.TerminalNode
|
|
YEAR() antlr.TerminalNode
|
|
YEARWEEK() antlr.TerminalNode
|
|
Y_FUNCTION() antlr.TerminalNode
|
|
X_FUNCTION() antlr.TerminalNode
|
|
JSON_ARRAY() antlr.TerminalNode
|
|
JSON_OBJECT() antlr.TerminalNode
|
|
JSON_QUOTE() antlr.TerminalNode
|
|
JSON_CONTAINS() antlr.TerminalNode
|
|
JSON_CONTAINS_PATH() antlr.TerminalNode
|
|
JSON_EXTRACT() antlr.TerminalNode
|
|
JSON_KEYS() antlr.TerminalNode
|
|
JSON_OVERLAPS() antlr.TerminalNode
|
|
JSON_SEARCH() antlr.TerminalNode
|
|
JSON_VALUE() antlr.TerminalNode
|
|
JSON_ARRAY_APPEND() antlr.TerminalNode
|
|
JSON_ARRAY_INSERT() antlr.TerminalNode
|
|
JSON_INSERT() antlr.TerminalNode
|
|
JSON_MERGE() antlr.TerminalNode
|
|
JSON_MERGE_PATCH() antlr.TerminalNode
|
|
JSON_MERGE_PRESERVE() antlr.TerminalNode
|
|
JSON_REMOVE() antlr.TerminalNode
|
|
JSON_REPLACE() antlr.TerminalNode
|
|
JSON_SET() antlr.TerminalNode
|
|
JSON_UNQUOTE() antlr.TerminalNode
|
|
JSON_DEPTH() antlr.TerminalNode
|
|
JSON_LENGTH() antlr.TerminalNode
|
|
JSON_TYPE() antlr.TerminalNode
|
|
JSON_VALID() antlr.TerminalNode
|
|
JSON_TABLE() antlr.TerminalNode
|
|
JSON_SCHEMA_VALID() antlr.TerminalNode
|
|
JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode
|
|
JSON_PRETTY() antlr.TerminalNode
|
|
JSON_STORAGE_FREE() antlr.TerminalNode
|
|
JSON_STORAGE_SIZE() antlr.TerminalNode
|
|
JSON_ARRAYAGG() antlr.TerminalNode
|
|
JSON_OBJECTAGG() antlr.TerminalNode
|
|
STATEMENT() antlr.TerminalNode
|
|
|
|
// IsFunctionNameBaseContext differentiates from other interfaces.
|
|
IsFunctionNameBaseContext()
|
|
}
|
|
|
|
type FunctionNameBaseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFunctionNameBaseContext() *FunctionNameBaseContext {
|
|
var p = new(FunctionNameBaseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionNameBase
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFunctionNameBaseContext(p *FunctionNameBaseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = MySqlParserRULE_functionNameBase
|
|
}
|
|
|
|
func (*FunctionNameBaseContext) IsFunctionNameBaseContext() {}
|
|
|
|
func NewFunctionNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameBaseContext {
|
|
var p = new(FunctionNameBaseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = MySqlParserRULE_functionNameBase
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FunctionNameBaseContext) ABS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserABS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ACOS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserACOS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ADDDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADDDATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ADDTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserADDTIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) AES_DECRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAES_DECRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) AES_ENCRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAES_ENCRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) AREA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserAREA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASBINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASBINARY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASWKT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASWKT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASYMMETRIC_DECRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASYMMETRIC_DECRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASYMMETRIC_DERIVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASYMMETRIC_DERIVE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASYMMETRIC_ENCRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASYMMETRIC_ENCRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASYMMETRIC_SIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASYMMETRIC_SIGN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ASYMMETRIC_VERIFY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserASYMMETRIC_VERIFY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ATAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserATAN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ATAN2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserATAN2, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) BENCHMARK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBENCHMARK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) BIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) BIT_COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_COUNT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) BIT_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBIT_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) BUFFER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserBUFFER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CEIL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCEIL, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CEILING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCEILING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CENTROID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCENTROID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CHARACTER_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARACTER_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CHARSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHARSET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CHAR_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCHAR_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COERCIBILITY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOERCIBILITY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COLLATION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOLLATION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COMPRESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOMPRESS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CONCAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONCAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CONCAT_WS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONCAT_WS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CONNECTION_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONNECTION_ID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CONV() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONV, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CONVERT_TZ() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCONVERT_TZ, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCOUNT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CRC32() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCRC32, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE_ASYMMETRIC_PUB_KEY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CREATE_DH_PARAMETERS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE_DH_PARAMETERS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CREATE_DIGEST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCREATE_DIGEST, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CROSSES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCROSSES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) CUME_DIST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserCUME_DIST, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DATABASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATABASE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DATEDIFF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATEDIFF, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DATE_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDATE_FORMAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DAYNAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAYNAME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DAYOFMONTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAYOFMONTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DAYOFWEEK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAYOFWEEK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DAYOFYEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDAYOFYEAR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DECODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDECODE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DEGREES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDEGREES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DENSE_RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDENSE_RANK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DES_DECRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDES_DECRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DES_ENCRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDES_ENCRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DIMENSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDIMENSION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) DISJOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserDISJOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ELT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserELT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ENCODE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCODE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ENCRYPT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENCRYPT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ENDPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENDPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ENVELOPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserENVELOPE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EQUALS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEQUALS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EXP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXP, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EXPORT_SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXPORT_SET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EXTERIORRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTERIORRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EXTRACTVALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserEXTRACTVALUE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FIELD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIELD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FIND_IN_SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIND_IN_SET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FIRST_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFIRST_VALUE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FLOOR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFLOOR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFORMAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FOUND_ROWS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFOUND_ROWS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FROM_BASE64() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM_BASE64, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FROM_DAYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM_DAYS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) FROM_UNIXTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserFROM_UNIXTIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMCOLLFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMCOLLFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMCOLLFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMCOLLFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYCOLLECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYCOLLECTION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYCOLLECTIONFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYCOLLECTIONFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMETRYTYPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMETRYTYPE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GEOMFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGEOMFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GET_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGET_FORMAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GET_LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGET_LOCK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GLENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGLENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GREATEST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGREATEST, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GTID_SUBSET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGTID_SUBSET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GTID_SUBTRACT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserGTID_SUBTRACT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) HEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHEX, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) HOUR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserHOUR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IFNULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIFNULL, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INET6_ATON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINET6_ATON, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INET6_NTOA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINET6_NTOA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INET_ATON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINET_ATON, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INET_NTOA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINET_NTOA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INSTR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINSTR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INTERIORRINGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERIORRINGN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INTERSECTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINTERSECTS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) INVISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserINVISIBLE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ISCLOSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISCLOSED, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ISEMPTY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISEMPTY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ISNULL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISNULL, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ISSIMPLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserISSIMPLE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_FREE_LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_FREE_LOCK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_IPV4() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_IPV4, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_IPV4_COMPAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_IPV4_COMPAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_IPV4_MAPPED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_IPV4_MAPPED, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_IPV6() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_IPV6, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) IS_USED_LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserIS_USED_LOCK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LAG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAG, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LAST_INSERT_ID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST_INSERT_ID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LAST_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLAST_VALUE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LCASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLCASE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LEAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LEAST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEAST, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LEFT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLEFT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LINEFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LINEFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINEFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LINESTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINESTRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LINESTRINGFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINESTRINGFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LINESTRINGFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLINESTRINGFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOAD_FILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOAD_FILE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOCATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOCATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOG, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOG10() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOG10, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOG2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOG2, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LOWER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLOWER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LPAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLPAD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) LTRIM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserLTRIM, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MAKEDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAKEDATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MAKETIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAKETIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MAKE_SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMAKE_SET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MASTER_POS_WAIT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMASTER_POS_WAIT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBRCONTAINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBRCONTAINS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBRDISJOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBRDISJOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBREQUAL() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBREQUAL, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBRINTERSECTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBRINTERSECTS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBROVERLAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBROVERLAPS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBRTOUCHES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBRTOUCHES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MBRWITHIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMBRWITHIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MD5() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMD5, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MICROSECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMICROSECOND, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MINUTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMINUTE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MLINEFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMLINEFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MLINEFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMLINEFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MOD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMOD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MONTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMONTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MONTHNAME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMONTHNAME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MPOINTFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMPOINTFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MPOINTFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMPOINTFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MPOLYFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMPOLYFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MPOLYFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMPOLYFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTILINESTRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTILINESTRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTILINESTRINGFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTILINESTRINGFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTILINESTRINGFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTILINESTRINGFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOINTFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOINTFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOINTFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOINTFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOLYGON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOLYGON, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOLYGONFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOLYGONFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) MULTIPOLYGONFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserMULTIPOLYGONFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NAME_CONST() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNAME_CONST, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NTH_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNTH_VALUE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NTILE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNTILE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NULLIF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNULLIF, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NUMGEOMETRIES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMGEOMETRIES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NUMINTERIORRINGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMINTERIORRINGS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) NUMPOINTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserNUMPOINTS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) OCT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOCT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) OCTET_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOCTET_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ORD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserORD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) OVERLAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserOVERLAPS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) PERCENT_RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERCENT_RANK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) PERIOD_ADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERIOD_ADD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) PERIOD_DIFF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPERIOD_DIFF, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) PI() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPI, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POINTFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOINTFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POINTFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOINTFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POINTN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOINTN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POLYFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POLYFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POLYGON() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYGON, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POLYGONFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYGONFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POLYGONFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOLYGONFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POSITION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOSITION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POW() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOW, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) POWER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserPOWER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) QUARTER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUARTER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) QUOTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserQUOTE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RADIANS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRADIANS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RAND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRAND, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RANDOM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANDOM, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RANK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RANDOM_BYTES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRANDOM_BYTES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RELEASE_LOCK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRELEASE_LOCK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) REVERSE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserREVERSE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RIGHT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRIGHT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ROUND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROUND, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ROW_COUNT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_COUNT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ROW_NUMBER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserROW_NUMBER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RPAD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRPAD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) RTRIM() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserRTRIM, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SCHEMA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSCHEMA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SECOND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSECOND, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SEC_TO_TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSEC_TO_TIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SESSION_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION_USER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SHA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SHA1() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHA1, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SHA2() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSHA2, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SIGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIGN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SLEEP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSLEEP, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SOUNDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSOUNDEX, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SQRT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSQRT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SRID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSRID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) STARTPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTARTPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) STRCMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTRCMP, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) STR_TO_DATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTR_TO_DATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_AREA() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_AREA, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ASBINARY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ASBINARY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ASTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ASTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ASWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ASWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ASWKT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ASWKT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_BUFFER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_BUFFER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_CENTROID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_CENTROID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_CONTAINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_CONTAINS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_CROSSES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_CROSSES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_DIFFERENCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_DIFFERENCE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_DIMENSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_DIMENSION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_DISJOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_DISJOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_DISTANCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_DISTANCE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ENDPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ENDPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ENVELOPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ENVELOPE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_EQUALS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_EQUALS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_EXTERIORRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_EXTERIORRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMCOLLFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMCOLLFROMTXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMCOLLFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMETRYTYPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMETRYTYPE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_GEOMFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_GEOMFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_INTERIORRINGN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_INTERIORRINGN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_INTERSECTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_INTERSECTION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_INTERSECTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_INTERSECTS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ISCLOSED() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ISCLOSED, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ISEMPTY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ISEMPTY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_ISSIMPLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_ISSIMPLE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_LINEFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_LINEFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_LINEFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_LINEFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_LINESTRINGFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_LINESTRINGFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_LINESTRINGFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_LINESTRINGFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_NUMGEOMETRIES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_NUMGEOMETRIES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_NUMINTERIORRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_NUMINTERIORRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_NUMINTERIORRINGS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_NUMINTERIORRINGS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_NUMPOINTS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_NUMPOINTS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_OVERLAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_OVERLAPS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POINTFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POINTFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POINTFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POINTFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POINTN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POINTN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POLYFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POLYFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POLYFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POLYFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POLYGONFROMTEXT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POLYGONFROMTEXT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_POLYGONFROMWKB() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_POLYGONFROMWKB, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_SRID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_SRID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_STARTPOINT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_STARTPOINT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_SYMDIFFERENCE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_SYMDIFFERENCE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_TOUCHES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_TOUCHES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_UNION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_UNION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_WITHIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_WITHIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_X() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_X, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ST_Y() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserST_Y, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SUBDATE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBDATE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SUBSTRING_INDEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBSTRING_INDEX, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SUBTIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSUBTIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) SYSTEM_USER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSYSTEM_USER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TAN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTAN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIME() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIMEDIFF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMEDIFF, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIMESTAMPADD() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMESTAMPADD, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIMESTAMPDIFF() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIMESTAMPDIFF, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIME_FORMAT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME_FORMAT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TIME_TO_SEC() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTIME_TO_SEC, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TOUCHES() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTOUCHES, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TO_BASE64() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO_BASE64, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TO_DAYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO_DAYS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) TO_SECONDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserTO_SECONDS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UCASE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUCASE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UNCOMPRESS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNCOMPRESS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UNCOMPRESSED_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNCOMPRESSED_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UNHEX() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNHEX, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UNIX_TIMESTAMP() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUNIX_TIMESTAMP, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UPDATEXML() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPDATEXML, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UPPER() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUPPER, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UUID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUUID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) UUID_SHORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserUUID_SHORT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVALIDATE_PASSWORD_STRENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) VERSION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVERSION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) VISIBLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserVISIBLE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WEEK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEEK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WEEKDAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEEKDAY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WEEKOFYEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEEKOFYEAR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WEIGHT_STRING() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWEIGHT_STRING, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) WITHIN() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserWITHIN, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) YEAR() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEAR, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) YEARWEEK() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserYEARWEEK, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) Y_FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserY_FUNCTION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) X_FUNCTION() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserX_FUNCTION, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_ARRAY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_ARRAY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_OBJECT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_OBJECT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_QUOTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_QUOTE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_CONTAINS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_CONTAINS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_CONTAINS_PATH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_CONTAINS_PATH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_EXTRACT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_EXTRACT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_KEYS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_KEYS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_OVERLAPS() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_OVERLAPS, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_SEARCH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_SEARCH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_VALUE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_VALUE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_ARRAY_APPEND() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_ARRAY_APPEND, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_ARRAY_INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_ARRAY_INSERT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_INSERT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_INSERT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_MERGE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_MERGE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_MERGE_PATCH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_MERGE_PATCH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_MERGE_PRESERVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_MERGE_PRESERVE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_REMOVE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_REMOVE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_REPLACE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_REPLACE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_SET() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_SET, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_UNQUOTE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_UNQUOTE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_DEPTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_DEPTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_LENGTH() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_LENGTH, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_TYPE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_TYPE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_VALID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_VALID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_TABLE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_TABLE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_SCHEMA_VALID() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_SCHEMA_VALID, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_SCHEMA_VALIDATION_REPORT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_PRETTY() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_PRETTY, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_STORAGE_FREE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_STORAGE_FREE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_STORAGE_SIZE() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_STORAGE_SIZE, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_ARRAYAGG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_ARRAYAGG, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) JSON_OBJECTAGG() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserJSON_OBJECTAGG, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) STATEMENT() antlr.TerminalNode {
|
|
return s.GetToken(MySqlParserSTATEMENT, 0)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) EnterRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.EnterFunctionNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) ExitRule(listener antlr.ParseTreeListener) {
|
|
if listenerT, ok := listener.(MySqlParserListener); ok {
|
|
listenerT.ExitFunctionNameBase(s)
|
|
}
|
|
}
|
|
|
|
func (s *FunctionNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case MySqlParserVisitor:
|
|
return t.VisitFunctionNameBase(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) FunctionNameBase() (localctx IFunctionNameBaseContext) {
|
|
localctx = NewFunctionNameBaseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 720, MySqlParserRULE_functionNameBase)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(7447)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == MySqlParserDATABASE || _la == MySqlParserLEFT || ((int64((_la-148)) & ^0x3f) == 0 && ((int64(1)<<(_la-148))&4194309) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-17179869161) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&8796109397507) != 0) || _la == MySqlParserINVISIBLE || ((int64((_la-673)) & ^0x3f) == 0 && ((int64(1)<<(_la-673))&-9223372036838064127) != 0) || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&-8589934599) != 0) || ((int64((_la-867)) & ^0x3f) == 0 && ((int64(1)<<(_la-867))&-257) != 0) || ((int64((_la-931)) & ^0x3f) == 0 && ((int64(1)<<(_la-931))&-1) != 0) || ((int64((_la-995)) & ^0x3f) == 0 && ((int64(1)<<(_la-995))&-1057) != 0) || ((int64((_la-1059)) & ^0x3f) == 0 && ((int64(1)<<(_la-1059))&562949416550399) != 0) || _la == MySqlParserMOD) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
func (p *MySqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
|
|
switch ruleIndex {
|
|
case 344:
|
|
var t *ExpressionContext = nil
|
|
if localctx != nil {
|
|
t = localctx.(*ExpressionContext)
|
|
}
|
|
return p.Expression_Sempred(t, predIndex)
|
|
|
|
case 345:
|
|
var t *PredicateContext = nil
|
|
if localctx != nil {
|
|
t = localctx.(*PredicateContext)
|
|
}
|
|
return p.Predicate_Sempred(t, predIndex)
|
|
|
|
case 346:
|
|
var t *ExpressionAtomContext = nil
|
|
if localctx != nil {
|
|
t = localctx.(*ExpressionAtomContext)
|
|
}
|
|
return p.ExpressionAtom_Sempred(t, predIndex)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(ruleIndex))
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
|
|
switch predIndex {
|
|
case 0:
|
|
return p.Precpred(p.GetParserRuleContext(), 3)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(predIndex))
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) Predicate_Sempred(localctx antlr.RuleContext, predIndex int) bool {
|
|
switch predIndex {
|
|
case 1:
|
|
return p.Precpred(p.GetParserRuleContext(), 8)
|
|
|
|
case 2:
|
|
return p.Precpred(p.GetParserRuleContext(), 6)
|
|
|
|
case 3:
|
|
return p.Precpred(p.GetParserRuleContext(), 5)
|
|
|
|
case 4:
|
|
return p.Precpred(p.GetParserRuleContext(), 3)
|
|
|
|
case 5:
|
|
return p.Precpred(p.GetParserRuleContext(), 10)
|
|
|
|
case 6:
|
|
return p.Precpred(p.GetParserRuleContext(), 9)
|
|
|
|
case 7:
|
|
return p.Precpred(p.GetParserRuleContext(), 7)
|
|
|
|
case 8:
|
|
return p.Precpred(p.GetParserRuleContext(), 4)
|
|
|
|
case 9:
|
|
return p.Precpred(p.GetParserRuleContext(), 2)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(predIndex))
|
|
}
|
|
}
|
|
|
|
func (p *MySqlParser) ExpressionAtom_Sempred(localctx antlr.RuleContext, predIndex int) bool {
|
|
switch predIndex {
|
|
case 10:
|
|
return p.Precpred(p.GetParserRuleContext(), 4)
|
|
|
|
case 11:
|
|
return p.Precpred(p.GetParserRuleContext(), 3)
|
|
|
|
case 12:
|
|
return p.Precpred(p.GetParserRuleContext(), 2)
|
|
|
|
case 13:
|
|
return p.Precpred(p.GetParserRuleContext(), 1)
|
|
|
|
case 14:
|
|
return p.Precpred(p.GetParserRuleContext(), 14)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(predIndex))
|
|
}
|
|
}
|