review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2  *  Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; version 2 of the License.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public License
  14  *  along with this program; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  16  */
  17
  18 lexer grammar MySQL51Lexer;
  19
  20 options {
  21         superClass=MySQLLexer;
  22 }
  23
  24 @header{
  25 package com.mysql.clusterj.jdbc.antlr;
  26 }
  27
  28 // $<Keywords
  29
  30 /* These are actual reserved words that cannot be used as an identifier without quotes.
  31    eventually we need to gate all these with a predicate (see nextTokenIsID) to allow the "word following a '.' character is always an identifier" rule
  32  */
  33 ACCESSIBLE      :       'ACCESSIBLE';
  34 ADD     :       'ADD';
  35 ALL     :       'ALL';
  36 ALTER   :       'ALTER';
  37 ANALYZE :       'ANALYZE';
  38 AND     :       'AND';
  39 AS      :       'AS';
  40 ASC     :       'ASC';
  41 ASENSITIVE      :       'ASENSITIVE';
  42 BEFORE  :       'BEFORE';
  43 BETWEEN :       'BETWEEN';
  44 // BIGINT       :       'BIGINT';               // datatype defined below
  45 BINARY  :       'BINARY';
  46 //BLOB  :       'BLOB';         // datatype defined below
  47 BOTH    :       'BOTH';
  48 BY      :       'BY';
  49 CALL    :       'CALL';
  50 CASCADE :       'CASCADE';
  51 CASE    :       'CASE';
  52 CHANGE  :       'CHANGE';
  53 //CHAR  :       'CHAR';         // datatype defined below
  54 CHARACTER       :       'CHARACTER';
  55 CHECK   :       'CHECK';
  56 COLLATE :       'COLLATE';
  57 COLUMN  :       'COLUMN';
  58 CONDITION       :       'CONDITION';
  59 CONSTRAINT      :       'CONSTRAINT';
  60 CONTINUE        :       'CONTINUE';
  61 CONVERT :       'CONVERT';
  62 CREATE  :       'CREATE';
  63 CROSS   :       'CROSS';
  64 CURRENT_DATE    :       'CURRENT_DATE';
  65 CURRENT_TIME    :       'CURRENT_TIME';
  66 CURRENT_TIMESTAMP       :       'CURRENT_TIMESTAMP';
  67 //CURRENT_USER  :       'CURRENT_USER'; //reserved, function below
  68 CURSOR  :       'CURSOR';
  69 DATABASE        :       'DATABASE';
  70 DATABASES       :       'DATABASES';
  71 DAY_HOUR        :       'DAY_HOUR';
  72 DAY_MICROSECOND :       'DAY_MICROSECOND';
  73 DAY_MINUTE      :       'DAY_MINUTE';
  74 DAY_SECOND      :       'DAY_SECOND';
  75 DEC     :       'DEC';
  76 //DECIMAL       :       'DECIMAL';              // datatype defined below
  77 DECLARE :       'DECLARE';
  78 DEFAULT :       'DEFAULT';
  79 DELAYED :       'DELAYED';
  80 DELETE  :       'DELETE';
  81 DESC    :       'DESC';
  82 DESCRIBE        :       'DESCRIBE';
  83 DETERMINISTIC   :       'DETERMINISTIC';
  84 DISTINCT        :       'DISTINCT';
  85 DISTINCTROW     :       'DISTINCTROW';
  86 DIV     :       'DIV';
  87 //DOUBLE        :       'DOUBLE';               // datatype defined below
  88 DROP    :       'DROP';
  89 DUAL    :       'DUAL';
  90 EACH    :       'EACH';
  91 ELSE    :       'ELSE';
  92 ELSEIF  :       'ELSEIF';
  93 ENCLOSED        :       'ENCLOSED';
  94 ESCAPED :       'ESCAPED';
  95 EXISTS  :       'EXISTS';
  96 EXIT    :       'EXIT';
  97 EXPLAIN :       'EXPLAIN';
  98 FALSE   :       'FALSE';
  99 FETCH   :       'FETCH';
 100 //FLOAT :       'FLOAT';                // datatype defined below
 101 FLOAT4  :       'FLOAT4';
 102 FLOAT8  :       'FLOAT8';
 103 FOR     :       'FOR';
 104 FORCE   :       'FORCE';
 105 FOREIGN :       'FOREIGN';
 106 FROM    :       'FROM';
 107 FULLTEXT        :       'FULLTEXT';
 108 GOTO    :       'GOTO';
 109 GRANT   :       'GRANT';
 110 GROUP   :       'GROUP';
 111 HAVING  :       'HAVING';
 112 HIGH_PRIORITY   :       'HIGH_PRIORITY';
 113 HOUR_MICROSECOND        :       'HOUR_MICROSECOND';
 114 HOUR_MINUTE     :       'HOUR_MINUTE';
 115 HOUR_SECOND     :       'HOUR_SECOND';
 116 IF      :       'IF';
 117 IGNORE  :       'IGNORE';
 118 IN      :       'IN';
 119 INDEX   :       'INDEX';
 120 INDEX_SYM  :    'INDEX_SYM';
 121 INFILE  :       'INFILE';
 122 INNER   :       'INNER';
 123 INNODB  : 'INNODB';
 124 INOUT   :       'INOUT';
 125 INSENSITIVE     :       'INSENSITIVE';
 126 //INSERT        :       'INSERT';       // reserved keyword and function below
 127 //INT   :       'INT';          // datatype defined below
 128 INT1    :       'INT1';
 129 INT2    :       'INT2';
 130 INT3    :       'INT3';
 131 INT4    :       'INT4';
 132 INT8    :       'INT8';
 133 //INTEGER       :       'INTEGER';              // datatype defined below
 134 //INTERVAL      :       'INTERVAL';             // reserved keyword and function below
 135 INTO    :       'INTO';
 136 IS      :       'IS';
 137 ITERATE :       'ITERATE';
 138 JOIN    :       'JOIN';
 139 KEY     :       'KEY';
 140 KEYS    :       'KEYS';
 141 KILL    :       'KILL';
 142 LABEL   :       'LABEL';
 143 LEADING :       'LEADING';
 144 LEAVE   :       'LEAVE';
 145 //LEFT  :       'LEFT'; // reserved keyword and function below
 146 LIKE    :       'LIKE';
 147 LIMIT   :       'LIMIT';
 148 LINEAR  :       'LINEAR';
 149 LINES   :       'LINES';
 150 LOAD    :       'LOAD';
 151 LOCALTIME       :       'LOCALTIME';
 152 LOCALTIMESTAMP  :       'LOCALTIMESTAMP';
 153 LOCK    :       'LOCK';
 154 LONG    :       'LONG';
 155 //LONGBLOB      :       'LONGBLOB';             // datatype defined below
 156 //LONGTEXT      :       'LONGTEXT';             // datatype defined below
 157 LOOP    :       'LOOP';
 158 LOW_PRIORITY    :       'LOW_PRIORITY';
 159 MASTER_SSL_VERIFY_SERVER_CERT   :       'MASTER_SSL_VERIFY_SERVER_CERT';
 160 MATCH   :       'MATCH';
 161 //MEDIUMBLOB    :       'MEDIUMBLOB';           // datatype defined below
 162 //MEDIUMINT     :       'MEDIUMINT';            // datatype defined below
 163 //MEDIUMTEXT    :       'MEDIUMTEXT';           // datatype defined below
 164 MIDDLEINT       :       'MIDDLEINT';            // datatype defined below
 165 MINUTE_MICROSECOND      :       'MINUTE_MICROSECOND';
 166 MINUTE_SECOND   :       'MINUTE_SECOND';
 167 MOD     :       'MOD';
 168 MODIFIES        :       'MODIFIES';
 169 NATURAL :       'NATURAL';
 170 NOT     :       'NOT';
 171 NO_WRITE_TO_BINLOG      :       'NO_WRITE_TO_BINLOG';
 172 NULL    :       'NULL';
 173 //NUMERIC       :       'NUMERIC';              // datatype defined below
 174 ON      :       'ON';
 175 OPTIMIZE        :       'OPTIMIZE';
 176 OPTION  :       'OPTION';
 177 OPTIONALLY      :       'OPTIONALLY';
 178 OR      :       'OR';
 179 ORDER   :       'ORDER';
 180 OUT     :       'OUT';
 181 OUTER   :       'OUTER';
 182 OUTFILE :       'OUTFILE';
 183 PRECISION       :       'PRECISION';
 184 PRIMARY :       'PRIMARY';
 185 PROCEDURE       :       'PROCEDURE';
 186 PURGE   :       'PURGE';
 187 RANGE   :       'RANGE';
 188 READ    :       'READ';
 189 READS   :       'READS';
 190 READ_ONLY       :       'READ_ONLY';
 191 READ_WRITE      :       'READ_WRITE';
 192 //REAL  :       'REAL';         // datatype defined below
 193 REFERENCES      :       'REFERENCES';
 194 REGEXP  :       'REGEXP';
 195 RELEASE :       'RELEASE';
 196 RENAME  :       'RENAME';
 197 REPEAT  :       'REPEAT';
 198 REPLACE :       'REPLACE';
 199 REQUIRE :       'REQUIRE';
 200 RESTRICT        :       'RESTRICT';
 201 RETURN  :       'RETURN';
 202 REVOKE  :       'REVOKE';
 203 //RIGHT :       'RIGHT';        // reserved keyword and function below
 204 RLIKE   :       'RLIKE';
 205 SCHEDULER : 'SCHEDULER';
 206 SCHEMA  :       'SCHEMA';
 207 SCHEMAS :       'SCHEMAS';
 208 SECOND_MICROSECOND      :       'SECOND_MICROSECOND';
 209 SELECT  :       'SELECT';
 210 SENSITIVE       :       'SENSITIVE';
 211 SEPARATOR       :       'SEPARATOR';
 212 SET     :       'SET';
 213 SHOW    :       'SHOW';
 214 //SMALLINT      :       'SMALLINT';             // datatype defined below
 215 SPATIAL :       'SPATIAL';
 216 SPECIFIC        :       'SPECIFIC';
 217 SQL     :       'SQL';
 218 SQLEXCEPTION    :       'SQLEXCEPTION';
 219 SQLSTATE        :       'SQLSTATE';
 220 SQLWARNING      :       'SQLWARNING';
 221 SQL_BIG_RESULT  :       'SQL_BIG_RESULT';
 222 SQL_CALC_FOUND_ROWS     :       'SQL_CALC_FOUND_ROWS';
 223 SQL_SMALL_RESULT        :       'SQL_SMALL_RESULT';
 224 SSL     :       'SSL';
 225 STARTING        :       'STARTING';
 226 STRAIGHT_JOIN   :       'STRAIGHT_JOIN';
 227 TABLE   :       'TABLE';
 228 TERMINATED      :       'TERMINATED';
 229 THEN    :       'THEN';
 230 //TINYBLOB      :       'TINYBLOB';             // datatype defined below
 231 //TINYINT       :       'TINYINT';              // datatype defined below
 232 //TINYTEXT      :       'TINYTEXT';             // datatype defined below
 233 TO      :       'TO';
 234 TRAILING        :       'TRAILING';
 235 TRIGGER :       'TRIGGER';
 236 TRUE    :       'TRUE';
 237 UNDO    :       'UNDO';
 238 UNION   :       'UNION';
 239 UNIQUE  :       'UNIQUE';
 240 UNLOCK  :       'UNLOCK';
 241 UNSIGNED        :       'UNSIGNED';
 242 UPDATE  :       'UPDATE';
 243 USAGE   :       'USAGE';
 244 USE     :       'USE';
 245 USING   :       'USING';
 246 //UTC_DATE      :       'UTC_DATE';             // next three are functions defined below
 247 //UTC_TIME      :       'UTC_TIME';
 248 //UTC_TIMESTAMP :       'UTC_TIMESTAMP';
 249 VALUES  :       'VALUES';
 250 //VARBINARY     :       'VARBINARY';            // datatype defined below
 251 //VARCHAR       :       'VARCHAR';              // datatype defined below
 252 VARCHARACTER    :       'VARCHARACTER';
 253 VARYING :       'VARYING';
 254 WHEN    :       'WHEN';
 255 WHERE   :       'WHERE';
 256 WHILE   :       'WHILE';
 257 WITH    :       'WITH';
 258 WRITE   :       'WRITE';
 259 XOR     :       'XOR';
 260 YEAR_MONTH      :       'YEAR_MONTH';
 261 ZEROFILL        :       'ZEROFILL';
 262
 263 // $> Keywords
 264
 265
 266 // $< Keywords allowed as identifiers
 267 /* the following two lists are taken from the official YACC grammar
 268  * is contains all keywords that are allowed to be used as identifiers
 269  * without quoting them.
 270  */
 271 /* Keyword that we allow for identifiers (except SP labels) */
 272
 273 // $< Keywords not in SP labels
 274
 275 ASCII   :       'ASCII';
 276 BACKUP  :       'BACKUP';
 277 BEGIN   :       'BEGIN';
 278 BYTE    :       'BYTE';
 279 CACHE   :       'CACHE';
 280 CHARSET :       'CHARSET';
 281 CHECKSUM        :       'CHECKSUM';
 282 CLOSE   :       'CLOSE';
 283 COMMENT :       'COMMENT';
 284 COMMIT  :       'COMMIT';
 285 CONTAINS        :       'CONTAINS';
 286 DEALLOCATE      :       'DEALLOCATE';
 287 DO      :       'DO';
 288 END     :       'END';
 289 EXECUTE :       'EXECUTE';
 290 FLUSH   :       'FLUSH';
 291 HANDLER :       'HANDLER';
 292 HELP    :       'HELP';
 293 HOST    :       'HOST';
 294 INSTALL :       'INSTALL';
 295 LANGUAGE        :       'LANGUAGE';
 296 NO      :       'NO';
 297 OPEN    :       'OPEN';
 298 OPTIONS :       'OPTIONS';
 299 OWNER   :       'OWNER';
 300 PARSER  :       'PARSER';
 301 PARTITION       :       'PARTITION';
 302 PORT    :       'PORT';
 303 PREPARE :       'PREPARE';
 304 REMOVE  :       'REMOVE';
 305 REPAIR  :       'REPAIR';
 306 RESET   :       'RESET';
 307 RESTORE :       'RESTORE';
 308 ROLLBACK        :       'ROLLBACK';
 309 SAVEPOINT       :       'SAVEPOINT';
 310 SECURITY        :       'SECURITY';
 311 SERVER  :       'SERVER';
 312 SIGNED  :       'SIGNED';
 313 SOCKET  :       'SOCKET';
 314 SLAVE   :       'SLAVE';
 315 SONAME  :       'SONAME';
 316 START   :       'START';
 317 STOP    :       'STOP';
 318 TRUNCATE        :       'TRUNCATE';
 319 UNICODE :       'UNICODE';
 320 UNINSTALL       :       'UNINSTALL';
 321 WRAPPER :       'WRAPPER';
 322 XA      :       'XA';
 323 UPGRADE :       'UPGRADE';
 324
 325 // $> Keywords not in SP labels
 326
 327 // $< Keywords in SP labels
 328 /* Keywords that we allow for labels in SPs. */
 329 ACTION  :       'ACTION';
 330 //ADDDATE       :       'ADDDATE';              // function defined below
 331 AFTER   :       'AFTER';
 332 AGAINST :       'AGAINST';
 333 AGGREGATE       :       'AGGREGATE';
 334 ALGORITHM       :       'ALGORITHM';
 335 ANY     :       'ANY';
 336 AT      :       'AT';
 337 AUTHORS :       'AUTHORS';
 338 AUTO_INCREMENT  :       'AUTO_INCREMENT';
 339 AUTOEXTEND_SIZE :       'AUTOEXTEND_SIZE';
 340 AVG : 'AVG';
 341 AVG_ROW_LENGTH  :       'AVG_ROW_LENGTH';
 342 BINLOG  :       'BINLOG';
 343 // BIT  :       'BIT';                  // datatype defined below
 344 BLOCK   :       'BLOCK';
 345 BOOL    :       'BOOL';
 346 BOOLEAN :       'BOOLEAN';
 347 BTREE   :       'BTREE';
 348 CASCADED        :       'CASCADED';
 349 CHAIN   :       'CHAIN';
 350 CHANGED :       'CHANGED';
 351 CIPHER  :       'CIPHER';
 352 CLIENT  :       'CLIENT';
 353 COALESCE        :       'COALESCE';
 354 CODE    :       'CODE';
 355 COLLATION       :       'COLLATION';
 356 COLUMNS :       'COLUMNS';
 357 // FIELDS is a synonym for COLUMNS
 358 FIELDS  :       'FIELDS';
 359 COMMITTED       :       'COMMITTED';
 360 COMPACT :       'COMPACT';
 361 COMPLETION      :       'COMPLETION';
 362 COMPRESSED      :       'COMPRESSED';
 363 CONCURRENT      :       'CONCURRENT';
 364 CONNECTION      :       'CONNECTION';
 365 CONSISTENT      :       'CONSISTENT';
 366 CONTEXT :       'CONTEXT';
 367 CONTRIBUTORS    :       'CONTRIBUTORS';
 368 CPU     :       'CPU';
 369 CUBE    :       'CUBE';
 370 DATA    :       'DATA';
 371 DATAFILE        :       'DATAFILE';
 372 // DATETIME     :       'DATETIME';                 // datatype defined below
 373 // DATE :       'DATE';                                 // datatype defined below
 374 //DAY   :       'DAY';                  // reserved, is also function below
 375 DEFINER :       'DEFINER';
 376 DELAY_KEY_WRITE :       'DELAY_KEY_WRITE';
 377 DES_KEY_FILE    :       'DES_KEY_FILE';
 378 DIRECTORY       :       'DIRECTORY';
 379 DISABLE :       'DISABLE';
 380 DISCARD :       'DISCARD';
 381 DISK    :       'DISK';
 382 DUMPFILE        :       'DUMPFILE';
 383 DUPLICATE       :       'DUPLICATE';
 384 DYNAMIC :       'DYNAMIC';
 385 ENDS    :       'ENDS';
 386 //ENUM  :       'ENUM';                         // datatype defined below
 387 ENGINE  :       'ENGINE';
 388 ENGINES :       'ENGINES';
 389 ERRORS  :       'ERRORS';
 390 ESCAPE  :       'ESCAPE';
 391 EVENT   :       'EVENT';
 392 EVENTS  :       'EVENTS';
 393 EVERY   :       'EVERY';
 394 EXPANSION       :       'EXPANSION';
 395 EXTENDED        :       'EXTENDED';
 396 EXTENT_SIZE     :       'EXTENT_SIZE';
 397 FAULTS  :       'FAULTS';
 398 FAST    :       'FAST';
 399 FOUND   :       'FOUND';
 400 ENABLE  :       'ENABLE';
 401 FULL    :       'FULL';
 402 FILE    :       'FILE';
 403 FIRST   :       'FIRST';
 404 FIXED   :       'FIXED';
 405 FRAC_SECOND     :       'FRAC_SECOND';
 406 GEOMETRY        :       'GEOMETRY';
 407 GEOMETRYCOLLECTION      :       'GEOMETRYCOLLECTION';
 408 //GET_FORMAT    :       'GET_FORMAT';               //function defined below
 409 GRANTS  :       'GRANTS';
 410 GLOBAL  :       'GLOBAL';
 411 HASH    :       'HASH';
 412 HOSTS   :       'HOSTS';
 413 //HOUR  :       'HOUR';                 //reserved, also function below
 414 IDENTIFIED      :       'IDENTIFIED';
 415 INVOKER :       'INVOKER';
 416 IMPORT  :       'IMPORT';
 417 INDEXES :       'INDEXES';
 418 INITIAL_SIZE    :       'INITIAL_SIZE';
 419 IO      :       'IO';
 420 IPC     :       'IPC';
 421 ISOLATION       :       'ISOLATION';
 422 ISSUER  :       'ISSUER';
 423 INNOBASE        :       'INNOBASE';
 424 INSERT_METHOD   :       'INSERT_METHOD';
 425 KEY_BLOCK_SIZE  :       'KEY_BLOCK_SIZE';
 426 LAST    :       'LAST';
 427 LEAVES  :       'LEAVES';
 428 LESS    :       'LESS';
 429 LEVEL   :       'LEVEL';
 430 LINESTRING      :       'LINESTRING';               // geometry function
 431 LIST    :       'LIST';
 432 LOCAL   :       'LOCAL';
 433 LOCKS   :       'LOCKS';
 434 LOGFILE :       'LOGFILE';
 435 LOGS    :       'LOGS';
 436 MAX_ROWS        :       'MAX_ROWS';
 437 MASTER  :       'MASTER';
 438 MASTER_HOST     :       'MASTER_HOST';
 439 MASTER_PORT     :       'MASTER_PORT';
 440 MASTER_LOG_FILE :       'MASTER_LOG_FILE';
 441 MASTER_LOG_POS  :       'MASTER_LOG_POS';
 442 MASTER_USER     :       'MASTER_USER';
 443 MASTER_PASSWORD :       'MASTER_PASSWORD';
 444 MASTER_SERVER_ID        :       'MASTER_SERVER_ID';
 445 MASTER_CONNECT_RETRY    :       'MASTER_CONNECT_RETRY';
 446 MASTER_SSL      :       'MASTER_SSL';
 447 MASTER_SSL_CA   :       'MASTER_SSL_CA';
 448 MASTER_SSL_CAPATH       :       'MASTER_SSL_CAPATH';
 449 MASTER_SSL_CERT :       'MASTER_SSL_CERT';
 450 MASTER_SSL_CIPHER       :       'MASTER_SSL_CIPHER';
 451 MASTER_SSL_KEY  :       'MASTER_SSL_KEY';
 452 MAX_CONNECTIONS_PER_HOUR        :       'MAX_CONNECTIONS_PER_HOUR';
 453 MAX_QUERIES_PER_HOUR    :       'MAX_QUERIES_PER_HOUR';
 454 MAX_SIZE        :       'MAX_SIZE';
 455 MAX_UPDATES_PER_HOUR    :       'MAX_UPDATES_PER_HOUR';
 456 MAX_USER_CONNECTIONS    :       'MAX_USER_CONNECTIONS';
 457 MAX_VALUE       :       'MAX_VALUE';
 458 MEDIUM  :       'MEDIUM';
 459 MEMORY  :       'MEMORY';
 460 MERGE   :       'MERGE';
 461 MICROSECOND     :       'MICROSECOND';
 462 MIGRATE :       'MIGRATE';
 463 //MINUTE        :       'MINUTE';               // also function
 464 MIN_ROWS        :       'MIN_ROWS';
 465 MODIFY  :       'MODIFY';
 466 MODE    :       'MODE';
 467 //MONTH :       'MONTH';                        // also function
 468 MULTILINESTRING :       'MULTILINESTRING';
 469 MULTIPOINT      :       'MULTIPOINT';
 470 MULTIPOLYGON    :       'MULTIPOLYGON';
 471 MUTEX   :       'MUTEX';
 472 NAME    :       'NAME';
 473 NAMES   :       'NAMES';
 474 NATIONAL        :       'NATIONAL';
 475 NCHAR   :       'NCHAR';
 476 NDBCLUSTER      :       'NDBCLUSTER';
 477 NEXT    :       'NEXT';
 478 NEW     :       'NEW';
 479 NO_WAIT :       'NO_WAIT';
 480 NODEGROUP       :       'NODEGROUP';
 481 NONE    :       'NONE';
 482 NVARCHAR        :       'NVARCHAR';
 483 OFFSET  :       'OFFSET';
 484 OLD_PASSWORD    :       'OLD_PASSWORD';
 485 ONE_SHOT        :       'ONE_SHOT';
 486 ONE     :       'ONE';
 487 PACK_KEYS       :       'PACK_KEYS';
 488 PAGE    :       'PAGE';
 489 PARTIAL :       'PARTIAL';
 490 PARTITIONING    :       'PARTITIONING';
 491 PARTITIONS      :       'PARTITIONS';
 492 PASSWORD        :       'PASSWORD';
 493 PHASE   :       'PHASE';
 494 PLUGIN  :       'PLUGIN';
 495 PLUGINS :       'PLUGINS';
 496 POINT   :       'POINT';
 497 POLYGON :       'POLYGON';
 498 PRESERVE        :       'PRESERVE';
 499 PREV    :       'PREV';
 500 PRIVILEGES      :       'PRIVILEGES';
 501 PROCESS :       'PROCESS';
 502 PROCESSLIST     :       'PROCESSLIST';
 503 PROFILE :       'PROFILE';
 504 PROFILES        :       'PROFILES';
 505 QUARTER :       'QUARTER';
 506 QUERY   :       'QUERY';
 507 QUICK   :       'QUICK';
 508 REBUILD :       'REBUILD';
 509 RECOVER :       'RECOVER';
 510 REDO_BUFFER_SIZE        :       'REDO_BUFFER_SIZE';
 511 REDOFILE        :       'REDOFILE';
 512 REDUNDANT       :       'REDUNDANT';
 513 RELAY_LOG_FILE  :       'RELAY_LOG_FILE';
 514 RELAY_LOG_POS   :       'RELAY_LOG_POS';
 515 RELAY_THREAD    :       'RELAY_THREAD';
 516 RELOAD  :       'RELOAD';
 517 REORGANIZE      :       'REORGANIZE';
 518 REPEATABLE      :       'REPEATABLE';
 519 REPLICATION     :       'REPLICATION';
 520 RESOURCES       :       'RESOURCES';
 521 RESUME  :       'RESUME';
 522 RETURNS :       'RETURNS';
 523 ROLLUP  :       'ROLLUP';
 524 ROUTINE :       'ROUTINE';
 525 ROWS    :       'ROWS';
 526 ROW_FORMAT      :       'ROW_FORMAT';
 527 ROW     :       'ROW';
 528 RTREE   :       'RTREE';
 529 SCHEDULE        :       'SCHEDULE';
 530 //SECOND        :       'SECOND';                               // also function
 531 SERIAL  :       'SERIAL';
 532 SERIALIZABLE    :       'SERIALIZABLE';
 533 SESSION :       'SESSION';
 534 SIMPLE  :       'SIMPLE';
 535 SHARE   :       'SHARE';
 536 SHUTDOWN        :       'SHUTDOWN';
 537 SNAPSHOT        :       'SNAPSHOT';
 538 SOME:   'SOME';         // alias for ANY
 539 SOUNDS  :       'SOUNDS';
 540 SOURCE  :       'SOURCE';
 541 SQL_CACHE       :       'SQL_CACHE';
 542 SQL_BUFFER_RESULT       :       'SQL_BUFFER_RESULT';
 543 SQL_NO_CACHE    :       'SQL_NO_CACHE';
 544 SQL_THREAD      :       'SQL_THREAD';
 545 STARTS  :       'STARTS';
 546 STATUS  :       'STATUS';
 547 STORAGE :       'STORAGE';
 548 STRING_KEYWORD  :       'STRING'; //  this is not a string but the keyword STRING used as a return value for UDF
 549 //SUBDATE       :       'SUBDATE';              // function defined below
 550 SUBJECT :       'SUBJECT';
 551 SUBPARTITION    :       'SUBPARTITION';
 552 SUBPARTITIONS   :       'SUBPARTITIONS';
 553 SUPER   :       'SUPER';
 554 SUSPEND :       'SUSPEND';
 555 SWAPS   :       'SWAPS';
 556 SWITCHES        :       'SWITCHES';
 557 TABLES  :       'TABLES';
 558 TABLESPACE      :       'TABLESPACE';
 559 TEMPORARY       :       'TEMPORARY';
 560 TEMPTABLE       :       'TEMPTABLE';
 561 //TEXT  :       'TEXT';                 // datatype defined below
 562 THAN    :       'THAN';
 563 TRANSACTION     :       'TRANSACTION';
 564 TRANSACTIONAL   :       'TRANSACTIONAL';
 565 TRIGGERS        :       'TRIGGERS';
 566 //TIMESTAMP     :       'TIMESTAMP';                // datatype defined below
 567 //TIMESTAMP_ADD :       'TIMESTAMP_ADD';            // function defined below
 568 //TIMESTAMP_DIFF        :       'TIMESTAMP_DIFF';           // function defined below
 569 //TIME  :       'TIME';                 // datatype defined below
 570 TYPES   :       'TYPES';
 571 TYPE    :       ('TYPE' (WS|EOF))=> 'TYPE';
 572 UDF_RETURNS     :       'UDF_RETURNS';
 573 FUNCTION        :       'FUNCTION';
 574 UNCOMMITTED     :       'UNCOMMITTED';
 575 UNDEFINED       :       'UNDEFINED';
 576 UNDO_BUFFER_SIZE        :       'UNDO_BUFFER_SIZE';
 577 UNDOFILE        :       'UNDOFILE';
 578 UNKNOWN :       'UNKNOWN';
 579 UNTIL   :       'UNTIL';
 580 //USER  :       'USER';                                 // also function
 581 USE_FRM :       'USE_FRM';
 582 VARIABLES       :       'VARIABLES';
 583 VIEW    :       'VIEW';
 584 VALUE   :       'VALUE';
 585 WARNINGS        :       'WARNINGS';
 586 WAIT    :       'WAIT';
 587 WEEK    :       'WEEK';                 // also function
 588 WORK    :       'WORK';
 589 X509    :       'X509';
 590 //YEAR  :       'YEAR';                 // datatype defined below
 591
 592 // $> Keywords in SP labels
 593
 594 // $> Keywords allowed as identifiers
 595
 596 // $< Punctuation
 597 COMMA   :       ',';
 598 DOT             :       '.';
 599 SEMI    :       ';';
 600 LPAREN  :       '(';
 601 RPAREN  :       ')';
 602 LCURLY  :       '{';
 603 RCURLY  :       '}';
 604 // $> Punctuation
 605
 606 // $< Builtin SQL Functions
 607
 608 /** functions must be directly followed by '(' to be considered a keyword (and thus a function name)
 609  * TODO: this is the place to support the SQL mode IGNORE_SPACE
 610  */
 611 //ADDDATE       :       'ADDDATE';      // duplicate from the keywords list
 612 BIT_AND :       'BIT_AND' {$type = checkFunctionAsID($type);};
 613 BIT_OR  :       'BIT_OR' {$type = checkFunctionAsID($type);};
 614 BIT_XOR :       'BIT_XOR' {$type = checkFunctionAsID($type);};
 615 CAST    :       'CAST' {$type = checkFunctionAsID($type);};
 616 COUNT   :       'COUNT' {$type = checkFunctionAsID($type);};
 617 //CURDATE       :       'CURDATE';      //below
 618 //CURTIME       :       'CURTIME';      //below
 619 DATE_ADD        :       'DATE_ADD' {$type = checkFunctionAsID($type);};
 620 DATE_SUB        :       'DATE_SUB' {$type = checkFunctionAsID($type);};
 621 //EXTRACT       :       'EXTRACT';      //below
 622 GROUP_CONCAT    :       'GROUP_CONCAT' {$type = checkFunctionAsID($type);};
 623 MAX     :       'MAX' {$type = checkFunctionAsID($type);};
 624 MID     :       'MID' {$type = checkFunctionAsID($type);};
 625 MIN     :       'MIN' {$type = checkFunctionAsID($type);};
 626 //NOW   :       'NOW';  //below
 627 //POSITION      :       'POSITION';     //below
 628 SESSION_USER    :       'SESSION_USER' {$type = checkFunctionAsID($type);};
 629 STD     :       'STD' {$type = checkFunctionAsID($type);};
 630 STDDEV  :       'STDDEV' {$type = checkFunctionAsID($type);};
 631 STDDEV_POP      :       'STDDEV_POP' {$type = checkFunctionAsID($type);};
 632 STDDEV_SAMP     :       'STDDEV_SAMP' {$type = checkFunctionAsID($type);};
 633 //SUBDATE       :       'SUBDATE';                      // duplicate from the keywords list
 634 SUBSTR  :       'SUBSTR' {$type = checkFunctionAsID($type);};
 635 //SUBSTRING     :       'SUBSTRING';    //below
 636 SUM     :       'SUM' {$type = checkFunctionAsID($type);};
 637 // SYSDATE      :       'SYSDATE';      //below
 638 SYSTEM_USER     :       'SYSTEM_USER' {$type = checkFunctionAsID($type);};
 639 //TRIM  :       'TRIM'; //below
 640 VARIANCE        :       'VARIANCE' {$type = checkFunctionAsID($type);};
 641 VAR_POP :       'VAR_POP' {$type = checkFunctionAsID($type);};
 642 VAR_SAMP        :       'VAR_SAMP' {$type = checkFunctionAsID($type);};
 643
 644 /* non-keywords */
 645 ADDDATE :       'ADDDATE' {$type = checkFunctionAsID($type);};
 646 CURDATE :       'CURDATE' {$type = checkFunctionAsID($type);};
 647 CURTIME :       'CURTIME' {$type = checkFunctionAsID($type);};
 648 DATE_ADD_INTERVAL       :       'DATE_ADD_INTERVAL' {$type = checkFunctionAsID($type);};
 649 DATE_SUB_INTERVAL       :       'DATE_SUB_INTERVAL' {$type = checkFunctionAsID($type);};
 650 EXTRACT :       'EXTRACT' {$type = checkFunctionAsID($type);};
 651 GET_FORMAT      :       'GET_FORMAT' {$type = checkFunctionAsID($type);};
 652 NOW     :       'NOW' {$type = checkFunctionAsID($type);};
 653 POSITION        :       'POSITION' {$type = checkFunctionAsID($type);};
 654 SUBDATE :       'SUBDATE' {$type = checkFunctionAsID($type);};
 655 SUBSTRING       :       'SUBSTRING' {$type = checkFunctionAsID($type);};
 656 SYSDATE :       'SYSDATE' {$type = checkFunctionAsID($type);};
 657 TIMESTAMP_ADD   :       'TIMESTAMP_ADD' {$type = checkFunctionAsID($type);};
 658 TIMESTAMP_DIFF  :       'TIMESTAMP_DIFF' {$type = checkFunctionAsID($type);};
 659 UTC_DATE        :       'UTC_DATE' {$type = checkFunctionAsID($type);};
 660 UTC_TIMESTAMP   :       'UTC_TIMESTAMP' {$type = checkFunctionAsID($type);};
 661 UTC_TIME        :       'UTC_TIME' {$type = checkFunctionAsID($type);};
 662
 663 /* conflict with keywords, or geometry functions */
 664 // the following keywords are handled by the ident parser rule where they are allowed as identifiers
 665 // and are special cased in function_call
 666 //ASCII :       'ASCII' {$type = checkFunctionAsID($type);};    // ascii is special in other places, too.
 667 //CHARSET       :       'CHARSET' {$type = checkFunctionAsID($type);};
 668 //COALESCE      :       'COALESCE' {$type = checkFunctionAsID($type);};
 669 //COLLATION     :       'COLLATION' {$type = checkFunctionAsID($type);};
 670 //CONTAINS      :       'CONTAINS' {$type = checkFunctionAsID($type);};
 671 //DATABASE      :       'DATABASE' {$type = checkFunctionAsID($type);};
 672 //GEOMETRYCOLLECTION    :       'GEOMETRYCOLLECTION' {$type = checkFunctionAsID($type);};
 673 // IF is a function and reserved, thus it cannot appear unquoted in any other context
 674 //LINESTRING    :       'LINESTRING' {$type = checkFunctionAsID($type);};
 675 //MICROSECOND   :       'MICROSECOND' {$type = checkFunctionAsID($type);};
 676 // MOD can both be a function or an operator and is reserved, thus it cannot appear unquoted in any other context
 677 //MULTILINESTRING       :       'MULTILINESTRING' {$type = checkFunctionAsID($type);};
 678 //MULTIPOINT    :       'MULTIPOINT' {$type = checkFunctionAsID($type);};
 679 //MULTIPOLYGON  :       'MULTIPOLYGON' {$type = checkFunctionAsID($type);};
 680 //OLD_PASSWORD  :       'OLD_PASSWORD' {$type = checkFunctionAsID($type);};
 681 //PASSWORD      :       'PASSWORD' {$type = checkFunctionAsID($type);};
 682 //POINT :       'POINT' {$type = checkFunctionAsID($type);};
 683 //POLYGON       :       'POLYGON' {$type = checkFunctionAsID($type);};
 684 //QUARTER       :       'QUARTER' {$type = checkFunctionAsID($type);};
 685 //REPEAT        :       'REPEAT' {$type = checkFunctionAsID($type);};
 686 //REPLACE       :       'REPLACE' {$type = checkFunctionAsID($type);};
 687 //TRUNCATE      :       'TRUNCATE' {$type = checkFunctionAsID($type);};
 688 //WEEK  :       'WEEK' {$type = checkFunctionAsID($type);};
 689
 690 /* keywords that can also be function names */
 691 CHAR    :       'CHAR'; // reserved
 692 CURRENT_USER    :       'CURRENT_USER';// reserved
 693 DATE    :       'DATE' {$type = checkFunctionAsID($type);};
 694 DAY     :       'DAY'; // {$type = checkFunctionAsID($type);}; // not affected by IGNORE_SPACE since 5.1.13
 695 HOUR    :       'HOUR' {$type = checkFunctionAsID($type);};
 696 INSERT  :       'INSERT'; // reserved
 697 INTERVAL        :       'INTERVAL'; // reserved
 698 LEFT    :       'LEFT'; // reserved
 699 MINUTE  :       'MINUTE' {$type = checkFunctionAsID($type);};
 700 MONTH   :       'MONTH' {$type = checkFunctionAsID($type);};
 701 RIGHT   :       'RIGHT'; // reserved
 702 SECOND  :       'SECOND' {$type = checkFunctionAsID($type);};
 703 TIME    :       'TIME' {$type = checkFunctionAsID($type);};
 704 TIMESTAMP       :       'TIMESTAMP' {$type = checkFunctionAsID($type);};
 705 TRIM    :       'TRIM' {$type = checkFunctionAsID($type);};
 706 USER    :       'USER' {$type = checkFunctionAsID($type);};
 707 YEAR    :       'YEAR' {$type = checkFunctionAsID($type);};
 708
 709
 710 // $> Builtin SQL Functions
 711
 712 // $< Operators
 713
 714 /**
 715 Operator Precedence Table from the 5.1 docs:
 716
 717 BINARY, COLLATE
 718 !
 719 - (unary minus), ~ (unary bit inversion)
 720 ^
 721 *, /, DIV, %, MOD
 722 -, +
 723 <<, >>
 724 &
 725 |
 726 =, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
 727 BETWEEN, CASE, WHEN, THEN, ELSE
 728 NOT
 729 &&, AND
 730 XOR
 731 ||, OR
 732 :=
 733 */
 734
 735 ASSIGN          :       ':=';
 736 PLUS            :       '+';
 737 MINUS           :       '-';
 738 MULT            :       '*';
 739 DIVISION        :       '/';
 740 MODULO          :       '%';
 741 BITWISE_XOR     :       '^';
 742 BITWISE_INVERSION       :       '~';
 743 BITWISE_AND     :       '&';
 744 LOGICAL_AND     :       '&&';
 745 BITWISE_OR      :       '|';
 746 LOGICAL_OR      :       '||';
 747 LESS_THAN       :       '<';
 748 LEFT_SHIFT      :       '<<';
 749 LESS_THAN_EQUAL :       '<=';
 750 NULL_SAFE_NOT_EQUAL     :       '<=>';
 751 EQUALS          :       '=';
 752 NOT_OP          :       '!';
 753 NOT_EQUAL       :       '<>' | '!=';
 754 GREATER_THAN:   '>';
 755 RIGHT_SHIFT     :       '>>';
 756 GREATER_THAN_EQUAL      :       '>=';
 757 // $> Operators
 758
 759 // $< Data types
 760 BIGINT  :       'BIGINT';
 761 BIT     :       'BIT';
 762 BLOB    :       'BLOB';
 763 //CHAR  :       'CHAR';         // also function
 764 //DATE  :       'DATE';         // also function
 765 DATETIME        :       'DATETIME';
 766 DECIMAL :       'DECIMAL';
 767 DOUBLE  :       'DOUBLE';
 768 ENUM    :       'ENUM';
 769 FLOAT   :       'FLOAT';
 770 INT     :       'INT';
 771 INTEGER :       'INTEGER';
 772 LONGBLOB        :       'LONGBLOB';
 773 LONGTEXT        :       'LONGTEXT';
 774 MEDIUMBLOB      :       'MEDIUMBLOB';
 775 MEDIUMINT       :       'MEDIUMINT';
 776 MEDIUMTEXT      :       'MEDIUMTEXT';
 777 NUMERIC :       'NUMERIC';
 778 REAL    :       'REAL';
 779 SMALLINT        :       'SMALLINT';
 780 TEXT    :       'TEXT';
 781 //TIME  :       'TIME';         // also function
 782 //TIMESTAMP     :       'TIMESTAMP';            // also function
 783 TINYBLOB        :       'TINYBLOB';
 784 TINYINT :       'TINYINT';
 785 TINYTEXT        :       'TINYTEXT';
 786 VARBINARY       :       'VARBINARY';
 787 VARCHAR :       'VARCHAR';
 788 //YEAR  :       'YEAR';         // also function
 789 // $> Data types
 790
 791
 792
 793 // $< Generic Tokens
 794
 795 /**
 796  * Values like b'1011' or B'1011'.
 797  * Even though binary values look like strings, they are of a special data type. The initial 'b' can both upper and lower case.
 798  * The quote character must be the single quote ('\''), whitespace is not allowed between 'b'|'B' and the quoted binary value.
 799  */
 800 BINARY_VALUE
 801         :       ('B' '\'')=> 'B\'' ('0'|'1')* '\''
 802         ;
 803
 804 HEXA_VALUE
 805         :       ('X' '\'')=> 'X\'' (DIGIT|'A'|'B'|'C'|'D'|'E'|'F')* '\''
 806         ;
 807
 808 /*
 809  * Character sets and collations are handled in the parser, as both allow whitespace between the string and the modifiers.
 810  * The n and N 'national character set' (UTF8 for MySQL 4.1 and up) modifiers do _not_ allow whitespace and thus must be handled here.
 811  *
 812  * Quoting quotes: By doubling the quote character used to start the string, you can quote that character itself:
 813  *        Input such as  "He said:""Foo!""" results in the single token STRING with the text: < He said:"Foo!" >
 814  * Alternatively the quote character can be escaped using the standard escape character ('\').
 815  *
 816  * Binary and hexadecimal are syntactically equivalent to strings but have a different meaning and should not be tokenized as STRING. See below.
 817  */
 818 fragment
 819 STRING
 820         :       'N'?                    // "introducer" for the national character set (UTF8 for MySQL 4.1 and up). must immediately precede the first quote character.
 821                 (       '"'
 822                         (       ('""')=> '""'
 823 //                      |       (ESCAPE_SEQUENCE)=> ESCAPE_SEQUENCE
 824                         |       ~('"'|'\\')
 825                         )*
 826                         '"'     // TODO: collapse two consecutive internal double quotes into one
 827                 |       '\''
 828                         (       ('\'\'')=> '\'\''
 829 //                      |       (ESCAPE_SEQUENCE)=> ESCAPE_SEQUENCE
 830                         |       ~('\''|'\\')
 831                         )*
 832                         '\''    // TODO: same as above with single quotes
 833                 )
 834         ;
 835
 836
 837 /**
 838  * UNDERSCORE_ID is a bad hack because for character sets we need an identifier which starts with '_'.
 839  * The bad thing is, if the actual identifier is not a valid character set name it does not start a string, even though it looks it does.
 840  * In that case, if it is a select_expr, it is specifying an alias for a column. Note that this ambiguity only arises with unquoted identifiers,
 841  * as character set modifiers for strings can never be quoted.
 842  */
 843 /*UNDERSCORE_ID
 844         :       {input.LA(1) == '_'}? => REAL_ID
 845         ;
 846 */
 847 /* user@host, ID and SESSION_VARIABLES are ambiguous */
 848 USER_HOST_or_ID_or_STRING
 849   : ID  {$type=ID;}
 850     ( USER_HOST {$type=USER_HOST;} )?
 851   | STRING {$type=STRING;} (USER_HOST {$type=USER_HOST;})?
 852   ;
 853
 854 fragment
 855 USER_HOST
 856   : '@' (ID | STRING)
 857   ;
 858
 859 fragment
 860 ID  : '`' (options{greedy=false;}: (~('`'))+) '`'
 861   | REAL_ID
 862   ;
 863
 864 fragment
 865 REAL_ID
 866         :       ('A'..'Z'|'_') ('0'..'9'|'A'..'Z'|'_')*         // TODO: what are the valid characters?
 867         ;
 868
 869
 870
 871 // TODO: these are case sensitive -> specifying them as lowercase in the grammar causes them to never be matched (because ANTLR doesn't know
 872 // we are only serving uppercase letters. Add trueCaseLA predicates here (but beware of hoisting)
 873 // TODO: this rule is broken; it is to parse Java source files not compiled strings.
 874 // The entire rule should be removed...
 875 //fragment
 876 //ESCAPE_SEQUENCE
 877 //      :       '\\'
 878 //              (       '0'
 879 //              |       '\''
 880 //              |       '"'
 881 //              |       'b'
 882 //              |       'n'             // TODO currently this clashes with \N == NULL. add predicate!
 883 //              |       'r'
 884 //              |       't'
 885 //              |       'Z'             // this is UPPERCASE! -> use ANTLRNoCaseStringStream.trueCaseLA() in predicate to resolve
 886 //              |       '\\'
 887 //              |       '%'
 888 //              |       '_'
 889 //              |    character=.     // TODO: collapse into just $char; this might be an error
 890 //              )
 891 //      ;
 892
 893 fragment
 894 DIGIT
 895         :       '0'..'9'
 896         ;
 897
 898
 899 /**
 900  * alternatives are delineated because otherwise NUMBER would be an epsilon transition, matching endlessly on a syntax error
 901  * unary minus|plus must be handled in the parser
 902  */
 903 NUMBER
 904         :
 905                 (       DIGIT+                  // 1434
 906                 |       DOT DIGIT+              // .02343
 907                 |       DIGIT+ DOT DIGIT*       // 13212.       or      12334.234234
 908                 )
 909                 ('E' DIGIT+)?
 910         ;
 911
 912 // $< Comments
 913 // DASHDASH_COMMENTS are special in the sense that they require the '--' to be followed by whitespace. If there's no whitespace '--' should be lexed as MINUS MINUS
 914 COMMENT_RULE
 915         :       (       C_COMMENT
 916                 |       POUND_COMMENT
 917                 |       {input.LA(3)==' ' || input.LA(3) == '\t' || input.LA(3) == '\n' || input.LA(3) == '\r'}?=> DASHDASH_COMMENT
 918                 )
 919                 {$channel=98;}
 920         ;
 921
 922 fragment
 923 C_COMMENT
 924         :       '/*' ( options {greedy=false;} : . )* '*/'
 925         ;
 926
 927 fragment
 928 POUND_COMMENT
 929         :       '#' ~('\n'|'\r')* '\r'? '\n'
 930         ;
 931
 932 fragment
 933 DASHDASH_COMMENT
 934         :       '--' (' ' | '\t' | '\n' | '\r') ~('\n'|'\r')* '\r'? '\n'
 935         ;
 936 // $> Comments
 937 GLOBAL_VARIABLE
 938         :       '@@' ID
 939         ;
 940 /* todo: user variables can be quoted, thus ID is wrong here */
 941 SESSION_VARIABLE
 942         :       '@' ID
 943         ;
 944
 945 WS      :       (' ' | '\t' | '\n' | '\r')+ { $channel=HIDDEN; }
 946         ;
 947
 948 /**
 949  * for normalized queries all values should have been replaced with a '?' character.
 950  * Tokenize that as special.
 951  */
 952 VALUE_PLACEHOLDER
 953         :       '?'
 954         ;
 955 // $> Generic Tokens