From 21ffab6af056f19471a086003229f5ec4b3653bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adam=20Zieli=C5=84ski?= Date: Sun, 11 Aug 2024 17:51:16 +0200 Subject: [PATCH 01/17] MySQL AST Parser v1 --- .../wp-includes/mysql-parser/MySQLLexer.php | 9033 +++++++++ .../wp-includes/mysql-parser/MySQLParser.php | 16610 ++++++++++++++++ .../mysql-parser/generate_parser.py | 118 + .../wp-includes/mysql-parser/run-tests.php | 101 + 4 files changed, 25862 insertions(+) create mode 100644 wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php create mode 100644 wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php create mode 100644 wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/generate_parser.py create mode 100644 wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/run-tests.php diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php new file mode 100644 index 00000000..30dd75e3 --- /dev/null +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php @@ -0,0 +1,9033 @@ +input = $input; + $this->serverVersion = $serverVersion; + $this->sqlModes = $sqlModes; + } + + const PipesAsConcat = 1; + const HighNotPrecedence = 2; + const NoBackslashEscapes = 4; + + public function isSqlModeActive(int $mode): bool + { + return ($this->sqlModes & $mode) !== 0; + } + + public function getServerVersion() + { + return $this->serverVersion; + } + + public static function getTokenName(int $tokenType): string + { + if (isset(self::$tokenNames[$tokenType])) { + return self::$tokenNames[$tokenType]; + } + + return ''; + } + + public function getText(): string + { + return $this->text; + } + + public function getType(): int + { + return $this->type; + } + + public function setType(int $type): void + { + $this->type = $type; + } + + public function getNextToken() + { + $this->nextToken(); + return $this->tokenInstance; + } + + private function nextToken() + { + while (true) { + $this->text = ''; + $this->type = null; + $this->tokenInstance = null; + $this->channel = self::DEFAULT_TOKEN_CHANNEL; + + $la = $this->LA(1); + + if ($la === "'") { + $this->SINGLE_QUOTED_TEXT(); + } elseif ($la === '"') { + $this->DOUBLE_QUOTED_TEXT(); + } elseif ($la === '`') { + $this->BACK_TICK_QUOTED_ID(); + } elseif (safe_ctype_digit($la)) { + $this->NUMBER(); + } elseif ($la === '.') { + if (safe_ctype_digit($this->LA(2))) { + $this->NUMBER(); + } else { + $this->DOT_IDENTIFIER(); + } + } elseif ($la === '=') { + $this->EQUAL_OPERATOR(); + } elseif ($la === ':') { + if ($this->LA(2) === '=') { + $this->ASSIGN_OPERATOR(); + } else { + $this->COLON_SYMBOL(); + } + } elseif ($la === '<') { + if ($this->LA(2) === '=') { + if ($this->LA(3) === '>') { + $this->NULL_SAFE_EQUAL_OPERATOR(); + } else { + $this->LESS_OR_EQUAL_OPERATOR(); + } + } elseif ($this->LA(2) === '>') { + $this->NOT_EQUAL2_OPERATOR(); + } elseif ($this->LA(2) === '<') { + $this->SHIFT_LEFT_OPERATOR(); + } else { + $this->LESS_THAN_OPERATOR(); + } + } elseif ($la === '>') { + if ($this->LA(2) === '=') { + $this->GREATER_OR_EQUAL_OPERATOR(); + } elseif ($this->LA(2) === '>') { + $this->SHIFT_RIGHT_OPERATOR(); + } else { + $this->GREATER_THAN_OPERATOR(); + } + } elseif ($la === '!') { + if ($this->LA(2) === '=') { + $this->NOT_EQUAL_OPERATOR(); + } else { + $this->LOGICAL_NOT_OPERATOR(); + } + } elseif ($la === '+') { + $this->PLUS_OPERATOR(); + } elseif ($la === '-') { + if ($this->LA(2) === '>') { + if ($this->LA(3) === '>') { + $this->JSON_UNQUOTED_SEPARATOR_SYMBOL(); + } else { + $this->JSON_SEPARATOR_SYMBOL(); + } + } else { + $this->MINUS_OPERATOR(); + } + } elseif ($la === '*') { + $this->MULT_OPERATOR(); + } elseif ($la === '/') { + if ($this->LA(2) === '*') { + $this->blockComment(); + } else { + $this->DIV_OPERATOR(); + } + } elseif ($la === '%') { + $this->MOD_OPERATOR(); + } elseif ($la === '&') { + if ($this->LA(2) === '&') { + $this->LOGICAL_AND_OPERATOR(); + } else { + $this->BITWISE_AND_OPERATOR(); + } + } elseif ($la === '^') { + $this->BITWISE_XOR_OPERATOR(); + } elseif ($la === '|') { + if ($this->LA(2) === '|') { + $this->LOGICAL_OR_OPERATOR(); + } else { + $this->BITWISE_OR_OPERATOR(); + } + } elseif ($la === '~') { + $this->BITWISE_NOT_OPERATOR(); + } elseif ($la === ',') { + $this->COMMA_SYMBOL(); + } elseif ($la === ';') { + $this->SEMICOLON_SYMBOL(); + } elseif ($la === '(') { + $this->OPEN_PAR_SYMBOL(); + } elseif ($la === ')') { + $this->CLOSE_PAR_SYMBOL(); + } elseif ($la === '{') { + $this->OPEN_CURLY_SYMBOL(); + } elseif ($la === '}') { + $this->CLOSE_CURLY_SYMBOL(); + } elseif ($la === '_') { + $this->UNDERLINE_SYMBOL(); + } elseif ($la === '@') { + if ($this->LA(2) === '@') { + $this->AT_AT_SIGN_SYMBOL(); + } else { + $this->AT_SIGN_SYMBOL(); + } + } elseif ($la === '?') { + $this->PARAM_MARKER(); + } elseif ($la === '\\') { + if ($this->LA(2) === 'N') { + $this->NULL2_SYMBOL(); + } else { + $this->INVALID_INPUT(); + } + } elseif ($la === '#') { + $this->POUND_COMMENT(); + } elseif ($la === '-' && $this->LA(2) === '-') { + $this->DASHDASH_COMMENT(); + } elseif (safe_ctype_space($la)) { + $this->WHITESPACE(); + } elseif ($la === '0' && ($this->LA(2) === 'x' || $this->LA(2) === 'b')) { + $this->NUMBER(); + } elseif (safe_ctype_alpha($la)) { + $this->IDENTIFIER_OR_KEYWORD(); + } elseif ($la === null) { + $this->matchEOF(); + $this->tokenInstance = new MySQLToken(self::EOF, ''); + return false; + } else { + $this->INVALID_INPUT(); + } + + if(null !== $this->type) { + break; + } + } + + $this->tokenInstance = new MySQLToken($this->type, $this->text, $this->channel); + return true; + } + + public function getToken() + { + return $this->tokenInstance; + } + + public function peekNextToken(int $k=1) + { + if ($k <= 0) { + throw new \InvalidArgumentException('k must be greater than 0.'); + } + + $pos = $this->position; + $c = $this->c; + $n = $this->n; + $token = $this->token; + $text = $this->text; + $type = $this->type; + $channel = $this->channel; + $tokenInstance = $this->tokenInstance; + + $token = null; + for ($i = 1; $i <= $k; ++$i) { + $token = $this->getNextToken(); + } + + $this->position = $pos; + $this->c = $c; + $this->n = $n; + $this->token = $token; + $this->text = $text; + $this->type = $type; + $this->channel = $channel; + $this->tokenInstance = $tokenInstance; + + return $token; + } + + protected function LA(int $i): ?string + { + if(null === $this->c) { + $this->c = $this->input[$this->position] ?? null; + } + if ($i === 1) { + return $this->c; + } elseif ($i === 2) { + return $this->n; + } else { + if ($this->position + $i - 1 >= strlen($this->input)) { + return null; + } else { + return $this->input[$this->position + $i - 1]; + } + } + } + + protected function consume(): void + { + $this->text .= $this->c; + + if ($this->position < strlen($this->input)) { + ++$this->position; + $this->c = $this->input[$this->position] ?? null; + $this->n = $this->input[$this->position + 1] ?? null; + } else { + $this->c = null; + $this->n = null; + } + } + + protected function matchEOF(): void + { + if ($this->c === null) { + $this->matchAny(); + } else { + throw new \RuntimeException('Current character is not EOF.'); + } + } + + protected function matchAny(): void + { + $this->consume(); + } + + protected function match(string $x): void + { + if ($this->c === $x) { + $this->consume(); + } else { + throw new \RuntimeException(sprintf("Expecting '%s', found '%s'", $x, $this->c)); + } + } + + /** + * This is a place holder to support features of MySQLBaseLexer which are not yet implemented + * in the PHP target. + * + * @return bool + */ + protected function checkVersion(string $text): bool + { + return false; + } + + /** + * This is a place holder to support features of MySQLBaseLexer which are not yet implemented + * in the PHP target. + * + * @return int + */ + protected function checkCharset(string $text): int + { + return 0; + } + + /** + * This is a place holder to support features of MySQLBaseLexer which are not yet implemented + * in the PHP target. + * + * @return void + */ + protected function emitDot(): void + { + return; + } + + protected static $tokenNames = [ + self::EQUAL_OPERATOR => 'EQUAL_OPERATOR', + self::ASSIGN_OPERATOR => 'ASSIGN_OPERATOR', + self::NULL_SAFE_EQUAL_OPERATOR => 'NULL_SAFE_EQUAL_OPERATOR', + self::GREATER_OR_EQUAL_OPERATOR => 'GREATER_OR_EQUAL_OPERATOR', + self::GREATER_THAN_OPERATOR => 'GREATER_THAN_OPERATOR', + self::LESS_OR_EQUAL_OPERATOR => 'LESS_OR_EQUAL_OPERATOR', + self::LESS_THAN_OPERATOR => 'LESS_THAN_OPERATOR', + self::NOT_EQUAL_OPERATOR => 'NOT_EQUAL_OPERATOR', + self::PLUS_OPERATOR => 'PLUS_OPERATOR', + self::MINUS_OPERATOR => 'MINUS_OPERATOR', + self::MULT_OPERATOR => 'MULT_OPERATOR', + self::DIV_OPERATOR => 'DIV_OPERATOR', + self::MOD_OPERATOR => 'MOD_OPERATOR', + self::LOGICAL_NOT_OPERATOR => 'LOGICAL_NOT_OPERATOR', + self::BITWISE_NOT_OPERATOR => 'BITWISE_NOT_OPERATOR', + self::SHIFT_LEFT_OPERATOR => 'SHIFT_LEFT_OPERATOR', + self::SHIFT_RIGHT_OPERATOR => 'SHIFT_RIGHT_OPERATOR', + self::LOGICAL_AND_OPERATOR => 'LOGICAL_AND_OPERATOR', + self::BITWISE_AND_OPERATOR => 'BITWISE_AND_OPERATOR', + self::BITWISE_XOR_OPERATOR => 'BITWISE_XOR_OPERATOR', + self::LOGICAL_OR_OPERATOR => 'LOGICAL_OR_OPERATOR', + self::BITWISE_OR_OPERATOR => 'BITWISE_OR_OPERATOR', + self::DOT_SYMBOL => 'DOT_SYMBOL', + self::COMMA_SYMBOL => 'COMMA_SYMBOL', + self::SEMICOLON_SYMBOL => 'SEMICOLON_SYMBOL', + self::COLON_SYMBOL => 'COLON_SYMBOL', + self::OPEN_PAR_SYMBOL => 'OPEN_PAR_SYMBOL', + self::CLOSE_PAR_SYMBOL => 'CLOSE_PAR_SYMBOL', + self::OPEN_CURLY_SYMBOL => 'OPEN_CURLY_SYMBOL', + self::CLOSE_CURLY_SYMBOL => 'CLOSE_CURLY_SYMBOL', + self::UNDERLINE_SYMBOL => 'UNDERLINE_SYMBOL', + self::JSON_SEPARATOR_SYMBOL => 'JSON_SEPARATOR_SYMBOL', + self::JSON_UNQUOTED_SEPARATOR_SYMBOL => 'JSON_UNQUOTED_SEPARATOR_SYMBOL', + self::AT_SIGN_SYMBOL => 'AT_SIGN_SYMBOL', + self::AT_TEXT_SUFFIX => 'AT_TEXT_SUFFIX', + self::AT_AT_SIGN_SYMBOL => 'AT_AT_SIGN_SYMBOL', + self::NULL2_SYMBOL => 'NULL2_SYMBOL', + self::PARAM_MARKER => 'PARAM_MARKER', + self::INT_SYMBOL => 'INT_SYMBOL', + self::TINYINT_SYMBOL => 'TINYINT_SYMBOL', + self::SMALLINT_SYMBOL => 'SMALLINT_SYMBOL', + self::MEDIUMINT_SYMBOL => 'MEDIUMINT_SYMBOL', + self::BIGINT_SYMBOL => 'BIGINT_SYMBOL', + self::REAL_SYMBOL => 'REAL_SYMBOL', + self::DOUBLE_SYMBOL => 'DOUBLE_SYMBOL', + self::FLOAT_SYMBOL => 'FLOAT_SYMBOL', + self::DECIMAL_SYMBOL => 'DECIMAL_SYMBOL', + self::NUMERIC_SYMBOL => 'NUMERIC_SYMBOL', + self::DATE_SYMBOL => 'DATE_SYMBOL', + self::TIME_SYMBOL => 'TIME_SYMBOL', + self::TIMESTAMP_SYMBOL => 'TIMESTAMP_SYMBOL', + self::DATETIME_SYMBOL => 'DATETIME_SYMBOL', + self::YEAR_SYMBOL => 'YEAR_SYMBOL', + self::CHAR_SYMBOL => 'CHAR_SYMBOL', + self::VARCHAR_SYMBOL => 'VARCHAR_SYMBOL', + self::BINARY_SYMBOL => 'BINARY_SYMBOL', + self::VARBINARY_SYMBOL => 'VARBINARY_SYMBOL', + self::TINYBLOB_SYMBOL => 'TINYBLOB_SYMBOL', + self::BLOB_SYMBOL => 'BLOB_SYMBOL', + self::MEDIUMBLOB_SYMBOL => 'MEDIUMBLOB_SYMBOL', + self::LONGBLOB_SYMBOL => 'LONGBLOB_SYMBOL', + self::TINYTEXT_SYMBOL => 'TINYTEXT_SYMBOL', + self::TEXT_SYMBOL => 'TEXT_SYMBOL', + self::MEDIUMTEXT_SYMBOL => 'MEDIUMTEXT_SYMBOL', + self::LONGTEXT_SYMBOL => 'LONGTEXT_SYMBOL', + self::ENUM_SYMBOL => 'ENUM_SYMBOL', + self::SET_SYMBOL => 'SET_SYMBOL', + self::JSON_SYMBOL => 'JSON_SYMBOL', + self::GEOMETRY_SYMBOL => 'GEOMETRY_SYMBOL', + self::POINT_SYMBOL => 'POINT_SYMBOL', + self::LINESTRING_SYMBOL => 'LINESTRING_SYMBOL', + self::POLYGON_SYMBOL => 'POLYGON_SYMBOL', + self::GEOMETRYCOLLECTION_SYMBOL => 'GEOMETRYCOLLECTION_SYMBOL', + self::MULTIPOINT_SYMBOL => 'MULTIPOINT_SYMBOL', + self::MULTILINESTRING_SYMBOL => 'MULTILINESTRING_SYMBOL', + self::MULTIPOLYGON_SYMBOL => 'MULTIPOLYGON_SYMBOL', + self::ACCESSIBLE_SYMBOL => 'ACCESSIBLE_SYMBOL', + self::ACCOUNT_SYMBOL => 'ACCOUNT_SYMBOL', + self::ACTION_SYMBOL => 'ACTION_SYMBOL', + self::ADD_SYMBOL => 'ADD_SYMBOL', + self::AFTER_SYMBOL => 'AFTER_SYMBOL', + self::AGAINST_SYMBOL => 'AGAINST_SYMBOL', + self::AGGREGATE_SYMBOL => 'AGGREGATE_SYMBOL', + self::ALGORITHM_SYMBOL => 'ALGORITHM_SYMBOL', + self::ALL_SYMBOL => 'ALL_SYMBOL', + self::ALTER_SYMBOL => 'ALTER_SYMBOL', + self::ALWAYS_SYMBOL => 'ALWAYS_SYMBOL', + self::ANALYSE_SYMBOL => 'ANALYSE_SYMBOL', + self::ANALYZE_SYMBOL => 'ANALYZE_SYMBOL', + self::AND_SYMBOL => 'AND_SYMBOL', + self::ANY_SYMBOL => 'ANY_SYMBOL', + self::AS_SYMBOL => 'AS_SYMBOL', + self::ASC_SYMBOL => 'ASC_SYMBOL', + self::ASENSITIVE_SYMBOL => 'ASENSITIVE_SYMBOL', + self::AT_SYMBOL => 'AT_SYMBOL', + self::AUTOEXTEND_SIZE_SYMBOL => 'AUTOEXTEND_SIZE_SYMBOL', + self::AUTO_INCREMENT_SYMBOL => 'AUTO_INCREMENT_SYMBOL', + self::AVG_ROW_LENGTH_SYMBOL => 'AVG_ROW_LENGTH_SYMBOL', + self::AVG_SYMBOL => 'AVG_SYMBOL', + self::BACKUP_SYMBOL => 'BACKUP_SYMBOL', + self::BEFORE_SYMBOL => 'BEFORE_SYMBOL', + self::BEGIN_SYMBOL => 'BEGIN_SYMBOL', + self::BETWEEN_SYMBOL => 'BETWEEN_SYMBOL', + self::BINLOG_SYMBOL => 'BINLOG_SYMBOL', + self::BIT_AND_SYMBOL => 'BIT_AND_SYMBOL', + self::BIT_OR_SYMBOL => 'BIT_OR_SYMBOL', + self::BIT_XOR_SYMBOL => 'BIT_XOR_SYMBOL', + self::BLOCK_SYMBOL => 'BLOCK_SYMBOL', + self::BOOL_SYMBOL => 'BOOL_SYMBOL', + self::BOOLEAN_SYMBOL => 'BOOLEAN_SYMBOL', + self::BOTH_SYMBOL => 'BOTH_SYMBOL', + self::BTREE_SYMBOL => 'BTREE_SYMBOL', + self::BY_SYMBOL => 'BY_SYMBOL', + self::BYTE_SYMBOL => 'BYTE_SYMBOL', + self::CACHE_SYMBOL => 'CACHE_SYMBOL', + self::CALL_SYMBOL => 'CALL_SYMBOL', + self::CASCADE_SYMBOL => 'CASCADE_SYMBOL', + self::CASCADED_SYMBOL => 'CASCADED_SYMBOL', + self::CASE_SYMBOL => 'CASE_SYMBOL', + self::CAST_SYMBOL => 'CAST_SYMBOL', + self::CATALOG_NAME_SYMBOL => 'CATALOG_NAME_SYMBOL', + self::CHAIN_SYMBOL => 'CHAIN_SYMBOL', + self::CHANGE_SYMBOL => 'CHANGE_SYMBOL', + self::CHANGED_SYMBOL => 'CHANGED_SYMBOL', + self::CHANNEL_SYMBOL => 'CHANNEL_SYMBOL', + self::CHARSET_SYMBOL => 'CHARSET_SYMBOL', + self::CHARACTER_SYMBOL => 'CHARACTER_SYMBOL', + self::CHECK_SYMBOL => 'CHECK_SYMBOL', + self::CHECKSUM_SYMBOL => 'CHECKSUM_SYMBOL', + self::CIPHER_SYMBOL => 'CIPHER_SYMBOL', + self::CLASS_ORIGIN_SYMBOL => 'CLASS_ORIGIN_SYMBOL', + self::CLIENT_SYMBOL => 'CLIENT_SYMBOL', + self::CLOSE_SYMBOL => 'CLOSE_SYMBOL', + self::COALESCE_SYMBOL => 'COALESCE_SYMBOL', + self::CODE_SYMBOL => 'CODE_SYMBOL', + self::COLLATE_SYMBOL => 'COLLATE_SYMBOL', + self::COLLATION_SYMBOL => 'COLLATION_SYMBOL', + self::COLUMN_FORMAT_SYMBOL => 'COLUMN_FORMAT_SYMBOL', + self::COLUMN_NAME_SYMBOL => 'COLUMN_NAME_SYMBOL', + self::COLUMNS_SYMBOL => 'COLUMNS_SYMBOL', + self::COLUMN_SYMBOL => 'COLUMN_SYMBOL', + self::COMMENT_SYMBOL => 'COMMENT_SYMBOL', + self::COMMITTED_SYMBOL => 'COMMITTED_SYMBOL', + self::COMMIT_SYMBOL => 'COMMIT_SYMBOL', + self::COMPACT_SYMBOL => 'COMPACT_SYMBOL', + self::COMPLETION_SYMBOL => 'COMPLETION_SYMBOL', + self::COMPRESSED_SYMBOL => 'COMPRESSED_SYMBOL', + self::COMPRESSION_SYMBOL => 'COMPRESSION_SYMBOL', + self::CONCURRENT_SYMBOL => 'CONCURRENT_SYMBOL', + self::CONDITION_SYMBOL => 'CONDITION_SYMBOL', + self::CONNECTION_SYMBOL => 'CONNECTION_SYMBOL', + self::CONSISTENT_SYMBOL => 'CONSISTENT_SYMBOL', + self::CONSTRAINT_SYMBOL => 'CONSTRAINT_SYMBOL', + self::CONSTRAINT_CATALOG_SYMBOL => 'CONSTRAINT_CATALOG_SYMBOL', + self::CONSTRAINT_NAME_SYMBOL => 'CONSTRAINT_NAME_SYMBOL', + self::CONSTRAINT_SCHEMA_SYMBOL => 'CONSTRAINT_SCHEMA_SYMBOL', + self::CONTAINS_SYMBOL => 'CONTAINS_SYMBOL', + self::CONTEXT_SYMBOL => 'CONTEXT_SYMBOL', + self::CONTINUE_SYMBOL => 'CONTINUE_SYMBOL', + self::CONTRIBUTORS_SYMBOL => 'CONTRIBUTORS_SYMBOL', + self::CONVERT_SYMBOL => 'CONVERT_SYMBOL', + self::COUNT_SYMBOL => 'COUNT_SYMBOL', + self::CPU_SYMBOL => 'CPU_SYMBOL', + self::CREATE_SYMBOL => 'CREATE_SYMBOL', + self::CROSS_SYMBOL => 'CROSS_SYMBOL', + self::CUBE_SYMBOL => 'CUBE_SYMBOL', + self::CURDATE_SYMBOL => 'CURDATE_SYMBOL', + self::CURRENT_DATE_SYMBOL => 'CURRENT_DATE_SYMBOL', + self::CURRENT_TIME_SYMBOL => 'CURRENT_TIME_SYMBOL', + self::CURRENT_TIMESTAMP_SYMBOL => 'CURRENT_TIMESTAMP_SYMBOL', + self::CURRENT_USER_SYMBOL => 'CURRENT_USER_SYMBOL', + self::CURRENT_SYMBOL => 'CURRENT_SYMBOL', + self::CURSOR_SYMBOL => 'CURSOR_SYMBOL', + self::CURSOR_NAME_SYMBOL => 'CURSOR_NAME_SYMBOL', + self::CURTIME_SYMBOL => 'CURTIME_SYMBOL', + self::DATABASE_SYMBOL => 'DATABASE_SYMBOL', + self::DATABASES_SYMBOL => 'DATABASES_SYMBOL', + self::DATAFILE_SYMBOL => 'DATAFILE_SYMBOL', + self::DATA_SYMBOL => 'DATA_SYMBOL', + self::DATE_ADD_SYMBOL => 'DATE_ADD_SYMBOL', + self::DATE_SUB_SYMBOL => 'DATE_SUB_SYMBOL', + self::DAY_HOUR_SYMBOL => 'DAY_HOUR_SYMBOL', + self::DAY_MICROSECOND_SYMBOL => 'DAY_MICROSECOND_SYMBOL', + self::DAY_MINUTE_SYMBOL => 'DAY_MINUTE_SYMBOL', + self::DAY_SECOND_SYMBOL => 'DAY_SECOND_SYMBOL', + self::DAY_SYMBOL => 'DAY_SYMBOL', + self::DAYOFMONTH_SYMBOL => 'DAYOFMONTH_SYMBOL', + self::DEALLOCATE_SYMBOL => 'DEALLOCATE_SYMBOL', + self::DEC_SYMBOL => 'DEC_SYMBOL', + self::DECLARE_SYMBOL => 'DECLARE_SYMBOL', + self::DEFAULT_SYMBOL => 'DEFAULT_SYMBOL', + self::DEFAULT_AUTH_SYMBOL => 'DEFAULT_AUTH_SYMBOL', + self::DEFINER_SYMBOL => 'DEFINER_SYMBOL', + self::DELAYED_SYMBOL => 'DELAYED_SYMBOL', + self::DELAY_KEY_WRITE_SYMBOL => 'DELAY_KEY_WRITE_SYMBOL', + self::DELETE_SYMBOL => 'DELETE_SYMBOL', + self::DESC_SYMBOL => 'DESC_SYMBOL', + self::DESCRIBE_SYMBOL => 'DESCRIBE_SYMBOL', + self::DES_KEY_FILE_SYMBOL => 'DES_KEY_FILE_SYMBOL', + self::DETERMINISTIC_SYMBOL => 'DETERMINISTIC_SYMBOL', + self::DIAGNOSTICS_SYMBOL => 'DIAGNOSTICS_SYMBOL', + self::DIRECTORY_SYMBOL => 'DIRECTORY_SYMBOL', + self::DISABLE_SYMBOL => 'DISABLE_SYMBOL', + self::DISCARD_SYMBOL => 'DISCARD_SYMBOL', + self::DISK_SYMBOL => 'DISK_SYMBOL', + self::DISTINCT_SYMBOL => 'DISTINCT_SYMBOL', + self::DISTINCTROW_SYMBOL => 'DISTINCTROW_SYMBOL', + self::DIV_SYMBOL => 'DIV_SYMBOL', + self::DO_SYMBOL => 'DO_SYMBOL', + self::DROP_SYMBOL => 'DROP_SYMBOL', + self::DUAL_SYMBOL => 'DUAL_SYMBOL', + self::DUMPFILE_SYMBOL => 'DUMPFILE_SYMBOL', + self::DUPLICATE_SYMBOL => 'DUPLICATE_SYMBOL', + self::DYNAMIC_SYMBOL => 'DYNAMIC_SYMBOL', + self::EACH_SYMBOL => 'EACH_SYMBOL', + self::ELSE_SYMBOL => 'ELSE_SYMBOL', + self::ELSEIF_SYMBOL => 'ELSEIF_SYMBOL', + self::EMPTY_SYMBOL => 'EMPTY_SYMBOL', + self::ENABLE_SYMBOL => 'ENABLE_SYMBOL', + self::ENCLOSED_SYMBOL => 'ENCLOSED_SYMBOL', + self::ENCRYPTION_SYMBOL => 'ENCRYPTION_SYMBOL', + self::END_SYMBOL => 'END_SYMBOL', + self::ENDS_SYMBOL => 'ENDS_SYMBOL', + self::ENFORCED_SYMBOL => 'ENFORCED_SYMBOL', + self::ENGINES_SYMBOL => 'ENGINES_SYMBOL', + self::ENGINE_SYMBOL => 'ENGINE_SYMBOL', + self::ERROR_SYMBOL => 'ERROR_SYMBOL', + self::ERRORS_SYMBOL => 'ERRORS_SYMBOL', + self::ESCAPED_SYMBOL => 'ESCAPED_SYMBOL', + self::ESCAPE_SYMBOL => 'ESCAPE_SYMBOL', + self::EVENT_SYMBOL => 'EVENT_SYMBOL', + self::EVENTS_SYMBOL => 'EVENTS_SYMBOL', + self::EVERY_SYMBOL => 'EVERY_SYMBOL', + self::EXCHANGE_SYMBOL => 'EXCHANGE_SYMBOL', + self::EXCEPT_SYMBOL => 'EXCEPT_SYMBOL', + self::EXECUTE_SYMBOL => 'EXECUTE_SYMBOL', + self::EXISTS_SYMBOL => 'EXISTS_SYMBOL', + self::EXIT_SYMBOL => 'EXIT_SYMBOL', + self::EXPANSION_SYMBOL => 'EXPANSION_SYMBOL', + self::EXPIRE_SYMBOL => 'EXPIRE_SYMBOL', + self::EXPLAIN_SYMBOL => 'EXPLAIN_SYMBOL', + self::EXPORT_SYMBOL => 'EXPORT_SYMBOL', + self::EXTENDED_SYMBOL => 'EXTENDED_SYMBOL', + self::EXTENT_SIZE_SYMBOL => 'EXTENT_SIZE_SYMBOL', + self::EXTRACT_SYMBOL => 'EXTRACT_SYMBOL', + self::FALSE_SYMBOL => 'FALSE_SYMBOL', + self::FAST_SYMBOL => 'FAST_SYMBOL', + self::FAULTS_SYMBOL => 'FAULTS_SYMBOL', + self::FETCH_SYMBOL => 'FETCH_SYMBOL', + self::FIELDS_SYMBOL => 'FIELDS_SYMBOL', + self::FILE_BLOCK_SIZE_SYMBOL => 'FILE_BLOCK_SIZE_SYMBOL', + self::FILE_SYMBOL => 'FILE_SYMBOL', + self::FILTER_SYMBOL => 'FILTER_SYMBOL', + self::FIRST_SYMBOL => 'FIRST_SYMBOL', + self::FIRST_VALUE_SYMBOL => 'FIRST_VALUE_SYMBOL', + self::FIXED_SYMBOL => 'FIXED_SYMBOL', + self::FLOAT4_SYMBOL => 'FLOAT4_SYMBOL', + self::FLOAT8_SYMBOL => 'FLOAT8_SYMBOL', + self::FLUSH_SYMBOL => 'FLUSH_SYMBOL', + self::FOLLOWS_SYMBOL => 'FOLLOWS_SYMBOL', + self::FORCE_SYMBOL => 'FORCE_SYMBOL', + self::FOREIGN_SYMBOL => 'FOREIGN_SYMBOL', + self::FOR_SYMBOL => 'FOR_SYMBOL', + self::FORMAT_SYMBOL => 'FORMAT_SYMBOL', + self::FOUND_SYMBOL => 'FOUND_SYMBOL', + self::FROM_SYMBOL => 'FROM_SYMBOL', + self::FULLTEXT_SYMBOL => 'FULLTEXT_SYMBOL', + self::FULL_SYMBOL => 'FULL_SYMBOL', + self::FUNCTION_SYMBOL => 'FUNCTION_SYMBOL', + self::GENERATED_SYMBOL => 'GENERATED_SYMBOL', + self::GENERAL_SYMBOL => 'GENERAL_SYMBOL', + self::GET_FORMAT_SYMBOL => 'GET_FORMAT_SYMBOL', + self::GET_MASTER_PUBLIC_KEY_SYMBOL => 'GET_MASTER_PUBLIC_KEY_SYMBOL', + self::GLOBAL_SYMBOL => 'GLOBAL_SYMBOL', + self::GRANT_SYMBOL => 'GRANT_SYMBOL', + self::GRANTS_SYMBOL => 'GRANTS_SYMBOL', + self::GROUP_CONCAT_SYMBOL => 'GROUP_CONCAT_SYMBOL', + self::GROUP_REPLICATION_SYMBOL => 'GROUP_REPLICATION_SYMBOL', + self::GROUP_SYMBOL => 'GROUP_SYMBOL', + self::HANDLER_SYMBOL => 'HANDLER_SYMBOL', + self::HASH_SYMBOL => 'HASH_SYMBOL', + self::HAVING_SYMBOL => 'HAVING_SYMBOL', + self::HELP_SYMBOL => 'HELP_SYMBOL', + self::HIGH_PRIORITY_SYMBOL => 'HIGH_PRIORITY_SYMBOL', + self::HISTOGRAM_SYMBOL => 'HISTOGRAM_SYMBOL', + self::HISTORY_SYMBOL => 'HISTORY_SYMBOL', + self::HOST_SYMBOL => 'HOST_SYMBOL', + self::HOSTS_SYMBOL => 'HOSTS_SYMBOL', + self::HOUR_MICROSECOND_SYMBOL => 'HOUR_MICROSECOND_SYMBOL', + self::HOUR_MINUTE_SYMBOL => 'HOUR_MINUTE_SYMBOL', + self::HOUR_SECOND_SYMBOL => 'HOUR_SECOND_SYMBOL', + self::HOUR_SYMBOL => 'HOUR_SYMBOL', + self::IDENTIFIED_SYMBOL => 'IDENTIFIED_SYMBOL', + self::IF_SYMBOL => 'IF_SYMBOL', + self::IGNORE_SYMBOL => 'IGNORE_SYMBOL', + self::IGNORE_SERVER_IDS_SYMBOL => 'IGNORE_SERVER_IDS_SYMBOL', + self::IMPORT_SYMBOL => 'IMPORT_SYMBOL', + self::IN_SYMBOL => 'IN_SYMBOL', + self::INDEXES_SYMBOL => 'INDEXES_SYMBOL', + self::INDEX_SYMBOL => 'INDEX_SYMBOL', + self::INFILE_SYMBOL => 'INFILE_SYMBOL', + self::INITIAL_SIZE_SYMBOL => 'INITIAL_SIZE_SYMBOL', + self::INNER_SYMBOL => 'INNER_SYMBOL', + self::INOUT_SYMBOL => 'INOUT_SYMBOL', + self::INSENSITIVE_SYMBOL => 'INSENSITIVE_SYMBOL', + self::INSERT_SYMBOL => 'INSERT_SYMBOL', + self::INSERT_METHOD_SYMBOL => 'INSERT_METHOD_SYMBOL', + self::INSTANCE_SYMBOL => 'INSTANCE_SYMBOL', + self::INSTALL_SYMBOL => 'INSTALL_SYMBOL', + self::INTEGER_SYMBOL => 'INTEGER_SYMBOL', + self::INTERVAL_SYMBOL => 'INTERVAL_SYMBOL', + self::INTO_SYMBOL => 'INTO_SYMBOL', + self::INVISIBLE_SYMBOL => 'INVISIBLE_SYMBOL', + self::INVOKER_SYMBOL => 'INVOKER_SYMBOL', + self::IO_SYMBOL => 'IO_SYMBOL', + self::IPC_SYMBOL => 'IPC_SYMBOL', + self::IS_SYMBOL => 'IS_SYMBOL', + self::ISOLATION_SYMBOL => 'ISOLATION_SYMBOL', + self::ISSUER_SYMBOL => 'ISSUER_SYMBOL', + self::ITERATE_SYMBOL => 'ITERATE_SYMBOL', + self::JOIN_SYMBOL => 'JOIN_SYMBOL', + self::JSON_TABLE_SYMBOL => 'JSON_TABLE_SYMBOL', + self::JSON_ARRAYAGG_SYMBOL => 'JSON_ARRAYAGG_SYMBOL', + self::JSON_OBJECTAGG_SYMBOL => 'JSON_OBJECTAGG_SYMBOL', + self::KEYS_SYMBOL => 'KEYS_SYMBOL', + self::KEY_BLOCK_SIZE_SYMBOL => 'KEY_BLOCK_SIZE_SYMBOL', + self::KEY_SYMBOL => 'KEY_SYMBOL', + self::KILL_SYMBOL => 'KILL_SYMBOL', + self::LANGUAGE_SYMBOL => 'LANGUAGE_SYMBOL', + self::LAST_SYMBOL => 'LAST_SYMBOL', + self::LAST_VALUE_SYMBOL => 'LAST_VALUE_SYMBOL', + self::LATERAL_SYMBOL => 'LATERAL_SYMBOL', + self::LEAD_SYMBOL => 'LEAD_SYMBOL', + self::LEADING_SYMBOL => 'LEADING_SYMBOL', + self::LEAVE_SYMBOL => 'LEAVE_SYMBOL', + self::LEAVES_SYMBOL => 'LEAVES_SYMBOL', + self::LEFT_SYMBOL => 'LEFT_SYMBOL', + self::LESS_SYMBOL => 'LESS_SYMBOL', + self::LEVEL_SYMBOL => 'LEVEL_SYMBOL', + self::LIKE_SYMBOL => 'LIKE_SYMBOL', + self::LIMIT_SYMBOL => 'LIMIT_SYMBOL', + self::LINEAR_SYMBOL => 'LINEAR_SYMBOL', + self::LINES_SYMBOL => 'LINES_SYMBOL', + self::LIST_SYMBOL => 'LIST_SYMBOL', + self::LOAD_SYMBOL => 'LOAD_SYMBOL', + self::LOCALTIME_SYMBOL => 'LOCALTIME_SYMBOL', + self::LOCALTIMESTAMP_SYMBOL => 'LOCALTIMESTAMP_SYMBOL', + self::LOCAL_SYMBOL => 'LOCAL_SYMBOL', + self::LOCATOR_SYMBOL => 'LOCATOR_SYMBOL', + self::LOCK_SYMBOL => 'LOCK_SYMBOL', + self::LOCKS_SYMBOL => 'LOCKS_SYMBOL', + self::LOGFILE_SYMBOL => 'LOGFILE_SYMBOL', + self::LOGS_SYMBOL => 'LOGS_SYMBOL', + self::LOOP_SYMBOL => 'LOOP_SYMBOL', + self::LOW_PRIORITY_SYMBOL => 'LOW_PRIORITY_SYMBOL', + self::MASTER_SYMBOL => 'MASTER_SYMBOL', + self::MASTER_AUTO_POSITION_SYMBOL => 'MASTER_AUTO_POSITION_SYMBOL', + self::MASTER_BIND_SYMBOL => 'MASTER_BIND_SYMBOL', + self::MASTER_CONNECT_RETRY_SYMBOL => 'MASTER_CONNECT_RETRY_SYMBOL', + self::MASTER_DELAY_SYMBOL => 'MASTER_DELAY_SYMBOL', + self::MASTER_HEARTBEAT_PERIOD_SYMBOL => 'MASTER_HEARTBEAT_PERIOD_SYMBOL', + self::MASTER_HOST_SYMBOL => 'MASTER_HOST_SYMBOL', + self::NETWORK_NAMESPACE_SYMBOL => 'NETWORK_NAMESPACE_SYMBOL', + self::MASTER_LOG_FILE_SYMBOL => 'MASTER_LOG_FILE_SYMBOL', + self::MASTER_LOG_POS_SYMBOL => 'MASTER_LOG_POS_SYMBOL', + self::MASTER_PASSWORD_SYMBOL => 'MASTER_PASSWORD_SYMBOL', + self::MASTER_PORT_SYMBOL => 'MASTER_PORT_SYMBOL', + self::MASTER_PUBLIC_KEY_PATH_SYMBOL => 'MASTER_PUBLIC_KEY_PATH_SYMBOL', + self::MASTER_RETRY_COUNT_SYMBOL => 'MASTER_RETRY_COUNT_SYMBOL', + self::MASTER_SERVER_ID_SYMBOL => 'MASTER_SERVER_ID_SYMBOL', + self::MASTER_SSL_CAPATH_SYMBOL => 'MASTER_SSL_CAPATH_SYMBOL', + self::MASTER_SSL_CA_SYMBOL => 'MASTER_SSL_CA_SYMBOL', + self::MASTER_SSL_CERT_SYMBOL => 'MASTER_SSL_CERT_SYMBOL', + self::MASTER_SSL_CIPHER_SYMBOL => 'MASTER_SSL_CIPHER_SYMBOL', + self::MASTER_SSL_CRL_SYMBOL => 'MASTER_SSL_CRL_SYMBOL', + self::MASTER_SSL_CRLPATH_SYMBOL => 'MASTER_SSL_CRLPATH_SYMBOL', + self::MASTER_SSL_KEY_SYMBOL => 'MASTER_SSL_KEY_SYMBOL', + self::MASTER_SSL_SYMBOL => 'MASTER_SSL_SYMBOL', + self::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL => 'MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL', + self::MASTER_TLS_VERSION_SYMBOL => 'MASTER_TLS_VERSION_SYMBOL', + self::MASTER_TLS_CIPHERSUITES_SYMBOL => 'MASTER_TLS_CIPHERSUITES_SYMBOL', + self::MASTER_USER_SYMBOL => 'MASTER_USER_SYMBOL', + self::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL => 'MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL', + self::MATCH_SYMBOL => 'MATCH_SYMBOL', + self::MAX_CONNECTIONS_PER_HOUR_SYMBOL => 'MAX_CONNECTIONS_PER_HOUR_SYMBOL', + self::MAX_QUERIES_PER_HOUR_SYMBOL => 'MAX_QUERIES_PER_HOUR_SYMBOL', + self::MAX_ROWS_SYMBOL => 'MAX_ROWS_SYMBOL', + self::MAX_SIZE_SYMBOL => 'MAX_SIZE_SYMBOL', + self::MAX_STATEMENT_TIME_SYMBOL => 'MAX_STATEMENT_TIME_SYMBOL', + self::MAX_UPDATES_PER_HOUR_SYMBOL => 'MAX_UPDATES_PER_HOUR_SYMBOL', + self::MAX_USER_CONNECTIONS_SYMBOL => 'MAX_USER_CONNECTIONS_SYMBOL', + self::MAXVALUE_SYMBOL => 'MAXVALUE_SYMBOL', + self::MAX_SYMBOL => 'MAX_SYMBOL', + self::MEDIUM_SYMBOL => 'MEDIUM_SYMBOL', + self::MEMBER_SYMBOL => 'MEMBER_SYMBOL', + self::MEMORY_SYMBOL => 'MEMORY_SYMBOL', + self::MERGE_SYMBOL => 'MERGE_SYMBOL', + self::MESSAGE_TEXT_SYMBOL => 'MESSAGE_TEXT_SYMBOL', + self::MICROSECOND_SYMBOL => 'MICROSECOND_SYMBOL', + self::MIDDLEINT_SYMBOL => 'MIDDLEINT_SYMBOL', + self::MIGRATE_SYMBOL => 'MIGRATE_SYMBOL', + self::MINUTE_MICROSECOND_SYMBOL => 'MINUTE_MICROSECOND_SYMBOL', + self::MINUTE_SECOND_SYMBOL => 'MINUTE_SECOND_SYMBOL', + self::MINUTE_SYMBOL => 'MINUTE_SYMBOL', + self::MIN_ROWS_SYMBOL => 'MIN_ROWS_SYMBOL', + self::MIN_SYMBOL => 'MIN_SYMBOL', + self::MODE_SYMBOL => 'MODE_SYMBOL', + self::MODIFIES_SYMBOL => 'MODIFIES_SYMBOL', + self::MODIFY_SYMBOL => 'MODIFY_SYMBOL', + self::MOD_SYMBOL => 'MOD_SYMBOL', + self::MONTH_SYMBOL => 'MONTH_SYMBOL', + self::MUTEX_SYMBOL => 'MUTEX_SYMBOL', + self::MYSQL_ERRNO_SYMBOL => 'MYSQL_ERRNO_SYMBOL', + self::NAME_SYMBOL => 'NAME_SYMBOL', + self::NAMES_SYMBOL => 'NAMES_SYMBOL', + self::NATIONAL_SYMBOL => 'NATIONAL_SYMBOL', + self::NATURAL_SYMBOL => 'NATURAL_SYMBOL', + self::NCHAR_SYMBOL => 'NCHAR_SYMBOL', + self::NDBCLUSTER_SYMBOL => 'NDBCLUSTER_SYMBOL', + self::NDB_SYMBOL => 'NDB_SYMBOL', + self::NEG_SYMBOL => 'NEG_SYMBOL', + self::NESTED_SYMBOL => 'NESTED_SYMBOL', + self::NEVER_SYMBOL => 'NEVER_SYMBOL', + self::NEW_SYMBOL => 'NEW_SYMBOL', + self::NEXT_SYMBOL => 'NEXT_SYMBOL', + self::NODEGROUP_SYMBOL => 'NODEGROUP_SYMBOL', + self::NONE_SYMBOL => 'NONE_SYMBOL', + self::NONBLOCKING_SYMBOL => 'NONBLOCKING_SYMBOL', + self::NOT_SYMBOL => 'NOT_SYMBOL', + self::NOWAIT_SYMBOL => 'NOWAIT_SYMBOL', + self::NO_WAIT_SYMBOL => 'NO_WAIT_SYMBOL', + self::NO_WRITE_TO_BINLOG_SYMBOL => 'NO_WRITE_TO_BINLOG_SYMBOL', + self::NULL_SYMBOL => 'NULL_SYMBOL', + self::NULLS_SYMBOL => 'NULLS_SYMBOL', + self::NUMBER_SYMBOL => 'NUMBER_SYMBOL', + self::NVARCHAR_SYMBOL => 'NVARCHAR_SYMBOL', + self::NTH_VALUE_SYMBOL => 'NTH_VALUE_SYMBOL', + self::NTILE_SYMBOL => 'NTILE_SYMBOL', + self::OF_SYMBOL => 'OF_SYMBOL', + self::OFF_SYMBOL => 'OFF_SYMBOL', + self::OFFLINE_SYMBOL => 'OFFLINE_SYMBOL', + self::OFFSET_SYMBOL => 'OFFSET_SYMBOL', + self::OJ_SYMBOL => 'OJ_SYMBOL', + self::OLD_PASSWORD_SYMBOL => 'OLD_PASSWORD_SYMBOL', + self::OLD_SYMBOL => 'OLD_SYMBOL', + self::ON_SYMBOL => 'ON_SYMBOL', + self::ONLINE_SYMBOL => 'ONLINE_SYMBOL', + self::ONE_SYMBOL => 'ONE_SYMBOL', + self::ONLY_SYMBOL => 'ONLY_SYMBOL', + self::OPEN_SYMBOL => 'OPEN_SYMBOL', + self::OPTIONAL_SYMBOL => 'OPTIONAL_SYMBOL', + self::OPTIONALLY_SYMBOL => 'OPTIONALLY_SYMBOL', + self::OPTIONS_SYMBOL => 'OPTIONS_SYMBOL', + self::OPTION_SYMBOL => 'OPTION_SYMBOL', + self::OPTIMIZE_SYMBOL => 'OPTIMIZE_SYMBOL', + self::OPTIMIZER_COSTS_SYMBOL => 'OPTIMIZER_COSTS_SYMBOL', + self::ORDER_SYMBOL => 'ORDER_SYMBOL', + self::ORDINALITY_SYMBOL => 'ORDINALITY_SYMBOL', + self::ORGANIZATION_SYMBOL => 'ORGANIZATION_SYMBOL', + self::OR_SYMBOL => 'OR_SYMBOL', + self::OTHERS_SYMBOL => 'OTHERS_SYMBOL', + self::OUTER_SYMBOL => 'OUTER_SYMBOL', + self::OUTFILE_SYMBOL => 'OUTFILE_SYMBOL', + self::OUT_SYMBOL => 'OUT_SYMBOL', + self::OWNER_SYMBOL => 'OWNER_SYMBOL', + self::PACK_KEYS_SYMBOL => 'PACK_KEYS_SYMBOL', + self::PAGE_SYMBOL => 'PAGE_SYMBOL', + self::PARSER_SYMBOL => 'PARSER_SYMBOL', + self::PARTIAL_SYMBOL => 'PARTIAL_SYMBOL', + self::PARTITIONING_SYMBOL => 'PARTITIONING_SYMBOL', + self::PARTITIONS_SYMBOL => 'PARTITIONS_SYMBOL', + self::PARTITION_SYMBOL => 'PARTITION_SYMBOL', + self::PASSWORD_SYMBOL => 'PASSWORD_SYMBOL', + self::PATH_SYMBOL => 'PATH_SYMBOL', + self::PERCENT_RANK_SYMBOL => 'PERCENT_RANK_SYMBOL', + self::PERSIST_SYMBOL => 'PERSIST_SYMBOL', + self::PERSIST_ONLY_SYMBOL => 'PERSIST_ONLY_SYMBOL', + self::PHASE_SYMBOL => 'PHASE_SYMBOL', + self::PLUGIN_SYMBOL => 'PLUGIN_SYMBOL', + self::PLUGINS_SYMBOL => 'PLUGINS_SYMBOL', + self::PLUGIN_DIR_SYMBOL => 'PLUGIN_DIR_SYMBOL', + self::PORT_SYMBOL => 'PORT_SYMBOL', + self::POSITION_SYMBOL => 'POSITION_SYMBOL', + self::PRECEDES_SYMBOL => 'PRECEDES_SYMBOL', + self::PRECEDING_SYMBOL => 'PRECEDING_SYMBOL', + self::PRECISION_SYMBOL => 'PRECISION_SYMBOL', + self::PREPARE_SYMBOL => 'PREPARE_SYMBOL', + self::PRESERVE_SYMBOL => 'PRESERVE_SYMBOL', + self::PREV_SYMBOL => 'PREV_SYMBOL', + self::PRIMARY_SYMBOL => 'PRIMARY_SYMBOL', + self::PRIVILEGES_SYMBOL => 'PRIVILEGES_SYMBOL', + self::PRIVILEGE_CHECKS_USER_SYMBOL => 'PRIVILEGE_CHECKS_USER_SYMBOL', + self::PROCEDURE_SYMBOL => 'PROCEDURE_SYMBOL', + self::PROCESS_SYMBOL => 'PROCESS_SYMBOL', + self::PROCESSLIST_SYMBOL => 'PROCESSLIST_SYMBOL', + self::PROFILES_SYMBOL => 'PROFILES_SYMBOL', + self::PROFILE_SYMBOL => 'PROFILE_SYMBOL', + self::PROXY_SYMBOL => 'PROXY_SYMBOL', + self::PURGE_SYMBOL => 'PURGE_SYMBOL', + self::QUARTER_SYMBOL => 'QUARTER_SYMBOL', + self::QUERY_SYMBOL => 'QUERY_SYMBOL', + self::QUICK_SYMBOL => 'QUICK_SYMBOL', + self::RANDOM_SYMBOL => 'RANDOM_SYMBOL', + self::RANGE_SYMBOL => 'RANGE_SYMBOL', + self::RANK_SYMBOL => 'RANK_SYMBOL', + self::READS_SYMBOL => 'READS_SYMBOL', + self::READ_ONLY_SYMBOL => 'READ_ONLY_SYMBOL', + self::READ_SYMBOL => 'READ_SYMBOL', + self::READ_WRITE_SYMBOL => 'READ_WRITE_SYMBOL', + self::REBUILD_SYMBOL => 'REBUILD_SYMBOL', + self::RECOVER_SYMBOL => 'RECOVER_SYMBOL', + self::REDOFILE_SYMBOL => 'REDOFILE_SYMBOL', + self::REDO_BUFFER_SIZE_SYMBOL => 'REDO_BUFFER_SIZE_SYMBOL', + self::REDUNDANT_SYMBOL => 'REDUNDANT_SYMBOL', + self::REFERENCES_SYMBOL => 'REFERENCES_SYMBOL', + self::RECURSIVE_SYMBOL => 'RECURSIVE_SYMBOL', + self::REGEXP_SYMBOL => 'REGEXP_SYMBOL', + self::RELAYLOG_SYMBOL => 'RELAYLOG_SYMBOL', + self::RELAY_SYMBOL => 'RELAY_SYMBOL', + self::RELAY_LOG_FILE_SYMBOL => 'RELAY_LOG_FILE_SYMBOL', + self::RELAY_LOG_POS_SYMBOL => 'RELAY_LOG_POS_SYMBOL', + self::RELAY_THREAD_SYMBOL => 'RELAY_THREAD_SYMBOL', + self::RELEASE_SYMBOL => 'RELEASE_SYMBOL', + self::RELOAD_SYMBOL => 'RELOAD_SYMBOL', + self::REMOTE_SYMBOL => 'REMOTE_SYMBOL', + self::REMOVE_SYMBOL => 'REMOVE_SYMBOL', + self::RENAME_SYMBOL => 'RENAME_SYMBOL', + self::REORGANIZE_SYMBOL => 'REORGANIZE_SYMBOL', + self::REPAIR_SYMBOL => 'REPAIR_SYMBOL', + self::REPEAT_SYMBOL => 'REPEAT_SYMBOL', + self::REPEATABLE_SYMBOL => 'REPEATABLE_SYMBOL', + self::REPLACE_SYMBOL => 'REPLACE_SYMBOL', + self::REPLICATION_SYMBOL => 'REPLICATION_SYMBOL', + self::REPLICATE_DO_DB_SYMBOL => 'REPLICATE_DO_DB_SYMBOL', + self::REPLICATE_IGNORE_DB_SYMBOL => 'REPLICATE_IGNORE_DB_SYMBOL', + self::REPLICATE_DO_TABLE_SYMBOL => 'REPLICATE_DO_TABLE_SYMBOL', + self::REPLICATE_IGNORE_TABLE_SYMBOL => 'REPLICATE_IGNORE_TABLE_SYMBOL', + self::REPLICATE_WILD_DO_TABLE_SYMBOL => 'REPLICATE_WILD_DO_TABLE_SYMBOL', + self::REPLICATE_WILD_IGNORE_TABLE_SYMBOL => 'REPLICATE_WILD_IGNORE_TABLE_SYMBOL', + self::REPLICATE_REWRITE_DB_SYMBOL => 'REPLICATE_REWRITE_DB_SYMBOL', + self::REQUIRE_SYMBOL => 'REQUIRE_SYMBOL', + self::REQUIRE_ROW_FORMAT_SYMBOL => 'REQUIRE_ROW_FORMAT_SYMBOL', + self::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL => 'REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL', + self::RESET_SYMBOL => 'RESET_SYMBOL', + self::RESIGNAL_SYMBOL => 'RESIGNAL_SYMBOL', + self::RESOURCE_SYMBOL => 'RESOURCE_SYMBOL', + self::RESPECT_SYMBOL => 'RESPECT_SYMBOL', + self::RESTART_SYMBOL => 'RESTART_SYMBOL', + self::RESTORE_SYMBOL => 'RESTORE_SYMBOL', + self::RESTRICT_SYMBOL => 'RESTRICT_SYMBOL', + self::RESUME_SYMBOL => 'RESUME_SYMBOL', + self::RETAIN_SYMBOL => 'RETAIN_SYMBOL', + self::RETURNED_SQLSTATE_SYMBOL => 'RETURNED_SQLSTATE_SYMBOL', + self::RETURNS_SYMBOL => 'RETURNS_SYMBOL', + self::REUSE_SYMBOL => 'REUSE_SYMBOL', + self::REVERSE_SYMBOL => 'REVERSE_SYMBOL', + self::REVOKE_SYMBOL => 'REVOKE_SYMBOL', + self::RIGHT_SYMBOL => 'RIGHT_SYMBOL', + self::RLIKE_SYMBOL => 'RLIKE_SYMBOL', + self::ROLE_SYMBOL => 'ROLE_SYMBOL', + self::ROLLBACK_SYMBOL => 'ROLLBACK_SYMBOL', + self::ROLLUP_SYMBOL => 'ROLLUP_SYMBOL', + self::ROTATE_SYMBOL => 'ROTATE_SYMBOL', + self::ROW_SYMBOL => 'ROW_SYMBOL', + self::ROWS_SYMBOL => 'ROWS_SYMBOL', + self::ROW_COUNT_SYMBOL => 'ROW_COUNT_SYMBOL', + self::ROW_FORMAT_SYMBOL => 'ROW_FORMAT_SYMBOL', + self::ROW_NUMBER_SYMBOL => 'ROW_NUMBER_SYMBOL', + self::RTREE_SYMBOL => 'RTREE_SYMBOL', + self::SAVEPOINT_SYMBOL => 'SAVEPOINT_SYMBOL', + self::SCHEMA_SYMBOL => 'SCHEMA_SYMBOL', + self::SCHEMAS_SYMBOL => 'SCHEMAS_SYMBOL', + self::SCHEMA_NAME_SYMBOL => 'SCHEMA_NAME_SYMBOL', + self::SCHEDULE_SYMBOL => 'SCHEDULE_SYMBOL', + self::SECOND_MICROSECOND_SYMBOL => 'SECOND_MICROSECOND_SYMBOL', + self::SECOND_SYMBOL => 'SECOND_SYMBOL', + self::SECONDARY_SYMBOL => 'SECONDARY_SYMBOL', + self::SECONDARY_ENGINE_SYMBOL => 'SECONDARY_ENGINE_SYMBOL', + self::SECONDARY_LOAD_SYMBOL => 'SECONDARY_LOAD_SYMBOL', + self::SECONDARY_UNLOAD_SYMBOL => 'SECONDARY_UNLOAD_SYMBOL', + self::SECURITY_SYMBOL => 'SECURITY_SYMBOL', + self::SELECT_SYMBOL => 'SELECT_SYMBOL', + self::SENSITIVE_SYMBOL => 'SENSITIVE_SYMBOL', + self::SEPARATOR_SYMBOL => 'SEPARATOR_SYMBOL', + self::SERIALIZABLE_SYMBOL => 'SERIALIZABLE_SYMBOL', + self::SERIAL_SYMBOL => 'SERIAL_SYMBOL', + self::SERVER_SYMBOL => 'SERVER_SYMBOL', + self::SERVER_OPTIONS_SYMBOL => 'SERVER_OPTIONS_SYMBOL', + self::SESSION_SYMBOL => 'SESSION_SYMBOL', + self::SESSION_USER_SYMBOL => 'SESSION_USER_SYMBOL', + self::SET_VAR_SYMBOL => 'SET_VAR_SYMBOL', + self::SHARE_SYMBOL => 'SHARE_SYMBOL', + self::SHOW_SYMBOL => 'SHOW_SYMBOL', + self::SHUTDOWN_SYMBOL => 'SHUTDOWN_SYMBOL', + self::SIGNAL_SYMBOL => 'SIGNAL_SYMBOL', + self::SIGNED_SYMBOL => 'SIGNED_SYMBOL', + self::SIMPLE_SYMBOL => 'SIMPLE_SYMBOL', + self::SKIP_SYMBOL => 'SKIP_SYMBOL', + self::SLAVE_SYMBOL => 'SLAVE_SYMBOL', + self::SLOW_SYMBOL => 'SLOW_SYMBOL', + self::SNAPSHOT_SYMBOL => 'SNAPSHOT_SYMBOL', + self::SOME_SYMBOL => 'SOME_SYMBOL', + self::SOCKET_SYMBOL => 'SOCKET_SYMBOL', + self::SONAME_SYMBOL => 'SONAME_SYMBOL', + self::SOUNDS_SYMBOL => 'SOUNDS_SYMBOL', + self::SOURCE_SYMBOL => 'SOURCE_SYMBOL', + self::SPATIAL_SYMBOL => 'SPATIAL_SYMBOL', + self::SQL_SYMBOL => 'SQL_SYMBOL', + self::SQLEXCEPTION_SYMBOL => 'SQLEXCEPTION_SYMBOL', + self::SQLSTATE_SYMBOL => 'SQLSTATE_SYMBOL', + self::SQLWARNING_SYMBOL => 'SQLWARNING_SYMBOL', + self::SQL_AFTER_GTIDS_SYMBOL => 'SQL_AFTER_GTIDS_SYMBOL', + self::SQL_AFTER_MTS_GAPS_SYMBOL => 'SQL_AFTER_MTS_GAPS_SYMBOL', + self::SQL_BEFORE_GTIDS_SYMBOL => 'SQL_BEFORE_GTIDS_SYMBOL', + self::SQL_BIG_RESULT_SYMBOL => 'SQL_BIG_RESULT_SYMBOL', + self::SQL_BUFFER_RESULT_SYMBOL => 'SQL_BUFFER_RESULT_SYMBOL', + self::SQL_CALC_FOUND_ROWS_SYMBOL => 'SQL_CALC_FOUND_ROWS_SYMBOL', + self::SQL_CACHE_SYMBOL => 'SQL_CACHE_SYMBOL', + self::SQL_NO_CACHE_SYMBOL => 'SQL_NO_CACHE_SYMBOL', + self::SQL_SMALL_RESULT_SYMBOL => 'SQL_SMALL_RESULT_SYMBOL', + self::SQL_THREAD_SYMBOL => 'SQL_THREAD_SYMBOL', + self::SQL_TSI_DAY_SYMBOL => 'SQL_TSI_DAY_SYMBOL', + self::SQL_TSI_HOUR_SYMBOL => 'SQL_TSI_HOUR_SYMBOL', + self::SQL_TSI_MICROSECOND_SYMBOL => 'SQL_TSI_MICROSECOND_SYMBOL', + self::SQL_TSI_MINUTE_SYMBOL => 'SQL_TSI_MINUTE_SYMBOL', + self::SQL_TSI_MONTH_SYMBOL => 'SQL_TSI_MONTH_SYMBOL', + self::SQL_TSI_QUARTER_SYMBOL => 'SQL_TSI_QUARTER_SYMBOL', + self::SQL_TSI_SECOND_SYMBOL => 'SQL_TSI_SECOND_SYMBOL', + self::SQL_TSI_WEEK_SYMBOL => 'SQL_TSI_WEEK_SYMBOL', + self::SQL_TSI_YEAR_SYMBOL => 'SQL_TSI_YEAR_SYMBOL', + self::SRID_SYMBOL => 'SRID_SYMBOL', + self::SSL_SYMBOL => 'SSL_SYMBOL', + self::STACKED_SYMBOL => 'STACKED_SYMBOL', + self::STARTING_SYMBOL => 'STARTING_SYMBOL', + self::START_SYMBOL => 'START_SYMBOL', + self::STARTS_SYMBOL => 'STARTS_SYMBOL', + self::STATS_AUTO_RECALC_SYMBOL => 'STATS_AUTO_RECALC_SYMBOL', + self::STATS_PERSISTENT_SYMBOL => 'STATS_PERSISTENT_SYMBOL', + self::STATS_SAMPLE_PAGES_SYMBOL => 'STATS_SAMPLE_PAGES_SYMBOL', + self::STATUS_SYMBOL => 'STATUS_SYMBOL', + self::STD_SYMBOL => 'STD_SYMBOL', + self::STDDEV_POP_SYMBOL => 'STDDEV_POP_SYMBOL', + self::STDDEV_SAMP_SYMBOL => 'STDDEV_SAMP_SYMBOL', + self::STDDEV_SYMBOL => 'STDDEV_SYMBOL', + self::STOP_SYMBOL => 'STOP_SYMBOL', + self::STORAGE_SYMBOL => 'STORAGE_SYMBOL', + self::STORED_SYMBOL => 'STORED_SYMBOL', + self::STRAIGHT_JOIN_SYMBOL => 'STRAIGHT_JOIN_SYMBOL', + self::STREAM_SYMBOL => 'STREAM_SYMBOL', + self::STRING_SYMBOL => 'STRING_SYMBOL', + self::SUBCLASS_ORIGIN_SYMBOL => 'SUBCLASS_ORIGIN_SYMBOL', + self::SUBDATE_SYMBOL => 'SUBDATE_SYMBOL', + self::SUBJECT_SYMBOL => 'SUBJECT_SYMBOL', + self::SUBPARTITIONS_SYMBOL => 'SUBPARTITIONS_SYMBOL', + self::SUBPARTITION_SYMBOL => 'SUBPARTITION_SYMBOL', + self::SUBSTR_SYMBOL => 'SUBSTR_SYMBOL', + self::SUBSTRING_SYMBOL => 'SUBSTRING_SYMBOL', + self::SUM_SYMBOL => 'SUM_SYMBOL', + self::SUPER_SYMBOL => 'SUPER_SYMBOL', + self::SUSPEND_SYMBOL => 'SUSPEND_SYMBOL', + self::SWAPS_SYMBOL => 'SWAPS_SYMBOL', + self::SWITCHES_SYMBOL => 'SWITCHES_SYMBOL', + self::SYSDATE_SYMBOL => 'SYSDATE_SYMBOL', + self::SYSTEM_SYMBOL => 'SYSTEM_SYMBOL', + self::SYSTEM_USER_SYMBOL => 'SYSTEM_USER_SYMBOL', + self::TABLE_SYMBOL => 'TABLE_SYMBOL', + self::TABLES_SYMBOL => 'TABLES_SYMBOL', + self::TABLESPACE_SYMBOL => 'TABLESPACE_SYMBOL', + self::TABLE_CHECKSUM_SYMBOL => 'TABLE_CHECKSUM_SYMBOL', + self::TABLE_NAME_SYMBOL => 'TABLE_NAME_SYMBOL', + self::TEMPORARY_SYMBOL => 'TEMPORARY_SYMBOL', + self::TEMPTABLE_SYMBOL => 'TEMPTABLE_SYMBOL', + self::TERMINATED_SYMBOL => 'TERMINATED_SYMBOL', + self::THAN_SYMBOL => 'THAN_SYMBOL', + self::THEN_SYMBOL => 'THEN_SYMBOL', + self::THREAD_PRIORITY_SYMBOL => 'THREAD_PRIORITY_SYMBOL', + self::TIES_SYMBOL => 'TIES_SYMBOL', + self::TIMESTAMP_ADD_SYMBOL => 'TIMESTAMP_ADD_SYMBOL', + self::TIMESTAMP_DIFF_SYMBOL => 'TIMESTAMP_DIFF_SYMBOL', + self::TO_SYMBOL => 'TO_SYMBOL', + self::TRAILING_SYMBOL => 'TRAILING_SYMBOL', + self::TRANSACTION_SYMBOL => 'TRANSACTION_SYMBOL', + self::TRIGGER_SYMBOL => 'TRIGGER_SYMBOL', + self::TRIGGERS_SYMBOL => 'TRIGGERS_SYMBOL', + self::TRIM_SYMBOL => 'TRIM_SYMBOL', + self::TRUE_SYMBOL => 'TRUE_SYMBOL', + self::TRUNCATE_SYMBOL => 'TRUNCATE_SYMBOL', + self::TYPES_SYMBOL => 'TYPES_SYMBOL', + self::TYPE_SYMBOL => 'TYPE_SYMBOL', + self::UDF_RETURNS_SYMBOL => 'UDF_RETURNS_SYMBOL', + self::UNBOUNDED_SYMBOL => 'UNBOUNDED_SYMBOL', + self::UNCOMMITTED_SYMBOL => 'UNCOMMITTED_SYMBOL', + self::UNDEFINED_SYMBOL => 'UNDEFINED_SYMBOL', + self::UNDO_BUFFER_SIZE_SYMBOL => 'UNDO_BUFFER_SIZE_SYMBOL', + self::UNDOFILE_SYMBOL => 'UNDOFILE_SYMBOL', + self::UNDO_SYMBOL => 'UNDO_SYMBOL', + self::UNICODE_SYMBOL => 'UNICODE_SYMBOL', + self::UNION_SYMBOL => 'UNION_SYMBOL', + self::UNIQUE_SYMBOL => 'UNIQUE_SYMBOL', + self::UNKNOWN_SYMBOL => 'UNKNOWN_SYMBOL', + self::UNINSTALL_SYMBOL => 'UNINSTALL_SYMBOL', + self::UNSIGNED_SYMBOL => 'UNSIGNED_SYMBOL', + self::UPDATE_SYMBOL => 'UPDATE_SYMBOL', + self::UPGRADE_SYMBOL => 'UPGRADE_SYMBOL', + self::USAGE_SYMBOL => 'USAGE_SYMBOL', + self::USER_RESOURCES_SYMBOL => 'USER_RESOURCES_SYMBOL', + self::USER_SYMBOL => 'USER_SYMBOL', + self::USE_FRM_SYMBOL => 'USE_FRM_SYMBOL', + self::USE_SYMBOL => 'USE_SYMBOL', + self::USING_SYMBOL => 'USING_SYMBOL', + self::UTC_DATE_SYMBOL => 'UTC_DATE_SYMBOL', + self::UTC_TIME_SYMBOL => 'UTC_TIME_SYMBOL', + self::UTC_TIMESTAMP_SYMBOL => 'UTC_TIMESTAMP_SYMBOL', + self::VALIDATION_SYMBOL => 'VALIDATION_SYMBOL', + self::VALUE_SYMBOL => 'VALUE_SYMBOL', + self::VALUES_SYMBOL => 'VALUES_SYMBOL', + self::VARCHARACTER_SYMBOL => 'VARCHARACTER_SYMBOL', + self::VARIABLES_SYMBOL => 'VARIABLES_SYMBOL', + self::VARIANCE_SYMBOL => 'VARIANCE_SYMBOL', + self::VARYING_SYMBOL => 'VARYING_SYMBOL', + self::VAR_POP_SYMBOL => 'VAR_POP_SYMBOL', + self::VAR_SAMP_SYMBOL => 'VAR_SAMP_SYMBOL', + self::VCPU_SYMBOL => 'VCPU_SYMBOL', + self::VIEW_SYMBOL => 'VIEW_SYMBOL', + self::VIRTUAL_SYMBOL => 'VIRTUAL_SYMBOL', + self::VISIBLE_SYMBOL => 'VISIBLE_SYMBOL', + self::WAIT_SYMBOL => 'WAIT_SYMBOL', + self::WARNINGS_SYMBOL => 'WARNINGS_SYMBOL', + self::WEEK_SYMBOL => 'WEEK_SYMBOL', + self::WHEN_SYMBOL => 'WHEN_SYMBOL', + self::WEIGHT_STRING_SYMBOL => 'WEIGHT_STRING_SYMBOL', + self::WHERE_SYMBOL => 'WHERE_SYMBOL', + self::WHILE_SYMBOL => 'WHILE_SYMBOL', + self::WINDOW_SYMBOL => 'WINDOW_SYMBOL', + self::WITH_SYMBOL => 'WITH_SYMBOL', + self::WITHOUT_SYMBOL => 'WITHOUT_SYMBOL', + self::WORK_SYMBOL => 'WORK_SYMBOL', + self::WRAPPER_SYMBOL => 'WRAPPER_SYMBOL', + self::WRITE_SYMBOL => 'WRITE_SYMBOL', + self::XA_SYMBOL => 'XA_SYMBOL', + self::X509_SYMBOL => 'X509_SYMBOL', + self::XID_SYMBOL => 'XID_SYMBOL', + self::XML_SYMBOL => 'XML_SYMBOL', + self::XOR_SYMBOL => 'XOR_SYMBOL', + self::YEAR_MONTH_SYMBOL => 'YEAR_MONTH_SYMBOL', + self::ZEROFILL_SYMBOL => 'ZEROFILL_SYMBOL', + self::INT1_SYMBOL => 'INT1_SYMBOL', + self::INT2_SYMBOL => 'INT2_SYMBOL', + self::INT3_SYMBOL => 'INT3_SYMBOL', + self::INT4_SYMBOL => 'INT4_SYMBOL', + self::INT8_SYMBOL => 'INT8_SYMBOL', + self::IDENTIFIER => 'IDENTIFIER', + self::BACK_TICK_QUOTED_ID => 'BACK_TICK_QUOTED_ID', + self::DOUBLE_QUOTED_TEXT => 'DOUBLE_QUOTED_TEXT', + self::SINGLE_QUOTED_TEXT => 'SINGLE_QUOTED_TEXT', + self::HEX_NUMBER => 'HEX_NUMBER', + self::BIN_NUMBER => 'BIN_NUMBER', + self::DECIMAL_NUMBER => 'DECIMAL_NUMBER', + self::FLOAT_NUMBER => 'FLOAT_NUMBER', + self::UNDERSCORE_CHARSET => 'UNDERSCORE_CHARSET', + self::DOT_IDENTIFIER => 'DOT_IDENTIFIER', + self::INVALID_INPUT => 'INVALID_INPUT', + self::LINEBREAK => 'LINEBREAK', + ]; + + protected function IDENTIFIER_OR_KEYWORD() + { + // Match the longest possible keyword. + while (safe_ctype_alnum($this->LA(1)) || $this->LA(1) === '_' || $this->LA(1) === '$') { + $this->consume(); + } + $text = $this->getText(); + + // Check for keywords that are also identifiers. + switch (strtoupper($text)) { + case 'ACCESSIBLE': + $this->ACCESSIBLE_SYMBOL(); + break; + case 'ACCOUNT': + if ($this->serverVersion >= 50707) { + $this->ACCOUNT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ACTION': + $this->ACTION_SYMBOL(); + break; + case 'ADD': + $this->ADD_SYMBOL(); + break; + case 'ADDDATE': + $this->ADDDATE_SYMBOL(); + break; + case 'AFTER': + $this->AFTER_SYMBOL(); + break; + case 'AGAINST': + $this->AGAINST_SYMBOL(); + break; + case 'AGGREGATE': + $this->AGGREGATE_SYMBOL(); + break; + case 'ALGORITHM': + $this->ALGORITHM_SYMBOL(); + break; + case 'ALL': + $this->ALL_SYMBOL(); + break; + case 'ALTER': + $this->ALTER_SYMBOL(); + break; + case 'ALWAYS': + if ($this->serverVersion >= 50707) { + $this->ALWAYS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ANALYSE': + if ($this->serverVersion < 80000) { + $this->ANALYSE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ANALYZE': + $this->ANALYZE_SYMBOL(); + break; + case 'AND': + $this->AND_SYMBOL(); + break; + case 'ANY': + $this->ANY_SYMBOL(); + break; + case 'AS': + $this->AS_SYMBOL(); + break; + case 'ASC': + $this->ASC_SYMBOL(); + break; + case 'ASCII': + $this->ASCII_SYMBOL(); + break; + case 'ASENSITIVE': + $this->ASENSITIVE_SYMBOL(); + break; + case 'AT': + $this->AT_SYMBOL(); + break; + case 'AUTHORS': + if ($this->serverVersion < 50700) { + $this->AUTHORS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'AUTOEXTEND_SIZE': + $this->AUTOEXTEND_SIZE_SYMBOL(); + break; + case 'AUTO_INCREMENT': + $this->AUTO_INCREMENT_SYMBOL(); + break; + case 'AVG': + $this->AVG_SYMBOL(); + break; + case 'AVG_ROW_LENGTH': + $this->AVG_ROW_LENGTH_SYMBOL(); + break; + case 'BACKUP': + $this->BACKUP_SYMBOL(); + break; + case 'BEFORE': + $this->BEFORE_SYMBOL(); + break; + case 'BEGIN': + $this->BEGIN_SYMBOL(); + break; + case 'BETWEEN': + $this->BETWEEN_SYMBOL(); + break; + case 'BIGINT': + $this->BIGINT_SYMBOL(); + break; + case 'BINARY': + $this->BINARY_SYMBOL(); + break; + case 'BINLOG': + $this->BINLOG_SYMBOL(); + break; + case 'BIT': + $this->BIT_SYMBOL(); + break; + case 'BIT_AND': + $this->BIT_AND_SYMBOL(); + break; + case 'BIT_OR': + $this->BIT_OR_SYMBOL(); + break; + case 'BIT_XOR': + $this->BIT_XOR_SYMBOL(); + break; + case 'BLOB': + $this->BLOB_SYMBOL(); + break; + case 'BLOCK': + $this->BLOCK_SYMBOL(); + break; + case 'BOOL': + $this->BOOL_SYMBOL(); + break; + case 'BOOLEAN': + $this->BOOLEAN_SYMBOL(); + break; + case 'BOTH': + $this->BOTH_SYMBOL(); + break; + case 'BTREE': + $this->BTREE_SYMBOL(); + break; + case 'BY': + $this->BY_SYMBOL(); + break; + case 'BYTE': + $this->BYTE_SYMBOL(); + break; + case 'CACHE': + $this->CACHE_SYMBOL(); + break; + case 'CALL': + $this->CALL_SYMBOL(); + break; + case 'CASCADE': + $this->CASCADE_SYMBOL(); + break; + case 'CASCADED': + $this->CASCADED_SYMBOL(); + break; + case 'CASE': + $this->CASE_SYMBOL(); + break; + case 'CAST': + $this->CAST_SYMBOL(); + break; + case 'CATALOG_NAME': + $this->CATALOG_NAME_SYMBOL(); + break; + case 'CHAIN': + $this->CHAIN_SYMBOL(); + break; + case 'CHANGE': + $this->CHANGE_SYMBOL(); + break; + case 'CHANGED': + $this->CHANGED_SYMBOL(); + break; + case 'CHANNEL': + if ($this->serverVersion >= 50706) { + $this->CHANNEL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'CHAR': + $this->CHAR_SYMBOL(); + break; + case 'CHARSET': + $this->CHARSET_SYMBOL(); + break; + case 'CHARACTER': + $this->CHAR_SYMBOL(); // Synonym + break; + case 'CHECK': + $this->CHECK_SYMBOL(); + break; + case 'CHECKSUM': + $this->CHECKSUM_SYMBOL(); + break; + case 'CIPHER': + $this->CIPHER_SYMBOL(); + break; + case 'CLASS_ORIGIN': + $this->CLASS_ORIGIN_SYMBOL(); + break; + case 'CLIENT': + $this->CLIENT_SYMBOL(); + break; + case 'CLOSE': + $this->CLOSE_SYMBOL(); + break; + case 'COALESCE': + $this->COALESCE_SYMBOL(); + break; + case 'CODE': + $this->CODE_SYMBOL(); + break; + case 'COLLATE': + $this->COLLATE_SYMBOL(); + break; + case 'COLLATION': + $this->COLLATION_SYMBOL(); + break; + case 'COLUMN': + $this->COLUMN_SYMBOL(); + break; + case 'COLUMNS': + $this->COLUMNS_SYMBOL(); + break; + case 'COLUMN_FORMAT': + $this->COLUMN_FORMAT_SYMBOL(); + break; + case 'COLUMN_NAME': + $this->COLUMN_NAME_SYMBOL(); + break; + case 'COMMENT': + $this->COMMENT_SYMBOL(); + break; + case 'COMMITTED': + $this->COMMITTED_SYMBOL(); + break; + case 'COMMIT': + $this->COMMIT_SYMBOL(); + break; + case 'COMPACT': + $this->COMPACT_SYMBOL(); + break; + case 'COMPLETION': + $this->COMPLETION_SYMBOL(); + break; + case 'COMPRESSED': + $this->COMPRESSED_SYMBOL(); + break; + case 'COMPRESSION': + if ($this->serverVersion >= 50707) { + $this->COMPRESSION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'CONCURRENT': + $this->CONCURRENT_SYMBOL(); + break; + case 'CONDITION': + $this->CONDITION_SYMBOL(); + break; + case 'CONNECTION': + $this->CONNECTION_SYMBOL(); + break; + case 'CONSISTENT': + $this->CONSISTENT_SYMBOL(); + break; + case 'CONSTRAINT': + $this->CONSTRAINT_SYMBOL(); + break; + case 'CONSTRAINT_CATALOG': + $this->CONSTRAINT_CATALOG_SYMBOL(); + break; + case 'CONSTRAINT_NAME': + $this->CONSTRAINT_NAME_SYMBOL(); + break; + case 'CONSTRAINT_SCHEMA': + $this->CONSTRAINT_SCHEMA_SYMBOL(); + break; + case 'CONTAINS': + $this->CONTAINS_SYMBOL(); + break; + case 'CONTEXT': + $this->CONTEXT_SYMBOL(); + break; + case 'CONTINUE': + $this->CONTINUE_SYMBOL(); + break; + case 'CONTRIBUTORS': + if ($this->serverVersion < 50700) { + $this->CONTRIBUTORS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'CONVERT': + $this->CONVERT_SYMBOL(); + break; + case 'COUNT': + $this->COUNT_SYMBOL(); + break; + case 'CPU': + $this->CPU_SYMBOL(); + break; + case 'CREATE': + $this->CREATE_SYMBOL(); + break; + case 'CROSS': + $this->CROSS_SYMBOL(); + break; + case 'CUBE': + if ($this->serverVersion < 80000) { + $this->CUBE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'CURDATE': + $this->CURDATE_SYMBOL(); + break; + case 'CURRENT': + if ($this->serverVersion >= 50604) { + $this->CURRENT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'CURRENT_DATE': + $this->CURDATE_SYMBOL(); // Synonym + break; + case 'CURRENT_TIME': + $this->CURTIME_SYMBOL(); // Synonym + break; + case 'CURRENT_TIMESTAMP': + $this->NOW_SYMBOL(); // Synonym + break; + case 'CURRENT_USER': + $this->CURRENT_USER_SYMBOL(); + break; + case 'CURSOR': + $this->CURSOR_SYMBOL(); + break; + case 'CURSOR_NAME': + $this->CURSOR_NAME_SYMBOL(); + break; + case 'CURTIME': + $this->CURTIME_SYMBOL(); + break; + case 'DATABASE': + $this->DATABASE_SYMBOL(); + break; + case 'DATABASES': + $this->DATABASES_SYMBOL(); + break; + case 'DATAFILE': + $this->DATAFILE_SYMBOL(); + break; + case 'DATA': + $this->DATA_SYMBOL(); + break; + case 'DATETIME': + $this->DATETIME_SYMBOL(); + break; + case 'DATE': + $this->DATE_SYMBOL(); + break; + case 'DATE_ADD': + $this->DATE_ADD_SYMBOL(); + break; + case 'DATE_SUB': + $this->DATE_SUB_SYMBOL(); + break; + case 'DAY': + $this->DAY_SYMBOL(); + break; + case 'DAY_HOUR': + $this->DAY_HOUR_SYMBOL(); + break; + case 'DAY_MICROSECOND': + $this->DAY_MICROSECOND_SYMBOL(); + break; + case 'DAY_MINUTE': + $this->DAY_MINUTE_SYMBOL(); + break; + case 'DAY_SECOND': + $this->DAY_SECOND_SYMBOL(); + break; + case 'DAYOFMONTH': + $this->DAY_SYMBOL(); // Synonym + break; + case 'DEALLOCATE': + $this->DEALLOCATE_SYMBOL(); + break; + case 'DEC': + $this->DECIMAL_SYMBOL(); // Synonym + break; + case 'DECIMAL': + $this->DECIMAL_SYMBOL(); + break; + case 'DECLARE': + $this->DECLARE_SYMBOL(); + break; + case 'DEFAULT': + $this->DEFAULT_SYMBOL(); + break; + case 'DEFAULT_AUTH': + if ($this->serverVersion >= 50604) { + $this->DEFAULT_AUTH_SYMBOL(); // Internal + } else { + $this->IDENTIFIER(); + } + break; + case 'DEFINER': + $this->DEFINER_SYMBOL(); + break; + case 'DEFINITION': + if ($this->serverVersion >= 80011) { + $this->DEFINITION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'DELAYED': + $this->DELAYED_SYMBOL(); + break; + case 'DELAY_KEY_WRITE': + $this->DELAY_KEY_WRITE_SYMBOL(); + break; + case 'DELETE': + $this->DELETE_SYMBOL(); + break; + case 'DENSE_RANK': + if ($this->serverVersion >= 80000) { + $this->DENSE_RANK_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'DESC': + $this->DESC_SYMBOL(); + break; + case 'DESCRIBE': + $this->DESCRIBE_SYMBOL(); + break; + case 'DESCRIPTION': + if ($this->serverVersion >= 80011) { + $this->DESCRIPTION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'DES_KEY_FILE': + if ($this->serverVersion < 80000) { + $this->DES_KEY_FILE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'DETERMINISTIC': + $this->DETERMINISTIC_SYMBOL(); + break; + case 'DIAGNOSTICS': + $this->DIAGNOSTICS_SYMBOL(); + break; + case 'DIRECTORY': + $this->DIRECTORY_SYMBOL(); + break; + case 'DISABLE': + $this->DISABLE_SYMBOL(); + break; + case 'DISCARD': + $this->DISCARD_SYMBOL(); + break; + case 'DISK': + $this->DISK_SYMBOL(); + break; + case 'DISTINCT': + $this->DISTINCT_SYMBOL(); + break; + case 'DISTINCTROW': + $this->DISTINCT_SYMBOL(); // Synonym + break; + case 'DIV': + $this->DIV_SYMBOL(); + break; + case 'DOUBLE': + $this->DOUBLE_SYMBOL(); + break; + case 'DO': + $this->DO_SYMBOL(); + break; + case 'DROP': + $this->DROP_SYMBOL(); + break; + case 'DUAL': + $this->DUAL_SYMBOL(); + break; + case 'DUMPFILE': + $this->DUMPFILE_SYMBOL(); + break; + case 'DUPLICATE': + $this->DUPLICATE_SYMBOL(); + break; + case 'DYNAMIC': + $this->DYNAMIC_SYMBOL(); + break; + case 'EACH': + $this->EACH_SYMBOL(); + break; + case 'ELSE': + $this->ELSE_SYMBOL(); + break; + case 'ELSEIF': + $this->ELSEIF_SYMBOL(); + break; + case 'EMPTY': + if ($this->serverVersion >= 80000) { + $this->EMPTY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ENABLE': + $this->ENABLE_SYMBOL(); + break; + case 'ENCLOSED': + $this->ENCLOSED_SYMBOL(); + break; + case 'ENCRYPTION': + if ($this->serverVersion >= 50711) { + $this->ENCRYPTION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'END': + $this->END_SYMBOL(); + break; + case 'ENDS': + $this->ENDS_SYMBOL(); + break; + case 'ENGINE': + $this->ENGINE_SYMBOL(); + break; + case 'ENGINES': + $this->ENGINES_SYMBOL(); + break; + case 'ENFORCED': + if ($this->serverVersion >= 80017) { + $this->ENFORCED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ENUM': + $this->ENUM_SYMBOL(); + break; + case 'ERRORS': + $this->ERRORS_SYMBOL(); + break; + case 'ERROR': + $this->ERROR_SYMBOL(); + break; + case 'ESCAPED': + $this->ESCAPED_SYMBOL(); + break; + case 'ESCAPE': + $this->ESCAPE_SYMBOL(); + break; + case 'EVENT': + $this->EVENT_SYMBOL(); + break; + case 'EVENTS': + $this->EVENTS_SYMBOL(); + break; + case 'EVERY': + $this->EVERY_SYMBOL(); + break; + case 'EXCEPT': + if ($this->serverVersion >= 80000) { + $this->EXCEPT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'EXCHANGE': + $this->EXCHANGE_SYMBOL(); + break; + case 'EXCLUDE': + if ($this->serverVersion >= 80000) { + $this->EXCLUDE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'EXECUTE': + $this->EXECUTE_SYMBOL(); + break; + case 'EXISTS': + $this->EXISTS_SYMBOL(); + break; + case 'EXIT': + $this->EXIT_SYMBOL(); + break; + case 'EXPANSION': + $this->EXPANSION_SYMBOL(); + break; + case 'EXPIRE': + if ($this->serverVersion >= 50606) { + $this->EXPIRE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'EXPLAIN': + $this->EXPLAIN_SYMBOL(); + break; + case 'EXPORT': + if ($this->serverVersion >= 50606) { + $this->EXPORT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'EXTENDED': + $this->EXTENDED_SYMBOL(); + break; + case 'EXTENT_SIZE': + $this->EXTENT_SIZE_SYMBOL(); + break; + case 'EXTRACT': + $this->EXTRACT_SYMBOL(); + break; + case 'FALSE': + $this->FALSE_SYMBOL(); + break; + case 'FAILED_LOGIN_ATTEMPTS': + if ($this->serverVersion >= 80019) { + $this->FAILED_LOGIN_ATTEMPTS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FAST': + $this->FAST_SYMBOL(); + break; + case 'FAULTS': + $this->FAULTS_SYMBOL(); + break; + case 'FETCH': + $this->FETCH_SYMBOL(); + break; + case 'FIELDS': + $this->COLUMNS_SYMBOL(); // Synonym + break; + case 'FILE': + $this->FILE_SYMBOL(); + break; + case 'FILE_BLOCK_SIZE': + if ($this->serverVersion >= 50707) { + $this->FILE_BLOCK_SIZE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FILTER': + if ($this->serverVersion >= 50700) { + $this->FILTER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FIRST': + $this->FIRST_SYMBOL(); + break; + case 'FIRST_VALUE': + if ($this->serverVersion >= 80000) { + $this->FIRST_VALUE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FIXED': + $this->FIXED_SYMBOL(); + break; + case 'FLOAT': + $this->FLOAT_SYMBOL(); + break; + case 'FLOAT4': + $this->FLOAT_SYMBOL(); // Synonym + break; + case 'FLOAT8': + $this->DOUBLE_SYMBOL(); // Synonym + break; + case 'FLUSH': + $this->FLUSH_SYMBOL(); + break; + case 'FOLLOWS': + if ($this->serverVersion >= 50700) { + $this->FOLLOWS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FOLLOWING': + if ($this->serverVersion >= 80000) { + $this->FOLLOWING_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'FORCE': + $this->FORCE_SYMBOL(); + break; + case 'FOR': + $this->FOR_SYMBOL(); + break; + case 'FOREIGN': + $this->FOREIGN_SYMBOL(); + break; + case 'FORMAT': + $this->FORMAT_SYMBOL(); + break; + case 'FOUND': + $this->FOUND_SYMBOL(); + break; + case 'FROM': + $this->FROM_SYMBOL(); + break; + case 'FULL': + $this->FULL_SYMBOL(); + break; + case 'FULLTEXT': + $this->FULLTEXT_SYMBOL(); + break; + case 'FUNCTION': + if ($this->serverVersion < 80000) { + $this->FUNCTION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'GENERATED': + if ($this->serverVersion >= 50707) { + $this->GENERATED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'GENERAL': + $this->GENERAL_SYMBOL(); + break; + case 'GEOMETRYCOLLECTION': + $this->GEOMETRYCOLLECTION_SYMBOL(); + break; + case 'GEOMETRY': + $this->GEOMETRY_SYMBOL(); + break; + case 'GET': + if ($this->serverVersion >= 50604) { + $this->GET_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'GET_FORMAT': + $this->GET_FORMAT_SYMBOL(); + break; + case 'GLOBAL': + $this->GLOBAL_SYMBOL(); + break; + case 'GRANT': + $this->GRANT_SYMBOL(); + break; + case 'GRANTS': + $this->GRANTS_SYMBOL(); + break; + case 'GROUP': + $this->GROUP_SYMBOL(); + break; + case 'GROUP_CONCAT': + $this->GROUP_CONCAT_SYMBOL(); + break; + case 'GROUP_REPLICATION': + if ($this->serverVersion >= 50707) { + $this->GROUP_REPLICATION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'GROUPING': + if ($this->serverVersion >= 80000) { + $this->GROUPING_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'GROUPS': + if ($this->serverVersion >= 80000) { + $this->GROUPS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'HANDLER': + $this->HANDLER_SYMBOL(); + break; + case 'HASH': + $this->HASH_SYMBOL(); + break; + case 'HAVING': + $this->HAVING_SYMBOL(); + break; + case 'HELP': + $this->HELP_SYMBOL(); + break; + case 'HIGH_PRIORITY': + $this->HIGH_PRIORITY_SYMBOL(); + break; + case 'HISTOGRAM': + if ($this->serverVersion >= 80000) { + $this->HISTOGRAM_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'HISTORY': + if ($this->serverVersion >= 80000) { + $this->HISTORY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'HOST': + $this->HOST_SYMBOL(); + break; + case 'HOSTS': + $this->HOSTS_SYMBOL(); + break; + case 'HOUR': + $this->HOUR_SYMBOL(); + break; + case 'HOUR_MICROSECOND': + $this->HOUR_MICROSECOND_SYMBOL(); + break; + case 'HOUR_MINUTE': + $this->HOUR_MINUTE_SYMBOL(); + break; + case 'HOUR_SECOND': + $this->HOUR_SECOND_SYMBOL(); + break; + case 'IDENTIFIED': + $this->IDENTIFIED_SYMBOL(); + break; + case 'IF': + $this->IF_SYMBOL(); + break; + case 'IGNORE': + $this->IGNORE_SYMBOL(); + break; + case 'IGNORE_SERVER_IDS': + $this->IGNORE_SERVER_IDS_SYMBOL(); + break; + case 'IMPORT': + if ($this->serverVersion < 80000) { + $this->IMPORT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'IN': + $this->IN_SYMBOL(); + break; + case 'INDEX': + $this->INDEX_SYMBOL(); + break; + case 'INDEXES': + $this->INDEXES_SYMBOL(); + break; + case 'INFILE': + $this->INFILE_SYMBOL(); + break; + case 'INITIAL_SIZE': + $this->INITIAL_SIZE_SYMBOL(); + break; + case 'INNER': + $this->INNER_SYMBOL(); + break; + case 'INOUT': + $this->INOUT_SYMBOL(); + break; + case 'INSENSITIVE': + $this->INSENSITIVE_SYMBOL(); + break; + case 'INSERT': + $this->INSERT_SYMBOL(); + break; + case 'INSERT_METHOD': + $this->INSERT_METHOD_SYMBOL(); + break; + case 'INSTANCE': + if ($this->serverVersion >= 50713) { + $this->INSTANCE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'INSTALL': + $this->INSTALL_SYMBOL(); + break; + case 'INT': + $this->INT_SYMBOL(); + break; + case 'INTEGER': + $this->INT_SYMBOL(); // Synonym + break; + case 'INTERVAL': + $this->INTERVAL_SYMBOL(); + break; + case 'INTO': + $this->INTO_SYMBOL(); + break; + case 'INVISIBLE': + if ($this->serverVersion >= 80000) { + $this->INVISIBLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'INVOKER': + $this->INVOKER_SYMBOL(); + break; + case 'IO_THREAD': + $this->RELAY_THREAD_SYMBOL(); // Synonym + break; + case 'IO_AFTER_GTIDS': + $this->IDENTIFIER(); // MYSQL, FUTURE-USE + break; + case 'IO_BEFORE_GTIDS': + $this->IDENTIFIER(); // MYSQL, FUTURE-USE + break; + case 'IO': + $this->IO_SYMBOL(); + break; + case 'IPC': + $this->IPC_SYMBOL(); + break; + case 'IS': + $this->IS_SYMBOL(); + break; + case 'ISOLATION': + $this->ISOLATION_SYMBOL(); + break; + case 'ISSUER': + $this->ISSUER_SYMBOL(); + break; + case 'ITERATE': + $this->ITERATE_SYMBOL(); + break; + case 'JOIN': + $this->JOIN_SYMBOL(); + break; + case 'JSON': + if ($this->serverVersion >= 50708) { + $this->JSON_SYMBOL(); // MYSQL + } else { + $this->IDENTIFIER(); + } + break; + case 'JSON_TABLE': + if ($this->serverVersion >= 80000) { + $this->JSON_TABLE_SYMBOL(); // SQL-2016-R + } else { + $this->IDENTIFIER(); + } + break; + case 'JSON_ARRAYAGG': + if ($this->serverVersion >= 80000) { + $this->JSON_ARRAYAGG_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'JSON_OBJECTAGG': + if ($this->serverVersion >= 80000) { + $this->JSON_OBJECTAGG_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'KEY': + $this->KEY_SYMBOL(); + break; + case 'KEYS': + $this->KEYS_SYMBOL(); + break; + case 'KEY_BLOCK_SIZE': + $this->KEY_BLOCK_SIZE_SYMBOL(); + break; + case 'KILL': + $this->KILL_SYMBOL(); + break; + case 'LAG': + if ($this->serverVersion >= 80000) { + $this->LAG_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'LANGUAGE': + $this->LANGUAGE_SYMBOL(); + break; + case 'LAST': + $this->LAST_SYMBOL(); + break; + case 'LAST_VALUE': + if ($this->serverVersion >= 80000) { + $this->LAST_VALUE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'LATERAL': + if ($this->serverVersion >= 80014) { + $this->LATERAL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'LEAD': + if ($this->serverVersion >= 80000) { + $this->LEAD_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'LEADING': + $this->LEADING_SYMBOL(); + break; + case 'LEAVE': + $this->LEAVE_SYMBOL(); + break; + case 'LEAVES': + $this->LEAVES_SYMBOL(); + break; + case 'LEFT': + $this->LEFT_SYMBOL(); + break; + case 'LESS': + $this->LESS_SYMBOL(); + break; + case 'LEVEL': + $this->LEVEL_SYMBOL(); + break; + case 'LIKE': + $this->LIKE_SYMBOL(); + break; + case 'LIMIT': + $this->LIMIT_SYMBOL(); + break; + case 'LINEAR': + $this->LINEAR_SYMBOL(); + break; + case 'LINES': + $this->LINES_SYMBOL(); + break; + case 'LINESTRING': + $this->LINESTRING_SYMBOL(); + break; + case 'LIST': + $this->LIST_SYMBOL(); + break; + case 'LOAD': + $this->LOAD_SYMBOL(); + break; + case 'LOCAL': + $this->LOCAL_SYMBOL(); + break; + case 'LOCALTIME': + $this->NOW_SYMBOL(); // Synonym + break; + case 'LOCALTIMESTAMP': + $this->NOW_SYMBOL(); // Synonym + break; + case 'LOCATOR': + $this->LOCATOR_SYMBOL(); + break; + case 'LOCK': + $this->LOCK_SYMBOL(); + break; + case 'LOCKS': + $this->LOCKS_SYMBOL(); + break; + case 'LOGFILE': + $this->LOGFILE_SYMBOL(); + break; + case 'LOGS': + $this->LOGS_SYMBOL(); + break; + case 'LONGBLOB': + $this->LONGBLOB_SYMBOL(); + break; + case 'LONGTEXT': + $this->LONGTEXT_SYMBOL(); + break; + case 'LONG': + $this->LONG_SYMBOL(); + break; + case 'LOOP': + $this->LOOP_SYMBOL(); + break; + case 'LOW_PRIORITY': + $this->LOW_PRIORITY_SYMBOL(); + break; + case 'MASTER': + $this->MASTER_SYMBOL(); + break; + case 'MASTER_AUTO_POSITION': + if ($this->serverVersion >= 50605) { + $this->MASTER_AUTO_POSITION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_BIND': + if ($this->serverVersion >= 50602) { + $this->MASTER_BIND_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_COMPRESSION_ALGORITHM': + if ($this->serverVersion >= 80018) { + $this->MASTER_COMPRESSION_ALGORITHM_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_CONNECT_RETRY': + $this->MASTER_CONNECT_RETRY_SYMBOL(); + break; + case 'MASTER_DELAY': + $this->MASTER_DELAY_SYMBOL(); + break; + case 'MASTER_HEARTBEAT_PERIOD': + $this->MASTER_HEARTBEAT_PERIOD_SYMBOL(); + break; + case 'MASTER_HOST': + $this->MASTER_HOST_SYMBOL(); + break; + case 'MASTER_LOG_FILE': + $this->MASTER_LOG_FILE_SYMBOL(); + break; + case 'MASTER_LOG_POS': + $this->MASTER_LOG_POS_SYMBOL(); + break; + case 'MASTER_PASSWORD': + $this->MASTER_PASSWORD_SYMBOL(); + break; + case 'MASTER_PORT': + $this->MASTER_PORT_SYMBOL(); + break; + case 'MASTER_PUBLIC_KEY_PATH': + if ($this->serverVersion >= 80000) { + $this->MASTER_PUBLIC_KEY_PATH_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_RETRY_COUNT': + if ($this->serverVersion >= 50601) { + $this->MASTER_RETRY_COUNT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_SERVER_ID': + $this->MASTER_SERVER_ID_SYMBOL(); + break; + case 'MASTER_SSL': + $this->MASTER_SSL_SYMBOL(); + break; + case 'MASTER_SSL_CA': + $this->MASTER_SSL_CA_SYMBOL(); + break; + case 'MASTER_SSL_CAPATH': + $this->MASTER_SSL_CAPATH_SYMBOL(); + break; + case 'MASTER_SSL_CERT': + $this->MASTER_SSL_CERT_SYMBOL(); + break; + case 'MASTER_SSL_CIPHER': + $this->MASTER_SSL_CIPHER_SYMBOL(); + break; + case 'MASTER_SSL_CRL': + if ($this->serverVersion >= 50603) { + $this->MASTER_SSL_CRL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_SSL_CRLPATH': + if ($this->serverVersion >= 50603) { + $this->MASTER_SSL_CRLPATH_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_SSL_KEY': + $this->MASTER_SSL_KEY_SYMBOL(); + break; + case 'MASTER_SSL_VERIFY_SERVER_CERT': + $this->MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL(); + break; + case 'MASTER_TLS_CIPHERSUITES': + if ($this->serverVersion >= 80018) { + $this->MASTER_TLS_CIPHERSUITES_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_TLS_VERSION': + if ($this->serverVersion >= 50713) { + $this->MASTER_TLS_VERSION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MASTER_USER': + $this->MASTER_USER_SYMBOL(); + break; + case 'MASTER_ZSTD_COMPRESSION_LEVEL': + if ($this->serverVersion >= 80018) { + $this->MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MATCH': + $this->MATCH_SYMBOL(); + break; + case 'MAX': + $this->MAX_SYMBOL(); + break; + case 'MAX_CONNECTIONS_PER_HOUR': + $this->MAX_CONNECTIONS_PER_HOUR_SYMBOL(); + break; + case 'MAX_QUERIES_PER_HOUR': + $this->MAX_QUERIES_PER_HOUR_SYMBOL(); + break; + case 'MAX_ROWS': + $this->MAX_ROWS_SYMBOL(); + break; + case 'MAX_SIZE': + $this->MAX_SIZE_SYMBOL(); + break; + case 'MAX_STATEMENT_TIME': + if (50704 < $this->serverVersion && $this->serverVersion < 50708) { + $this->MAX_STATEMENT_TIME_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MAX_UPDATES_PER_HOUR': + $this->MAX_UPDATES_PER_HOUR_SYMBOL(); + break; + case 'MAX_USER_CONNECTIONS': + $this->MAX_USER_CONNECTIONS_SYMBOL(); + break; + case 'MAXVALUE': + $this->MAXVALUE_SYMBOL(); + break; + case 'MEDIUM': + $this->MEDIUM_SYMBOL(); + break; + case 'MEDIUMBLOB': + $this->MEDIUMBLOB_SYMBOL(); + break; + case 'MEDIUMINT': + $this->MEDIUMINT_SYMBOL(); + break; + case 'MEDIUMTEXT': + $this->MEDIUMTEXT_SYMBOL(); + break; + case 'MEMBER': + if ($this->serverVersion >= 80017) { + $this->MEMBER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'MEMORY': + $this->MEMORY_SYMBOL(); + break; + case 'MERGE': + $this->MERGE_SYMBOL(); + break; + case 'MESSAGE_TEXT': + $this->MESSAGE_TEXT_SYMBOL(); + break; + case 'MICROSECOND': + $this->MICROSECOND_SYMBOL(); + break; + case 'MIDDLEINT': + $this->MEDIUMINT_SYMBOL(); // Synonym + break; + case 'MIGRATE': + $this->MIGRATE_SYMBOL(); + break; + case 'MINUTE': + $this->MINUTE_SYMBOL(); + break; + case 'MINUTE_MICROSECOND': + $this->MINUTE_MICROSECOND_SYMBOL(); + break; + case 'MINUTE_SECOND': + $this->MINUTE_SECOND_SYMBOL(); + break; + case 'MIN': + $this->MIN_SYMBOL(); + break; + case 'MIN_ROWS': + $this->MIN_ROWS_SYMBOL(); + break; + case 'MODE': + $this->MODE_SYMBOL(); + break; + case 'MODIFIES': + $this->MODIFIES_SYMBOL(); + break; + case 'MODIFY': + $this->MODIFY_SYMBOL(); + break; + case 'MOD': + $this->MOD_SYMBOL(); + break; + case 'MONTH': + $this->MONTH_SYMBOL(); + break; + case 'MULTILINESTRING': + $this->MULTILINESTRING_SYMBOL(); + break; + case 'MULTIPOINT': + $this->MULTIPOINT_SYMBOL(); + break; + case 'MULTIPOLYGON': + $this->MULTIPOLYGON_SYMBOL(); + break; + case 'MUTEX': + $this->MUTEX_SYMBOL(); + break; + case 'MYSQL_ERRNO': + $this->MYSQL_ERRNO_SYMBOL(); + break; + case 'NAME': + $this->NAME_SYMBOL(); + break; + case 'NAMES': + $this->NAMES_SYMBOL(); + break; + case 'NATIONAL': + $this->NATIONAL_SYMBOL(); + break; + case 'NATURAL': + $this->NATURAL_SYMBOL(); + break; + case 'NCHAR': + $this->NCHAR_SYMBOL(); + break; + case 'NDB': + $this->NDBCLUSTER_SYMBOL(); // Synonym + break; + case 'NDBCLUSTER': + $this->NDBCLUSTER_SYMBOL(); + break; + case 'NETWORK_NAMESPACE': + if ($this->serverVersion >= 80017) { + $this->NETWORK_NAMESPACE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NEG': + $this->NEG_SYMBOL(); + break; + case 'NESTED': + if ($this->serverVersion >= 80000) { + $this->NESTED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NEVER': + if ($this->serverVersion >= 50704) { + $this->NEVER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NEW': + $this->NEW_SYMBOL(); + break; + case 'NEXT': + $this->NEXT_SYMBOL(); + break; + case 'NODEGROUP': + $this->NODEGROUP_SYMBOL(); + break; + case 'NONE': + $this->NONE_SYMBOL(); + break; + case 'NONBLOCKING': + if (50700 < $this->serverVersion && $this->serverVersion < 50706) { + $this->NONBLOCKING_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NOT': + $this->NOT_SYMBOL(); + break; + case 'NOW': + $this->NOW_SYMBOL(); + break; + case 'NOWAIT': + if ($this->serverVersion >= 80000) { + $this->NOWAIT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NO': + $this->NO_SYMBOL(); + break; + case 'NO_WAIT': + $this->NO_WAIT_SYMBOL(); + break; + case 'NO_WRITE_TO_BINLOG': + $this->NO_WRITE_TO_BINLOG_SYMBOL(); + break; + case 'NULL': + $this->NULL_SYMBOL(); + break; + case 'NULLS': + if ($this->serverVersion >= 80000) { + $this->NULLS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NUMBER': + if ($this->serverVersion >= 50606) { + $this->NUMBER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NUMERIC': + $this->NUMERIC_SYMBOL(); + break; + case 'NVARCHAR': + $this->NVARCHAR_SYMBOL(); + break; + case 'NTH_VALUE': + if ($this->serverVersion >= 80000) { + $this->NTH_VALUE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'NTILE': + if ($this->serverVersion >= 80000) { + $this->NTILE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OFF': + if ($this->serverVersion >= 80019) { + $this->OFF_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OF': + if ($this->serverVersion >= 80000) { + $this->OF_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OFFLINE': + $this->OFFLINE_SYMBOL(); + break; + case 'OFFSET': + $this->OFFSET_SYMBOL(); + break; + case 'OJ': + if ($this->serverVersion >= 80017) { + $this->OJ_SYMBOL(); // ODBC + } else { + $this->IDENTIFIER(); + } + break; + case 'OLD': + if ($this->serverVersion >= 80014) { + $this->OLD_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OLD_PASSWORD': + if ($this->serverVersion < 50706) { + $this->OLD_PASSWORD_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ON': + $this->ON_SYMBOL(); + break; + case 'ONE': + $this->ONE_SYMBOL(); + break; + case 'ONLINE': + $this->ONLINE_SYMBOL(); + break; + case 'ONLY': + if ($this->serverVersion >= 50605) { + $this->ONLY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OPEN': + $this->OPEN_SYMBOL(); + break; + case 'OPTIONAL': + if ($this->serverVersion >= 80013) { + $this->OPTIONAL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OPTIONALLY': + $this->OPTIONALLY_SYMBOL(); + break; + case 'OPTION': + $this->OPTION_SYMBOL(); + break; + case 'OPTIONS': + $this->OPTIONS_SYMBOL(); + break; + case 'OPTIMIZE': + $this->OPTIMIZE_SYMBOL(); + break; + case 'OPTIMIZER_COSTS': + if ($this->serverVersion >= 50706) { + $this->OPTIMIZER_COSTS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OR': + $this->OR_SYMBOL(); + break; + case 'ORDER': + $this->ORDER_SYMBOL(); + break; + case 'ORDINALITY': + if ($this->serverVersion >= 80000) { + $this->ORDINALITY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ORGANIZATION': + if ($this->serverVersion >= 80011) { + $this->ORGANIZATION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OTHERS': + if ($this->serverVersion >= 80000) { + $this->OTHERS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'OUTER': + $this->OUTER_SYMBOL(); + break; + case 'OUTFILE': + $this->OUTFILE_SYMBOL(); + break; + case 'OUT': + $this->OUT_SYMBOL(); + break; + case 'OWNER': + $this->OWNER_SYMBOL(); + break; + case 'PACK_KEYS': + $this->PACK_KEYS_SYMBOL(); + break; + case 'PAGE': + $this->PAGE_SYMBOL(); + break; + case 'PARSER': + $this->PARSER_SYMBOL(); + break; + case 'PARTIAL': + $this->PARTIAL_SYMBOL(); + break; + case 'PARTITION': + $this->PARTITION_SYMBOL(); + break; + case 'PARTITIONING': + $this->PARTITIONING_SYMBOL(); + break; + case 'PARTITIONS': + $this->PARTITIONS_SYMBOL(); + break; + case 'PASSWORD': + $this->PASSWORD_SYMBOL(); + break; + case 'PASSWORD_LOCK_TIME': + if ($this->serverVersion >= 80019) { + $this->PASSWORD_LOCK_TIME_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PATH': + if ($this->serverVersion >= 80000) { + $this->PATH_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PERCENT_RANK': + if ($this->serverVersion >= 80000) { + $this->PERCENT_RANK_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PERSIST': + if ($this->serverVersion >= 80000) { + $this->PERSIST_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PERSIST_ONLY': + if ($this->serverVersion >= 80000) { + $this->PERSIST_ONLY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PHASE': + $this->PHASE_SYMBOL(); + break; + case 'PLUGIN': + $this->PLUGIN_SYMBOL(); + break; + case 'PLUGINS': + $this->PLUGINS_SYMBOL(); + break; + case 'PLUGIN_DIR': + if ($this->serverVersion >= 50604) { + $this->PLUGIN_DIR_SYMBOL(); // Internal + } else { + $this->IDENTIFIER(); + } + break; + case 'POINT': + $this->POINT_SYMBOL(); + break; + case 'POLYGON': + $this->POLYGON_SYMBOL(); + break; + case 'PORT': + $this->PORT_SYMBOL(); + break; + case 'POSITION': + $this->POSITION_SYMBOL(); + break; + case 'PRECEDES': + if ($this->serverVersion >= 50700) { + $this->PRECEDES_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PRECEDING': + if ($this->serverVersion >= 80000) { + $this->PRECEDING_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PRECISION': + $this->PRECISION_SYMBOL(); + break; + case 'PREPARE': + $this->PREPARE_SYMBOL(); + break; + case 'PRESERVE': + $this->PRESERVE_SYMBOL(); + break; + case 'PREV': + $this->PREV_SYMBOL(); + break; + case 'PRIMARY': + $this->PRIMARY_SYMBOL(); + break; + case 'PRIVILEGE_CHECKS_USER': + if ($this->serverVersion >= 80018) { + $this->PRIVILEGE_CHECKS_USER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'PRIVILEGES': + $this->PRIVILEGES_SYMBOL(); + break; + case 'PROCEDURE': + $this->PROCEDURE_SYMBOL(); + break; + case 'PROCESS': + $this->PROCESS_SYMBOL(); + break; + case 'PROCESSLIST': + $this->PROCESSLIST_SYMBOL(); + break; + case 'PROFILE': + $this->PROFILE_SYMBOL(); + break; + case 'PROFILES': + $this->PROFILES_SYMBOL(); + break; + case 'PROXY': + $this->PROXY_SYMBOL(); + break; + case 'PURGE': + $this->PURGE_SYMBOL(); + break; + case 'QUARTER': + $this->QUARTER_SYMBOL(); + break; + case 'QUERY': + $this->QUERY_SYMBOL(); + break; + case 'QUICK': + $this->QUICK_SYMBOL(); + break; + case 'RANDOM': + if ($this->serverVersion >= 80018) { + $this->RANDOM_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RANGE': + $this->RANGE_SYMBOL(); + break; + case 'RANK': + if ($this->serverVersion >= 80000) { + $this->RANK_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'READ': + $this->READ_SYMBOL(); + break; + case 'READS': + $this->READS_SYMBOL(); + break; + case 'READ_ONLY': + $this->READ_ONLY_SYMBOL(); + break; + case 'READ_WRITE': + $this->READ_WRITE_SYMBOL(); + break; + case 'REAL': + $this->REAL_SYMBOL(); + break; + case 'REBUILD': + $this->REBUILD_SYMBOL(); + break; + case 'RECOVER': + $this->RECOVER_SYMBOL(); + break; + case 'RECURSIVE': + if ($this->serverVersion >= 80000) { + $this->RECURSIVE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REDOFILE': + if ($this->serverVersion < 80000) { + $this->REDOFILE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REDO_BUFFER_SIZE': + $this->REDO_BUFFER_SIZE_SYMBOL(); + break; + case 'REDUNDANT': + $this->REDUNDANT_SYMBOL(); + break; + case 'REFERENCE': + if ($this->serverVersion >= 80011) { + $this->REFERENCE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REFERENCES': + $this->REFERENCES_SYMBOL(); + break; + case 'REGEXP': + $this->REGEXP_SYMBOL(); + break; + case 'RELAY': + $this->RELAY_SYMBOL(); + break; + case 'RELAYLOG': + $this->RELAYLOG_SYMBOL(); + break; + case 'RELAY_LOG_FILE': + $this->RELAY_LOG_FILE_SYMBOL(); + break; + case 'RELAY_LOG_POS': + $this->RELAY_LOG_POS_SYMBOL(); + break; + case 'RELAY_THREAD': + $this->RELAY_THREAD_SYMBOL(); + break; + case 'RELEASE': + $this->RELEASE_SYMBOL(); + break; + case 'RELOAD': + $this->RELOAD_SYMBOL(); + break; + case 'REMOTE': + if ($this->serverVersion >= 80003 && $this->serverVersion < 80014) { + $this->REMOTE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REMOVE': + $this->REMOVE_SYMBOL(); + break; + case 'RENAME': + $this->RENAME_SYMBOL(); + break; + case 'REORGANIZE': + $this->REORGANIZE_SYMBOL(); + break; + case 'REPAIR': + $this->REPAIR_SYMBOL(); + break; + case 'REPEAT': + $this->REPEAT_SYMBOL(); + break; + case 'REPEATABLE': + $this->REPEATABLE_SYMBOL(); + break; + case 'REPLACE': + $this->REPLACE_SYMBOL(); + break; + case 'REPLICATION': + $this->REPLICATION_SYMBOL(); + break; + case 'REPLICATE_DO_DB': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_DO_DB_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_IGNORE_DB': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_IGNORE_DB_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_DO_TABLE': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_DO_TABLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_IGNORE_TABLE': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_IGNORE_TABLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_WILD_DO_TABLE': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_WILD_DO_TABLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_WILD_IGNORE_TABLE': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_WILD_IGNORE_TABLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REPLICATE_REWRITE_DB': + if ($this->serverVersion >= 50700) { + $this->REPLICATE_REWRITE_DB_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REQUIRE': + $this->REQUIRE_SYMBOL(); + break; + case 'REQUIRE_ROW_FORMAT': + if ($this->serverVersion >= 80019) { + $this->REQUIRE_ROW_FORMAT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REQUIRE_TABLE_PRIMARY_KEY_CHECK': + if ($this->serverVersion >= 80019) { + $this->REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RESOURCE': + if ($this->serverVersion >= 80000) { + $this->RESOURCE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RESPECT': + if ($this->serverVersion >= 80000) { + $this->RESPECT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RESTART': + if ($this->serverVersion >= 80011) { + $this->RESTART_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RESTORE': + $this->RESTORE_SYMBOL(); + break; + case 'RESTRICT': + $this->RESTRICT_SYMBOL(); + break; + case 'RESUME': + $this->RESUME_SYMBOL(); + break; + case 'RETAIN': + if ($this->serverVersion >= 80014) { + $this->RETAIN_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RETURNED_SQLSTATE': + $this->RETURNED_SQLSTATE_SYMBOL(); + break; + case 'RETURNS': + $this->RETURNS_SYMBOL(); + break; + case 'RETURN': + $this->RETURN_SYMBOL(); + break; + case 'REUSE': + if ($this->serverVersion >= 80000) { + $this->REUSE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'REVERSE': + $this->REVERSE_SYMBOL(); + break; + case 'REVOKE': + $this->REVOKE_SYMBOL(); + break; + case 'RIGHT': + $this->RIGHT_SYMBOL(); + break; + case 'RLIKE': + $this->REGEXP_SYMBOL(); // Synonym + break; + case 'ROLE': + if ($this->serverVersion >= 80000) { + $this->ROLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ROLLBACK': + $this->ROLLBACK_SYMBOL(); + break; + case 'ROLLUP': + $this->ROLLUP_SYMBOL(); + break; + case 'ROTATE': + if ($this->serverVersion >= 50713) { + $this->ROTATE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ROW': + if ($this->serverVersion < 80000) { + $this->ROW_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ROWS': + if ($this->serverVersion < 80000) { + $this->ROWS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'ROW_COUNT': + $this->ROW_COUNT_SYMBOL(); + break; + case 'ROW_FORMAT': + $this->ROW_FORMAT_SYMBOL(); + break; + case 'ROW_NUMBER': + if ($this->serverVersion >= 80000) { + $this->ROW_NUMBER_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'RTREE': + $this->RTREE_SYMBOL(); + break; + case 'SAVEPOINT': + $this->SAVEPOINT_SYMBOL(); + break; + case 'SCHEDULE': + $this->SCHEDULE_SYMBOL(); + break; + case 'SCHEMA': + $this->DATABASE_SYMBOL(); // Synonym + break; + case 'SCHEMAS': + $this->DATABASES_SYMBOL(); // Synonym + break; + case 'SCHEMA_NAME': + $this->SCHEMA_NAME_SYMBOL(); + break; + case 'SECOND': + $this->SECOND_SYMBOL(); + break; + case 'SECOND_MICROSECOND': + $this->SECOND_MICROSECOND_SYMBOL(); + break; + case 'SECONDARY': + if ($this->serverVersion >= 80013) { + $this->SECONDARY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SECONDARY_ENGINE': + if ($this->serverVersion >= 80013) { + $this->SECONDARY_ENGINE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SECONDARY_LOAD': + if ($this->serverVersion >= 80013) { + $this->SECONDARY_LOAD_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SECONDARY_UNLOAD': + if ($this->serverVersion >= 80013) { + $this->SECONDARY_UNLOAD_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SECURITY': + $this->SECURITY_SYMBOL(); + break; + case 'SELECT': + $this->SELECT_SYMBOL(); + break; + case 'SENSITIVE': + $this->SENSITIVE_SYMBOL(); + break; + case 'SEPARATOR': + $this->SEPARATOR_SYMBOL(); + break; + case 'SERIALIZABLE': + $this->SERIALIZABLE_SYMBOL(); + break; + case 'SERIAL': + $this->SERIAL_SYMBOL(); + break; + case 'SERVER': + $this->SERVER_SYMBOL(); + break; + case 'SERVER_OPTIONS': + $this->SERVER_OPTIONS_SYMBOL(); + break; + case 'SESSION': + $this->SESSION_SYMBOL(); + break; + case 'SESSION_USER': + $this->USER_SYMBOL(); // Synonym + break; + case 'SET': + $this->SET_SYMBOL(); + break; + case 'SET_VAR': + $this->SET_VAR_SYMBOL(); + break; + case 'SHARE': + $this->SHARE_SYMBOL(); + break; + case 'SHOW': + $this->SHOW_SYMBOL(); + break; + case 'SHUTDOWN': + if ($this->serverVersion < 50709) { + $this->SHUTDOWN_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SIGNAL': + $this->SIGNAL_SYMBOL(); + break; + case 'SIGNED': + $this->SIGNED_SYMBOL(); + break; + case 'SIMPLE': + $this->SIMPLE_SYMBOL(); + break; + case 'SKIP': + if ($this->serverVersion >= 80000) { + $this->SKIP_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SLAVE': + $this->SLAVE_SYMBOL(); + break; + case 'SLOW': + $this->SLOW_SYMBOL(); + break; + case 'SMALLINT': + $this->SMALLINT_SYMBOL(); + break; + case 'SNAPSHOT': + $this->SNAPSHOT_SYMBOL(); + break; + case 'SOME': + $this->ANY_SYMBOL(); // Synonym + break; + case 'SOCKET': + $this->SOCKET_SYMBOL(); + break; + case 'SONAME': + $this->SONAME_SYMBOL(); + break; + case 'SOUNDS': + $this->SOUNDS_SYMBOL(); + break; + case 'SOURCE': + $this->SOURCE_SYMBOL(); + break; + case 'SPATIAL': + $this->SPATIAL_SYMBOL(); + break; + case 'SPECIFIC': + $this->SPECIFIC_SYMBOL(); + break; + case 'SQL': + $this->SQL_SYMBOL(); + break; + case 'SQLEXCEPTION': + $this->SQLEXCEPTION_SYMBOL(); + break; + case 'SQLSTATE': + $this->SQLSTATE_SYMBOL(); + break; + case 'SQLWARNING': + $this->SQLWARNING_SYMBOL(); + break; + case 'SQL_AFTER_GTIDS': + $this->SQL_AFTER_GTIDS_SYMBOL(); + break; + case 'SQL_AFTER_MTS_GAPS': + if ($this->serverVersion >= 50606) { + $this->SQL_AFTER_MTS_GAPS_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SQL_BEFORE_GTIDS': + $this->SQL_BEFORE_GTIDS_SYMBOL(); + break; + case 'SQL_BIG_RESULT': + $this->SQL_BIG_RESULT_SYMBOL(); + break; + case 'SQL_BUFFER_RESULT': + $this->SQL_BUFFER_RESULT_SYMBOL(); + break; + case 'SQL_CALC_FOUND_ROWS': + $this->SQL_CALC_FOUND_ROWS_SYMBOL(); + break; + case 'SQL_CACHE': + if ($this->serverVersion < 80000) { + $this->SQL_CACHE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SQL_NO_CACHE': + $this->SQL_NO_CACHE_SYMBOL(); + break; + case 'SQL_SMALL_RESULT': + $this->SQL_SMALL_RESULT_SYMBOL(); + break; + case 'SQL_THREAD': + $this->SQL_THREAD_SYMBOL(); + break; + case 'SQL_TSI_SECOND': + $this->SECOND_SYMBOL(); // Synonym + break; + case 'SQL_TSI_MINUTE': + $this->MINUTE_SYMBOL(); // Synonym + break; + case 'SQL_TSI_HOUR': + $this->HOUR_SYMBOL(); // Synonym + break; + case 'SQL_TSI_DAY': + $this->DAY_SYMBOL(); // Synonym + break; + case 'SQL_TSI_WEEK': + $this->WEEK_SYMBOL(); // Synonym + break; + case 'SQL_TSI_MONTH': + $this->MONTH_SYMBOL(); // Synonym + break; + case 'SQL_TSI_QUARTER': + $this->QUARTER_SYMBOL(); // Synonym + break; + case 'SQL_TSI_YEAR': + $this->YEAR_SYMBOL(); // Synonym + break; + case 'SRID': + if ($this->serverVersion >= 80000) { + $this->SRID_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SSL': + $this->SSL_SYMBOL(); + break; + case 'STACKED': + if ($this->serverVersion >= 50700) { + $this->STACKED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'STARTING': + $this->STARTING_SYMBOL(); + break; + case 'STARTS': + $this->STARTS_SYMBOL(); + break; + case 'START': + $this->START_SYMBOL(); + break; + case 'STATS_AUTO_RECALC': + $this->STATS_AUTO_RECALC_SYMBOL(); + break; + case 'STATS_PERSISTENT': + $this->STATS_PERSISTENT_SYMBOL(); + break; + case 'STATS_SAMPLE_PAGES': + $this->STATS_SAMPLE_PAGES_SYMBOL(); + break; + case 'STATUS': + $this->STATUS_SYMBOL(); + break; + case 'STD': + $this->STD_SYMBOL(); + break; + case 'STDDEV': + $this->STD_SYMBOL(); // Synonym + break; + case 'STDDEV_POP': + $this->STD_SYMBOL(); // Synonym + break; + case 'STDDEV_SAMP': + $this->STDDEV_SAMP_SYMBOL(); + break; + case 'STOP': + $this->STOP_SYMBOL(); + break; + case 'STORAGE': + $this->STORAGE_SYMBOL(); + break; + case 'STORED': + if ($this->serverVersion >= 50707) { + $this->STORED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'STRAIGHT_JOIN': + $this->STRAIGHT_JOIN_SYMBOL(); + break; + case 'STREAM': + if ($this->serverVersion >= 80019) { + $this->STREAM_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'STRING': + $this->STRING_SYMBOL(); + break; + case 'SUBCLASS_ORIGIN': + $this->SUBCLASS_ORIGIN_SYMBOL(); + break; + case 'SUBDATE': + $this->SUBDATE_SYMBOL(); + break; + case 'SUBJECT': + $this->SUBJECT_SYMBOL(); + break; + case 'SUBPARTITION': + $this->SUBPARTITION_SYMBOL(); + break; + case 'SUBPARTITIONS': + $this->SUBPARTITIONS_SYMBOL(); + break; + case 'SUBSTR': + $this->SUBSTRING_SYMBOL(); // Synonym + break; + case 'SUBSTRING': + $this->SUBSTRING_SYMBOL(); + break; + case 'SUM': + $this->SUM_SYMBOL(); + break; + case 'SUPER': + $this->SUPER_SYMBOL(); + break; + case 'SUSPEND': + $this->SUSPEND_SYMBOL(); + break; + case 'SWAPS': + $this->SWAPS_SYMBOL(); + break; + case 'SWITCHES': + $this->SWITCHES_SYMBOL(); + break; + case 'SYSDATE': + $this->SYSDATE_SYMBOL(); + break; + case 'SYSTEM': + if ($this->serverVersion >= 80000) { + $this->SYSTEM_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'SYSTEM_USER': + $this->USER_SYMBOL(); // Synonym + break; + case 'TABLE': + $this->TABLE_SYMBOL(); + break; + case 'TABLES': + $this->TABLES_SYMBOL(); + break; + case 'TABLESPACE': + $this->TABLESPACE_SYMBOL(); + break; + case 'TABLE_CHECKSUM': + $this->TABLE_CHECKSUM_SYMBOL(); + break; + case 'TABLE_NAME': + $this->TABLE_NAME_SYMBOL(); + break; + case 'TEMPORARY': + $this->TEMPORARY_SYMBOL(); + break; + case 'TEMPTABLE': + $this->TEMPTABLE_SYMBOL(); + break; + case 'TERMINATED': + $this->TERMINATED_SYMBOL(); + break; + case 'TEXT': + $this->TEXT_SYMBOL(); + break; + case 'THAN': + $this->THAN_SYMBOL(); + break; + case 'THEN': + $this->THEN_SYMBOL(); + break; + case 'THREAD_PRIORITY': + if ($this->serverVersion >= 80000) { + $this->THREAD_PRIORITY_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'TIES': + if ($this->serverVersion >= 80000) { + $this->TIES_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'TIME': + $this->TIME_SYMBOL(); + break; + case 'TIMESTAMP': + $this->TIMESTAMP_SYMBOL(); + break; + case 'TIMESTAMPADD': + $this->TIMESTAMP_ADD_SYMBOL(); + break; + case 'TIMESTAMPDIFF': + $this->TIMESTAMP_DIFF_SYMBOL(); + break; + case 'TINYBLOB': + $this->TINYBLOB_SYMBOL(); + break; + case 'TINYINT': + $this->TINYINT_SYMBOL(); + break; + case 'TINYTEXT': + $this->TINYTEXT_SYMBOL(); + break; + case 'TO': + $this->TO_SYMBOL(); + break; + case 'TRAILING': + $this->TRAILING_SYMBOL(); + break; + case 'TRANSACTION': + $this->TRANSACTION_SYMBOL(); + break; + case 'TRIGGER': + $this->TRIGGER_SYMBOL(); + break; + case 'TRIGGERS': + $this->TRIGGERS_SYMBOL(); + break; + case 'TRIM': + $this->TRIM_SYMBOL(); + break; + case 'TRUE': + $this->TRUE_SYMBOL(); + break; + case 'TRUNCATE': + $this->TRUNCATE_SYMBOL(); + break; + case 'TYPES': + $this->TYPES_SYMBOL(); + break; + case 'TYPE': + $this->TYPE_SYMBOL(); + break; + case 'UDF_RETURNS': + $this->UDF_RETURNS_SYMBOL(); + break; + case 'UNBOUNDED': + if ($this->serverVersion >= 80000) { + $this->UNBOUNDED_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'UNCOMMITTED': + $this->UNCOMMITTED_SYMBOL(); + break; + case 'UNDEFINED': + $this->UNDEFINED_SYMBOL(); + break; + case 'UNDO': + $this->UNDO_SYMBOL(); + break; + case 'UNDO_BUFFER_SIZE': + $this->UNDO_BUFFER_SIZE_SYMBOL(); + break; + case 'UNDOFILE': + $this->UNDOFILE_SYMBOL(); + break; + case 'UNICODE': + $this->UNICODE_SYMBOL(); + break; + case 'UNION': + $this->UNION_SYMBOL(); + break; + case 'UNIQUE': + $this->UNIQUE_SYMBOL(); + break; + case 'UNKNOWN': + $this->UNKNOWN_SYMBOL(); + break; + case 'UNINSTALL': + $this->UNINSTALL_SYMBOL(); + break; + case 'UNSIGNED': + $this->UNSIGNED_SYMBOL(); + break; + case 'UPDATE': + $this->UPDATE_SYMBOL(); + break; + case 'UPGRADE': + $this->UPGRADE_SYMBOL(); + break; + case 'USAGE': + $this->USAGE_SYMBOL(); + break; + case 'USER': + $this->USER_SYMBOL(); + break; + case 'USER_RESOURCES': + $this->USER_RESOURCES_SYMBOL(); + break; + case 'USE': + $this->USE_SYMBOL(); + break; + case 'USE_FRM': + $this->USE_FRM_SYMBOL(); + break; + case 'USING': + $this->USING_SYMBOL(); + break; + case 'UTC_DATE': + $this->UTC_DATE_SYMBOL(); + break; + case 'UTC_TIME': + $this->UTC_TIME_SYMBOL(); + break; + case 'UTC_TIMESTAMP': + $this->UTC_TIMESTAMP_SYMBOL(); + break; + case 'VALIDATION': + if ($this->serverVersion >= 50706) { + $this->VALIDATION_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'VALUE': + $this->VALUE_SYMBOL(); + break; + case 'VALUES': + $this->VALUES_SYMBOL(); + break; + case 'VARBINARY': + $this->VARBINARY_SYMBOL(); + break; + case 'VARCHAR': + $this->VARCHAR_SYMBOL(); + break; + case 'VARCHARACTER': + $this->VARCHAR_SYMBOL(); // Synonym + break; + case 'VARIABLES': + $this->VARIABLES_SYMBOL(); + break; + case 'VARIANCE': + $this->VARIANCE_SYMBOL(); + break; + case 'VARYING': + $this->VARYING_SYMBOL(); + break; + case 'VAR_POP': + $this->VARIANCE_SYMBOL(); // Synonym + break; + case 'VAR_SAMP': + $this->VAR_SAMP_SYMBOL(); + break; + case 'VCPU': + if ($this->serverVersion >= 80000) { + $this->VCPU_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'VIEW': + $this->VIEW_SYMBOL(); + break; + case 'VIRTUAL': + if ($this->serverVersion >= 50707) { + $this->VIRTUAL_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'VISIBLE': + if ($this->serverVersion >= 80000) { + $this->VISIBLE_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'WAIT': + $this->WAIT_SYMBOL(); + break; + case 'WARNINGS': + $this->WARNINGS_SYMBOL(); + break; + case 'WEEK': + $this->WEEK_SYMBOL(); + break; + case 'WHEN': + $this->WHEN_SYMBOL(); + break; + case 'WEIGHT_STRING': + $this->WEIGHT_STRING_SYMBOL(); + break; + case 'WHERE': + $this->WHERE_SYMBOL(); + break; + case 'WHILE': + $this->WHILE_SYMBOL(); + break; + case 'WINDOW': + if ($this->serverVersion >= 80000) { + $this->WINDOW_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'WITH': + $this->WITH_SYMBOL(); + break; + case 'WITHOUT': + if ($this->serverVersion >= 80000) { + $this->WITHOUT_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'WORK': + $this->WORK_SYMBOL(); + break; + case 'WRAPPER': + $this->WRAPPER_SYMBOL(); + break; + case 'WRITE': + $this->WRITE_SYMBOL(); + break; + case 'XA': + $this->XA_SYMBOL(); + break; + case 'X509': + $this->X509_SYMBOL(); + break; + case 'XID': + if ($this->serverVersion >= 50704) { + $this->XID_SYMBOL(); + } else { + $this->IDENTIFIER(); + } + break; + case 'XML': + $this->XML_SYMBOL(); + break; + case 'XOR': + $this->XOR_SYMBOL(); + break; + case 'YEAR': + $this->YEAR_SYMBOL(); + break; + case 'YEAR_MONTH': + $this->YEAR_MONTH_SYMBOL(); + break; + case 'ZEROFILL': + $this->ZEROFILL_SYMBOL(); + break; + case 'INT1': + $this->INT1_SYMBOL(); + break; + case 'INT2': + $this->INT2_SYMBOL(); + break; + case 'INT3': + $this->INT3_SYMBOL(); + break; + case 'INT4': + $this->INT4_SYMBOL(); + break; + case 'INT8': + $this->INT8_SYMBOL(); + break; + default: + // Not a keyword, emit as identifier. + $this->IDENTIFIER(); + } + } + + protected function blockComment() + { + $this->consume(); // Consume the '/'. + $this->consume(); // Consume the '*'. + + // If the next character is '!', it could be a version comment. + if ($this->c === '!') { + $this->consume(); // Consume the '!'. + + // If the next character is a digit, it's a version comment. + if (safe_ctype_digit($this->c)) { + // Consume all digits. + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + + // Check if the version comment is active for the current server version. + if ($this->checkVersion($this->getText())) { + // If it's active, treat the content as regular SQL code. + $this->MYSQL_COMMENT_START(); + $this->sqlCodeInComment(); + } else { + // If it's not active, skip the comment content. + $this->skipCommentContent(); + } + } else { + // If it's not a version comment, treat it as a regular multi-line comment. + $this->MYSQL_COMMENT_START(); + $this->skipCommentContent(); + } + } else { + // If the next character is not '!', it's a regular multi-line comment. + $this->skipCommentContent(); + } + + // Set the channel to HIDDEN for block comments. + $this->channel = self::HIDDEN; + } + + protected function skipCommentContent(): void + { + while ($this->c !== null) { + if ($this->c === '*' && $this->n === '/') { + $this->consume(); // Consume the '*'. + $this->consume(); // Consume the '/'. + break; + } + $this->consume(); + } + } + + protected function sqlCodeInComment(): void + { + $this->skipCommentContent(); + $this->VERSION_COMMENT_END(); + } + + protected function DOT_IDENTIFIER() + { + $this->consume(); // Consume the '.'. + $this->IDENTIFIER(); + $this->setType(self::DOT_SYMBOL);//@TODO: DOT_IDENTIFIER); + } + + protected function NUMBER() + { + if ($this->c === '0' && $this->n === 'x') { + $this->HEX_NUMBER(); + } elseif ($this->c === '0' && $this->n === 'b') { + $this->BIN_NUMBER(); + } elseif ($this->c === '.' && safe_ctype_digit($this->LA(2))) { + $this->DECIMAL_NUMBER(); + } else { + $this->INT_NUMBER(); + + if ($this->c === '.') { + $this->consume(); + + if (safe_ctype_digit($this->c)) { + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + + if ($this->c === 'e' || $this->c === 'E') { + $this->consume(); + if ($this->c === '+' || $this->c === '-') { + $this->consume(); + } + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + $this->setType(self::FLOAT_NUMBER); + } else { + $this->setType(self::DECIMAL_NUMBER); + } + } else { + // If there is no digit after the '.', it's a DOT_IDENTIFIER. + $this->emitDot(); + $this->setType(self::IDENTIFIER); + } + } elseif ($this->c === 'e' || $this->c === 'E') { + $this->consume(); + if ($this->c === '+' || $this->c === '-') { + $this->consume(); + } + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + $this->setType(self::FLOAT_NUMBER); + } + } + } + + protected function SINGLE_QUOTED_TEXT() + { + do { + $this->consume(); // Consume the first single quote. + while ($this->c !== null) { + if ($this->c === '\\' && !$this->isSqlModeActive(MySQLLexer::NoBackslashEscapes)) { + // If it's an escape sequence, consume the backslash and the next character. + $this->consume(); + $this->consume(); + } elseif ($this->c === "'") { + $this->consume(); // Consume the second single quote. + break; + } else { + $this->consume(); + } + } + } while ($this->c === "'"); // Continue if there's another single quote. + + $this->setType(self::SINGLE_QUOTED_TEXT); + } + + protected function DOUBLE_QUOTED_TEXT() + { + do { + $this->consume(); // Consume the first double quote. + while ($this->c !== null) { + if ($this->c === '\\' && !$this->isSqlModeActive(MySQLLexer::NoBackslashEscapes)) { + // If it's an escape sequence, consume the backslash and the next character. + $this->consume(); + $this->consume(); + } elseif ($this->c === '"') { + $this->consume(); // Consume the second double quote. + break; + } else { + $this->consume(); + } + } + } while ($this->c === '"'); // Continue if there's another double quote. + + $this->setType(self::DOUBLE_QUOTED_TEXT); + } + + protected function BACK_TICK_QUOTED_ID() + { + $this->consume(); // Consume the first back tick. + while ($this->c !== null) { + if ($this->c === '\\' && !$this->isSqlModeActive(MySQLLexer::NoBackslashEscapes)) { + // If it's an escape sequence, consume the backslash and the next character. + $this->consume(); + $this->consume(); + } elseif ($this->c === '`') { + $this->consume(); // Consume the second back tick. + break; + } else { + $this->consume(); + } + } + + $this->setType(self::BACK_TICK_QUOTED_ID); + } + + protected function HEX_NUMBER() + { + $this->consume(); // Consume the '0'. + $this->consume(); // Consume the 'x'. + while (ctype_xdigit($this->c)) { + $this->consume(); + } + $this->setType(self::HEX_NUMBER); + } + + protected function BIN_NUMBER() + { + $this->consume(); // Consume the '0'. + $this->consume(); // Consume the 'b'. + while ($this->c === '0' || $this->c === '1') { + $this->consume(); + } + $this->setType(self::BIN_NUMBER); + } + + protected function INT_NUMBER() + { + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + $this->setType(self::DECIMAL_NUMBER); + } + + protected function DECIMAL_NUMBER() + { + $this->consume(); // Consume the '.'. + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + $this->setType(self::DECIMAL_NUMBER); + } + + protected function FLOAT_NUMBER() + { + // This rule is never actually called, as FLOAT_NUMBER tokens are emitted by NUMBER(). + throw new \BadMethodCallException('FLOAT_NUMBER() should never be called directly.'); + } + + protected function EQUAL_OPERATOR() + { + $this->consume(); + $this->setType(self::EQUAL_OPERATOR); + } + + protected function ASSIGN_OPERATOR() + { + $this->consume(); // Consume the ':'. + $this->consume(); // Consume the '='. + $this->setType(self::ASSIGN_OPERATOR); + } + + protected function NULL_SAFE_EQUAL_OPERATOR() + { + $this->consume(); // Consume the '<'. + $this->consume(); // Consume the '='. + $this->consume(); // Consume the '>'. + $this->setType(self::NULL_SAFE_EQUAL_OPERATOR); + } + + protected function GREATER_OR_EQUAL_OPERATOR() + { + $this->consume(); // Consume the '>'. + $this->consume(); // Consume the '='. + $this->setType(self::GREATER_OR_EQUAL_OPERATOR); + } + + protected function GREATER_THAN_OPERATOR() + { + $this->consume(); + $this->setType(self::GREATER_THAN_OPERATOR); + } + + protected function LESS_OR_EQUAL_OPERATOR() + { + $this->consume(); // Consume the '<'. + $this->consume(); // Consume the '='. + $this->setType(self::LESS_OR_EQUAL_OPERATOR); + } + + protected function LESS_THAN_OPERATOR() + { + $this->consume(); + $this->setType(self::LESS_THAN_OPERATOR); + } + + protected function NOT_EQUAL_OPERATOR() + { + $this->consume(); // Consume the '!'. + $this->consume(); // Consume the '='. + $this->setType(self::NOT_EQUAL_OPERATOR); + } + + protected function NOT_EQUAL2_OPERATOR() + { + $this->consume(); // Consume the '<'. + $this->consume(); // Consume the '>'. + $this->setType(self::NOT_EQUAL_OPERATOR); + } + + protected function PLUS_OPERATOR() + { + $this->consume(); + $this->setType(self::PLUS_OPERATOR); + } + + protected function MINUS_OPERATOR() + { + $this->consume(); + $this->setType(self::MINUS_OPERATOR); + } + + protected function MULT_OPERATOR() + { + $this->consume(); + $this->setType(self::MULT_OPERATOR); + } + + protected function DIV_OPERATOR() + { + $this->consume(); + $this->setType(self::DIV_OPERATOR); + } + + protected function MOD_OPERATOR() + { + $this->consume(); + $this->setType(self::MOD_OPERATOR); + } + + protected function LOGICAL_NOT_OPERATOR() + { + $this->consume(); + $this->setType(self::LOGICAL_NOT_OPERATOR); + } + + protected function BITWISE_NOT_OPERATOR() + { + $this->consume(); + $this->setType(self::BITWISE_NOT_OPERATOR); + } + + protected function SHIFT_LEFT_OPERATOR() + { + $this->consume(); // Consume the '<'. + $this->consume(); // Consume the '<'. + $this->setType(self::SHIFT_LEFT_OPERATOR); + } + + protected function SHIFT_RIGHT_OPERATOR() + { + $this->consume(); // Consume the '>'. + $this->consume(); // Consume the '>'. + $this->setType(self::SHIFT_RIGHT_OPERATOR); + } + + protected function LOGICAL_AND_OPERATOR() + { + $this->consume(); // Consume the '&'. + $this->consume(); // Consume the '&'. + $this->setType(self::LOGICAL_AND_OPERATOR); + } + + protected function BITWISE_AND_OPERATOR() + { + $this->consume(); + $this->setType(self::BITWISE_AND_OPERATOR); + } + + protected function BITWISE_XOR_OPERATOR() + { + $this->consume(); + $this->setType(self::BITWISE_XOR_OPERATOR); + } + + protected function LOGICAL_OR_OPERATOR() + { + $this->consume(); // Consume the '|'. + $this->consume(); // Consume the '|'. + + if ($this->isSqlModeActive(MySQLLexer::PipesAsConcat)) { + $this->setType(self::CONCAT_PIPES_SYMBOL); + } else { + $this->setType(self::LOGICAL_OR_OPERATOR); + } + } + + protected function BITWISE_OR_OPERATOR() + { + $this->consume(); + $this->setType(self::BITWISE_OR_OPERATOR); + } + + protected function DOT_SYMBOL() + { + $this->consume(); + $this->setType(self::DOT_SYMBOL); + } + + protected function COMMA_SYMBOL() + { + $this->consume(); + $this->setType(self::COMMA_SYMBOL); + } + + protected function SEMICOLON_SYMBOL() + { + $this->consume(); + $this->setType(self::SEMICOLON_SYMBOL); + } + + protected function COLON_SYMBOL() + { + $this->consume(); + $this->setType(self::COLON_SYMBOL); + } + + protected function OPEN_PAR_SYMBOL() + { + $this->consume(); + $this->setType(self::OPEN_PAR_SYMBOL); + } + + protected function CLOSE_PAR_SYMBOL() + { + $this->consume(); + $this->setType(self::CLOSE_PAR_SYMBOL); + } + + protected function OPEN_CURLY_SYMBOL() + { + $this ->consume(); + $this->setType(self::OPEN_CURLY_SYMBOL); + } + + protected function CLOSE_CURLY_SYMBOL() + { + $this->consume(); + $this->setType(self::CLOSE_CURLY_SYMBOL); + } + + protected function UNDERLINE_SYMBOL() + { + $this->consume(); + + if (safe_ctype_alpha($this->LA(1))) { + // If the next character is a letter, it's a charset. + while (ctype_alnum($this->LA(1))) { + $this->consume(); + } + + $this->setType($this->checkCharset($this->getText())); + } else { + $this->setType(self::UNDERLINE_SYMBOL); + } + } + + protected function JSON_SEPARATOR_SYMBOL() + { + if ($this->serverVersion >= 50708) { + $this->consume(); // Consume the '-'. + $this->consume(); // Consume the '>'. + $this->setType(self::JSON_SEPARATOR_SYMBOL); + } else { + $this->setType(self::INVALID_INPUT); + } + } + + protected function JSON_UNQUOTED_SEPARATOR_SYMBOL() + { + if ($this->serverVersion >= 50713) { + $this->consume(); // Consume the '-'. + $this->consume(); // Consume the '>'. + $this->consume(); // Consume the '>'. + $this->setType(self::JSON_UNQUOTED_SEPARATOR_SYMBOL); + } else { + $this->setType(self::INVALID_INPUT); + } + } + + protected function AT_SIGN_SYMBOL() + { + $this->consume(); + $this->setType(self::AT_SIGN_SYMBOL); + } + + protected function AT_AT_SIGN_SYMBOL() + { + $this->consume(); // Consume the '@'. + $this->consume(); // Consume the '@'. + $this->setType(self::AT_AT_SIGN_SYMBOL); + } + + protected function NULL2_SYMBOL() + { + $this->consume(); // Consume the '\'. + $this->consume(); // Consume the 'N'. + $this->setType(self::NULL2_SYMBOL); + } + + protected function PARAM_MARKER() + { + $this->consume(); + $this->setType(self::PARAM_MARKER); + } + + protected function WHITESPACE() + { + while (safe_ctype_space($this->c)) { + $this->consume(); + } + + $this->channel = self::HIDDEN; + } + + protected function INVALID_INPUT() + { + $this->consume(); + $this->setType(self::INVALID_INPUT); + } + + protected function POUND_COMMENT() + { + $this->consume(); + + while ($this->c !== null) { + if ($this->c === "\n" || $this->c === "\r") { + break; + } + $this->consume(); + } + + $this->channel = self::HIDDEN; + } + + protected function DASHDASH_COMMENT() + { + $this->consume(); // Consume the '-'. + $this->consume(); // Consume the '-'. + + while (safe_ctype_space($this->c)) { + $this->consume(); + } + + while ($this->c !== null) { + if ($this->c === "\n" || $this->c === "\r") { + break; + } + $this->consume(); + } + + $this->channel = self::HIDDEN; + } + + protected function ACCESSIBLE_SYMBOL() + { + $this->setType(self::ACCESSIBLE_SYMBOL); + } + + protected function ACCOUNT_SYMBOL() + { + $this->setType(self::ACCOUNT_SYMBOL); + } + + protected function ACTION_SYMBOL() + { + $this->setType(self::ACTION_SYMBOL); + } + + protected function ADD_SYMBOL() + { + $this->setType(self::ADD_SYMBOL); + } + + protected function ADDDATE_SYMBOL() + { + $this->setType($this->determineFunction(self::ADDDATE_SYMBOL)); // MYSQL-FUNC + } + + protected function AFTER_SYMBOL() + { + $this->setType(self::AFTER_SYMBOL); + } + + protected function AGAINST_SYMBOL() + { + $this->setType(self::AGAINST_SYMBOL); + } + + protected function AGGREGATE_SYMBOL() + { + $this->setType(self::AGGREGATE_SYMBOL); + } + + protected function ALGORITHM_SYMBOL() + { + $this->setType(self::ALGORITHM_SYMBOL); + } + + protected function ALL_SYMBOL() + { + $this->setType(self::ALL_SYMBOL); + } + + protected function ALTER_SYMBOL() + { + $this->setType(self::ALTER_SYMBOL); + } + + protected function ALWAYS_SYMBOL() + { + $this->setType(self::ALWAYS_SYMBOL); + } + + protected function ANALYSE_SYMBOL() + { + $this->setType(self::ANALYSE_SYMBOL); + } + + protected function ANALYZE_SYMBOL() + { + $this->setType(self::ANALYZE_SYMBOL); + } + + protected function AND_SYMBOL() + { + $this->setType(self::AND_SYMBOL); + } + + protected function ANY_SYMBOL() + { + $this->setType(self::ANY_SYMBOL); + } + + protected function AS_SYMBOL() + { + $this->setType(self::AS_SYMBOL); + } + + protected function ASC_SYMBOL() + { + $this->setType(self::ASC_SYMBOL); + } + + protected function ASCII_SYMBOL() + { + $this->setType(self::ASCII_SYMBOL); + } + + protected function ASENSITIVE_SYMBOL() + { + $this->setType(self::ASENSITIVE_SYMBOL); + } + + protected function AT_SYMBOL() + { + $this->setType(self::AT_SYMBOL); + } + + protected function AUTHORS_SYMBOL() + { + $this->setType(self::AUTHORS_SYMBOL); + } + + protected function AUTOEXTEND_SIZE_SYMBOL() + { + $this->setType(self::AUTOEXTEND_SIZE_SYMBOL); + } + + protected function AUTO_INCREMENT_SYMBOL() + { + $this->setType(self::AUTO_INCREMENT_SYMBOL); + } + + protected function AVG_SYMBOL() + { + $this->setType(self::AVG_SYMBOL); + } + + protected function AVG_ROW_LENGTH_SYMBOL() + { + $this->setType(self::AVG_ROW_LENGTH_SYMBOL); + } + + protected function BACKUP_SYMBOL() + { + $this->setType(self::BACKUP_SYMBOL); + } + + protected function BEFORE_SYMBOL() + { + $this->setType(self::BEFORE_SYMBOL); + } + + protected function BEGIN_SYMBOL() + { + $this->setType(self::BEGIN_SYMBOL); + } + + protected function BETWEEN_SYMBOL() + { + $this->setType(self::BETWEEN_SYMBOL); + } + + protected function BIGINT_SYMBOL() + { + $this->setType(self::BIGINT_SYMBOL); + } + + protected function BINARY_SYMBOL() + { + $this->setType(self::BINARY_SYMBOL); + } + + protected function BINLOG_SYMBOL() + { + $this->setType(self::BINLOG_SYMBOL); + } + + protected function BIT_AND_SYMBOL() + { + $this->setType($this->determineFunction(self::BIT_AND_SYMBOL)); // MYSQL-FUNC + } + + protected function BIT_OR_SYMBOL() + { + $this->setType($this->determineFunction(self::BIT_OR_SYMBOL)); // MYSQL-FUNC + } + + protected function BIT_SYMBOL() + { + $this->setType(self::BIT_SYMBOL); + } + + protected function BIT_XOR_SYMBOL() + { + $this->setType($this->determineFunction(self::BIT_XOR_SYMBOL)); // MYSQL-FUNC + } + + protected function BLOB_SYMBOL() + { + $this->setType(self::BLOB_SYMBOL); + } + + protected function BLOCK_SYMBOL() + { + $this->setType(self::BLOCK_SYMBOL); + } + + protected function BOOLEAN_SYMBOL() + { + $this->setType(self::BOOLEAN_SYMBOL); + } + + protected function BOOL_SYMBOL() + { + $this->setType(self::BOOL_SYMBOL); + } + + protected function BOTH_SYMBOL() + { + $this->setType(self::BOTH_SYMBOL); + } + + protected function BTREE_SYMBOL() + { + $this->setType(self::BTREE_SYMBOL); + } + + protected function BUCKETS_SYMBOL() + { + $this->setType(self::BUCKETS_SYMBOL); + } + + protected function BY_SYMBOL() + { + $this->setType(self::BY_SYMBOL); + } + + protected function BYTE_SYMBOL() + { + $this->setType(self::BYTE_SYMBOL); + } + + protected function CACHE_SYMBOL() + { + $this->setType(self::CACHE_SYMBOL); + } + + protected function CALL_SYMBOL() + { + $this->setType(self::CALL_SYMBOL); + } + + protected function CASCADE_SYMBOL() + { + $this->setType(self::CASCADE_SYMBOL); + } + + protected function CASCADED_SYMBOL() + { + $this->setType(self::CASCADED_SYMBOL); + } + + protected function CASE_SYMBOL() + { + $this->setType(self::CASE_SYMBOL); + } + + protected function CAST_SYMBOL() + { + $this->setType($this->determineFunction(self::CAST_SYMBOL)); // SQL-2003-R + } + + protected function CATALOG_NAME_SYMBOL() + { + $this->setType(self::CATALOG_NAME_SYMBOL); + } + + protected function CHAIN_SYMBOL() + { + $this->setType(self::CHAIN_SYMBOL); + } + + protected function CHANGE_SYMBOL() + { + $this->setType(self::CHANGE_SYMBOL); + } + + protected function CHANGED_SYMBOL() + { + $this->setType(self::CHANGED_SYMBOL); + } + + protected function CHANNEL_SYMBOL() + { + $this->setType(self::CHANNEL_SYMBOL); + } + + protected function CHAR_SYMBOL() + { + $this->setType(self::CHAR_SYMBOL); + } + + protected function CHARSET_SYMBOL() + { + $this->setType(self::CHARSET_SYMBOL); + } + + protected function CHECK_SYMBOL() + { + $this->setType(self::CHECK_SYMBOL); + } + + protected function CHECKSUM_SYMBOL() + { + $this->setType(self::CHECKSUM_SYMBOL); + } + + protected function CIPHER_SYMBOL() + { + $this->setType(self::CIPHER_SYMBOL); + } + + protected function CLASS_ORIGIN_SYMBOL() + { + $this->setType(self::CLASS_ORIGIN_SYMBOL); + } + + protected function CLIENT_SYMBOL() + { + $this->setType(self::CLIENT_SYMBOL); + } + + protected function CLONE_SYMBOL() + { + $this->setType(self::CLONE_SYMBOL); + } + + protected function CLOSE_SYMBOL() + { + $this->setType(self::CLOSE_SYMBOL); + } + + protected function COALESCE_SYMBOL() + { + $this->setType(self::COALESCE_SYMBOL); + } + + protected function CODE_SYMBOL() + { + $this->setType(self::CODE_SYMBOL); + } + + protected function COLLATE_SYMBOL() + { + $this->setType(self::COLLATE_SYMBOL); + } + + protected function COLLATION_SYMBOL() + { + $this->setType(self::COLLATION_SYMBOL); + } + + protected function COLUMN_FORMAT_SYMBOL() + { + $this->setType(self::COLUMN_FORMAT_SYMBOL); + } + + protected function COLUMN_NAME_SYMBOL() + { + $this->setType(self::COLUMN_NAME_SYMBOL); + } + + protected function COLUMNS_SYMBOL() + { + $this->setType(self::COLUMNS_SYMBOL); + } + + protected function COLUMN_SYMBOL() + { + $this->setType(self::COLUMN_SYMBOL); + } + + protected function COMMENT_SYMBOL() + { + $this->setType(self::COMMENT_SYMBOL); + } + + protected function COMMIT_SYMBOL() + { + $this->setType(self::COMMIT_SYMBOL); + } + + protected function COMMITTED_SYMBOL() + { + $this->setType(self::COMMITTED_SYMBOL); + } + + protected function COMPACT_SYMBOL() + { + $this->setType(self::COMPACT_SYMBOL); + } + + protected function COMPLETION_SYMBOL() + { + $this->setType(self::COMPLETION_SYMBOL); + } + + protected function COMPONENT_SYMBOL() + { + $this->setType(self::COMPONENT_SYMBOL); + } + + protected function COMPRESSED_SYMBOL() + { + $this->setType(self::COMPRESSED_SYMBOL); + } + + protected function COMPRESSION_SYMBOL() + { + $this->setType(self::COMPRESSION_SYMBOL); + } + + protected function CONCURRENT_SYMBOL() + { + $this->setType(self::CONCURRENT_SYMBOL); + } + + protected function CONDITION_SYMBOL() + { + $this->setType(self::CONDITION_SYMBOL); + } + + protected function CONNECTION_SYMBOL() + { + $this->setType(self::CONNECTION_SYMBOL); + } + + protected function CONSISTENT_SYMBOL() + { + $this->setType(self::CONSISTENT_SYMBOL); + } + + protected function CONSTRAINT_SYMBOL() + { + $this->setType(self::CONSTRAINT_SYMBOL); + } + + protected function CONSTRAINT_CATALOG_SYMBOL() + { + $this->setType(self::CONSTRAINT_CATALOG_SYMBOL); + } + + protected function CONSTRAINT_NAME_SYMBOL() + { + $this->setType(self::CONSTRAINT_NAME_SYMBOL); + } + + protected function CONSTRAINT_SCHEMA_SYMBOL() + { + $this->setType(self::CONSTRAINT_SCHEMA_SYMBOL); + } + + protected function CONTAINS_SYMBOL() + { + $this->setType(self::CONTAINS_SYMBOL); + } + + protected function CONTEXT_SYMBOL() + { + $this->setType(self::CONTEXT_SYMBOL); + } + + protected function CONTINUE_SYMBOL() + { + $this->setType(self::CONTINUE_SYMBOL); + } + + protected function CONTRIBUTORS_SYMBOL() + { + $this->setType(self::CONTRIBUTORS_SYMBOL); + } + + protected function CONVERT_SYMBOL() + { + $this->setType(self::CONVERT_SYMBOL); + } + + protected function COUNT_SYMBOL() + { + $this->setType($this->determineFunction(self::COUNT_SYMBOL)); // SQL-2003-N + } + + protected function CPU_SYMBOL() + { + $this->setType(self::CPU_SYMBOL); + } + + protected function CREATE_SYMBOL() + { + $this->setType(self::CREATE_SYMBOL); + } + + protected function CROSS_SYMBOL() + { + $this->setType(self::CROSS_SYMBOL); + } + + protected function CUBE_SYMBOL() + { + $this->setType(self::CUBE_SYMBOL); + } + + protected function CURDATE_SYMBOL() + { + $this->setType($this->determineFunction(self::CURDATE_SYMBOL)); // MYSQL-FUNC + } + + protected function CURRENT_SYMBOL() + { + $this->setType(self::CURRENT_SYMBOL); + } + + protected function CURRENT_DATE_SYMBOL() + { + $this->setType($this->determineFunction(self::CURDATE_SYMBOL)); // Synonym, MYSQL-FUNC + } + + protected function CURRENT_TIME_SYMBOL() + { + $this->setType($this->determineFunction(self::CURTIME_SYMBOL)); // Synonym, MYSQL-FUNC + } + + protected function CURRENT_TIMESTAMP_SYMBOL() + { + $this->setType(self::NOW_SYMBOL); // Synonym + } + + protected function CURRENT_USER_SYMBOL() + { + $this->setType(self::CURRENT_USER_SYMBOL); + } + + protected function CURSOR_SYMBOL() + { + $this->setType(self::CURSOR_SYMBOL); + } + + protected function CURSOR_NAME_SYMBOL() + { + $this->setType(self::CURSOR_NAME_SYMBOL); + } + + protected function CURTIME_SYMBOL() + { + $this->setType($this->determineFunction(self::CURTIME_SYMBOL)); // MYSQL-FUNC + } + + protected function DATABASE_SYMBOL() + { + $this->setType(self::DATABASE_SYMBOL); + } + + protected function DATABASES_SYMBOL() + { + $this->setType(self::DATABASES_SYMBOL); + } + + protected function DATAFILE_SYMBOL() + { + $this->setType(self::DATAFILE_SYMBOL); + } + + protected function DATA_SYMBOL() + { + $this->setType(self::DATA_SYMBOL); + } + + protected function DATETIME_SYMBOL() + { + $this->setType(self::DATETIME_SYMBOL); + } + + protected function DATE_ADD_SYMBOL() + { + $this->setType($this->determineFunction(self::DATE_ADD_SYMBOL)); + } + + protected function DATE_SUB_SYMBOL() + { + $this->setType($this->determineFunction(self::DATE_SUB_SYMBOL)); + } + + protected function DATE_SYMBOL() + { + $this->setType(self::DATE_SYMBOL); + } + + protected function DAY_HOUR_SYMBOL() + { + $this->setType(self::DAY_HOUR_SYMBOL); + } + + protected function DAY_MICROSECOND_SYMBOL() + { + $this->setType(self::DAY_MICROSECOND_SYMBOL); + } + + protected function DAY_MINUTE_SYMBOL() + { + $this->setType(self::DAY_MINUTE_SYMBOL); + } + + protected function DAY_SECOND_SYMBOL() + { + $this->setType(self::DAY_SECOND_SYMBOL); + } + + protected function DAY_SYMBOL() + { + $this->setType(self::DAY_SYMBOL); + } + + protected function DAYOFMONTH_SYMBOL() + { + $this->setType(self::DAY_SYMBOL); // Synonym + } + + protected function DEALLOCATE_SYMBOL() + { + $this->setType(self::DEALLOCATE_SYMBOL); + } + + protected function DECIMAL_SYMBOL() + { + $this->setType(self::DECIMAL_SYMBOL); + } + + protected function DEC_SYMBOL() + { + $this->setType(self::DECIMAL_SYMBOL); // Synonym + } + + protected function DECLARE_SYMBOL() + { + $this->setType(self::DECLARE_SYMBOL); + } + + protected function DEFAULT_SYMBOL() + { + $this->setType(self::DEFAULT_SYMBOL); + } + + protected function DEFAULT_AUTH_SYMBOL() + { + $this->setType(self::DEFAULT_AUTH_SYMBOL); + } + + protected function DEFINER_SYMBOL() + { + $this->setType(self::DEFINER_SYMBOL); + } + + protected function DEFINITION_SYMBOL() + { + $this->setType(self::DEFINITION_SYMBOL); + } + + protected function DELAYED_SYMBOL() + { + $this->setType(self::DELAYED_SYMBOL); + } + + protected function DELAY_KEY_WRITE_SYMBOL() + { + $this->setType(self::DELAY_KEY_WRITE_SYMBOL); + } + + protected function DELETE_SYMBOL() + { + $this->setType(self::DELETE_SYMBOL); + } + + protected function DENSE_RANK_SYMBOL() + { + $this->setType(self::DENSE_RANK_SYMBOL); + } + + protected function DESC_SYMBOL() + { + $this->setType(self::DESC_SYMBOL); + } + + protected function DESCRIBE_SYMBOL() + { + $this->setType(self::DESCRIBE_SYMBOL); + } + + protected function DESCRIPTION_SYMBOL() + { + $this->setType(self::DESCRIPTION_SYMBOL); + } + + protected function DES_KEY_FILE_SYMBOL() + { + $this->setType(self::DES_KEY_FILE_SYMBOL); + } + + protected function DETERMINISTIC_SYMBOL() + { + $this->setType(self::DETERMINISTIC_SYMBOL); + } + + protected function DIAGNOSTICS_SYMBOL() + { + $this->setType(self::DIAGNOSTICS_SYMBOL); + } + + protected function DIRECTORY_SYMBOL() + { + $this->setType(self::DIRECTORY_SYMBOL); + } + + protected function DISABLE_SYMBOL() + { + $this->setType(self::DISABLE_SYMBOL); + } + + protected function DISCARD_SYMBOL() + { + $this->setType(self::DISCARD_SYMBOL); + } + + protected function DISK_SYMBOL() + { + $this->setType(self::DISK_SYMBOL); + } + + protected function DISTINCT_SYMBOL() + { + $this->setType(self::DISTINCT_SYMBOL); + } + + protected function DISTINCTROW_SYMBOL() + { + $this->setType(self::DISTINCT_SYMBOL); // Synonym + } + + protected function DIV_SYMBOL() + { + $this->setType(self::DIV_SYMBOL); + } + + protected function DOUBLE_SYMBOL() + { + $this->setType(self::DOUBLE_SYMBOL); + } + + protected function DO_SYMBOL() + { + $this->setType(self::DO_SYMBOL); + } + + protected function DROP_SYMBOL() + { + $this->setType(self::DROP_SYMBOL); + } + + protected function DUAL_SYMBOL() + { + $this->setType(self::DUAL_SYMBOL); + } + + protected function DUMPFILE_SYMBOL() + { + $this->setType(self::DUMPFILE_SYMBOL); + } + + protected function DUPLICATE_SYMBOL() + { + $this->setType(self::DUPLICATE_SYMBOL); + } + + protected function DYNAMIC_SYMBOL() + { + $this->setType(self::DYNAMIC_SYMBOL); + } + + protected function EACH_SYMBOL() + { + $this->setType(self::EACH_SYMBOL); + } + + protected function ELSE_SYMBOL() + { + $this->setType(self::ELSE_SYMBOL); + } + + protected function ELSEIF_SYMBOL() + { + $this->setType(self::ELSEIF_SYMBOL); + } + + protected function EMPTY_SYMBOL() + { + $this->setType(self::EMPTY_SYMBOL); + } + + protected function ENABLE_SYMBOL() + { + $this->setType(self::ENABLE_SYMBOL); + } + + protected function ENCLOSED_SYMBOL() + { + $this->setType(self::ENCLOSED_SYMBOL); + } + + protected function ENCRYPTION_SYMBOL() + { + $this->setType(self::ENCRYPTION_SYMBOL); + } + + protected function END_SYMBOL() + { + $this->setType(self::END_SYMBOL); + } + + protected function ENDS_SYMBOL() + { + $this->setType(self::ENDS_SYMBOL); + } + + protected function ENFORCED_SYMBOL() + { + $this->setType(self::ENFORCED_SYMBOL); + } + + protected function ENGINE_SYMBOL() + { + $this->setType(self::ENGINE_SYMBOL); + } + + protected function ENGINES_SYMBOL() + { + $this->setType(self::ENGINES_SYMBOL); + } + + protected function ENUM_SYMBOL() + { + $this->setType(self::ENUM_SYMBOL); + } + + protected function ERROR_SYMBOL() + { + $this->setType(self::ERROR_SYMBOL); + } + + protected function ERRORS_SYMBOL() + { + $this->setType(self::ERRORS_SYMBOL); + } + + protected function ESCAPED_SYMBOL() + { + $this->setType(self::ESCAPED_SYMBOL); + } + + protected function ESCAPE_SYMBOL() + { + $this->setType(self::ESCAPE_SYMBOL); + } + + protected function EVENT_SYMBOL() + { + $this->setType(self::EVENT_SYMBOL); + } + + protected function EVENTS_SYMBOL() + { + $this->setType(self::EVENTS_SYMBOL); + } + + protected function EVERY_SYMBOL() + { + $this->setType(self::EVERY_SYMBOL); + } + + protected function EXCHANGE_SYMBOL() + { + $this->setType(self::EXCHANGE_SYMBOL); + } + + protected function EXCEPT_SYMBOL() + { + $this->setType(self::EXCEPT_SYMBOL); + } + + protected function EXECUTE_SYMBOL() + { + $this->setType(self::EXECUTE_SYMBOL); + } + + protected function EXISTS_SYMBOL() + { + $this->setType(self::EXISTS_SYMBOL); + } + + protected function EXIT_SYMBOL() + { + $this->setType(self::EXIT_SYMBOL); + } + + protected function EXPANSION_SYMBOL() + { + $this->setType(self::EXPANSION_SYMBOL); + } + + protected function EXPIRE_SYMBOL() + { + $this->setType(self::EXPIRE_SYMBOL); + } + + protected function EXPLAIN_SYMBOL() + { + $this->setType(self::EXPLAIN_SYMBOL); + } + + protected function EXPORT_SYMBOL() + { + $this->setType(self::EXPORT_SYMBOL); + } + + protected function EXTENDED_SYMBOL() + { + $this->setType(self::EXTENDED_SYMBOL); + } + + protected function EXTENT_SIZE_SYMBOL() + { + $this->setType(self::EXTENT_SIZE_SYMBOL); + } + + protected function EXTRACT_SYMBOL() + { + $this->setType($this->determineFunction(self::EXTRACT_SYMBOL)); // SQL-2003-N + } + + protected function FALSE_SYMBOL() + { + $this->setType(self::FALSE_SYMBOL); + } + + protected function FAILED_LOGIN_ATTEMPTS_SYMBOL() + { + $this->setType(self::FAILED_LOGIN_ATTEMPTS_SYMBOL); + } + + protected function FAST_SYMBOL() + { + $this->setType(self::FAST_SYMBOL); + } + + protected function FAULTS_SYMBOL() + { + $this->setType(self::FAULTS_SYMBOL); + } + + protected function FETCH_SYMBOL() + { + $this->setType(self::FETCH_SYMBOL); + } + + protected function FIELDS_SYMBOL() + { + $this->setType(self::COLUMNS_SYMBOL); // Synonym + } + + protected function FILE_BLOCK_SIZE_SYMBOL() + { + $this->setType(self::FILE_BLOCK_SIZE_SYMBOL); + } + + protected function FILE_SYMBOL() + { + $this->setType(self::FILE_SYMBOL); + } + + protected function FILTER_SYMBOL() + { + $this->setType(self::FILTER_SYMBOL); + } + + protected function FIRST_SYMBOL() + { + $this->setType(self::FIRST_SYMBOL); + } + + protected function FIRST_VALUE_SYMBOL() + { + $this->setType(self::FIRST_VALUE_SYMBOL); + } + + protected function FIXED_SYMBOL() + { + $this->setType(self::FIXED_SYMBOL); + } + + protected function FLOAT4_SYMBOL() + { + $this->setType(self::FLOAT_SYMBOL); // Synonym + } + + protected function FLOAT8_SYMBOL() + { + $this->setType(self::DOUBLE_SYMBOL); // Synonym + } + + protected function FLOAT_SYMBOL() + { + $this->setType(self::FLOAT_SYMBOL); + } + + protected function FLUSH_SYMBOL() + { + $this->setType(self::FLUSH_SYMBOL); + } + + protected function FOLLOWS_SYMBOL() + { + $this->setType(self::FOLLOWS_SYMBOL); + } + + protected function FOLLOWING_SYMBOL() + { + $this->setType(self::FOLLOWING_SYMBOL); + } + + protected function FORCE_SYMBOL() + { + $this->setType(self::FORCE_SYMBOL); + } + + protected function FOR_SYMBOL() + { + $this->setType(self::FOR_SYMBOL); + } + + protected function FOREIGN_SYMBOL() + { + $this->setType(self::FOREIGN_SYMBOL); + } + + protected function FORMAT_SYMBOL() + { + $this->setType(self::FORMAT_SYMBOL); + } + + protected function FOUND_SYMBOL() + { + $this->setType(self::FOUND_SYMBOL); + } + + protected function FROM_SYMBOL() + { + $this->setType(self::FROM_SYMBOL); + } + + protected function FULLTEXT_SYMBOL() + { + $this->setType(self::FULLTEXT_SYMBOL); + } + + protected function FULL_SYMBOL() + { + $this->setType(self::FULL_SYMBOL); + } + + protected function FUNCTION_SYMBOL() + { + $this->setType(self::FUNCTION_SYMBOL); + } + + protected function GENERATED_SYMBOL() + { + $this->setType(self::GENERATED_SYMBOL); + } + + protected function GENERAL_SYMBOL() + { + $this->setType(self::GENERAL_SYMBOL); + } + + protected function GEOMETRYCOLLECTION_SYMBOL() + { + $this->setType(self::GEOMETRYCOLLECTION_SYMBOL); + } + + protected function GEOMETRY_SYMBOL() + { + $this->setType(self::GEOMETRY_SYMBOL); + } + + protected function GET_SYMBOL() + { + $this->setType(self::GET_SYMBOL); + } + + protected function GET_FORMAT_SYMBOL() + { + $this->setType(self::GET_FORMAT_SYMBOL); + } + + protected function GET_MASTER_PUBLIC_KEY_SYMBOL() + { + $this->setType(self::GET_MASTER_PUBLIC_KEY_SYMBOL); + } + + protected function GLOBAL_SYMBOL() + { + $this->setType(self::GLOBAL_SYMBOL); + } + + protected function GRANT_SYMBOL() + { + $this->setType(self::GRANT_SYMBOL); + } + + protected function GRANTS_SYMBOL() + { + $this->setType(self::GRANTS_SYMBOL); + } + + protected function GROUP_CONCAT_SYMBOL() + { + $this->setType($this->determineFunction(self::GROUP_CONCAT_SYMBOL)); + } + + protected function GROUP_SYMBOL() + { + $this->setType(self::GROUP_SYMBOL); + } + + protected function GROUP_REPLICATION_SYMBOL() + { + $this->setType(self::GROUP_REPLICATION_SYMBOL); + } + + protected function GROUPING_SYMBOL() + { + $this->setType(self::GROUPING_SYMBOL); + } + + protected function GROUPS_SYMBOL() + { + $this->setType(self::GROUPS_SYMBOL); + } + + protected function HANDLER_SYMBOL() + { + $this->setType(self::HANDLER_SYMBOL); + } + + protected function HASH_SYMBOL() + { + $this->setType(self::HASH_SYMBOL); + } + + protected function HAVING_SYMBOL() + { + $this->setType(self::HAVING_SYMBOL); + } + + protected function HELP_SYMBOL() + { + $this->setType(self::HELP_SYMBOL); + } + + protected function HIGH_PRIORITY_SYMBOL() + { + $this->setType(self::HIGH_PRIORITY_SYMBOL); + } + + protected function HISTOGRAM_SYMBOL() + { + $this->setType(self::HISTOGRAM_SYMBOL); + } + + protected function HISTORY_SYMBOL() + { + $this->setType(self::HISTORY_SYMBOL); + } + + protected function HOSTS_SYMBOL() + { + $this->setType(self::HOSTS_SYMBOL); + } + + protected function HOST_SYMBOL() + { + $this->setType(self::HOST_SYMBOL); + } + + protected function HOUR_SYMBOL() + { + $this->setType(self::HOUR_SYMBOL); + } + + protected function HOUR_MICROSECOND_SYMBOL() + { + $this->setType(self::HOUR_MICROSECOND_SYMBOL); + } + + protected function HOUR_MINUTE_SYMBOL() + { + $this->setType(self::HOUR_MINUTE_SYMBOL); + } + + protected function HOUR_SECOND_SYMBOL() + { + $this->setType(self::HOUR_SECOND_SYMBOL); + } + + protected function IDENTIFIED_SYMBOL() + { + $this->setType(self::IDENTIFIED_SYMBOL); + } + + protected function IF_SYMBOL() + { + $this->setType(self::IF_SYMBOL); + } + + protected function IGNORE_SYMBOL() + { + $this->setType(self::IGNORE_SYMBOL); + } + + protected function IGNORE_SERVER_IDS_SYMBOL() + { + $this->setType(self::IGNORE_SERVER_IDS_SYMBOL); + } + + protected function IMPORT_SYMBOL() + { + $this->setType(self::IMPORT_SYMBOL); + } + + protected function IN_SYMBOL() + { + $this->setType(self::IN_SYMBOL); + } + + protected function INDEX_SYMBOL() + { + $this->setType(self::INDEX_SYMBOL); + } + + protected function INDEXES_SYMBOL() + { + $this->setType(self::INDEXES_SYMBOL); + } + + protected function INFILE_SYMBOL() + { + $this->setType(self::INFILE_SYMBOL); + } + + protected function INITIAL_SIZE_SYMBOL() + { + $this->setType(self::INITIAL_SIZE_SYMBOL); + } + + protected function INNER_SYMBOL() + { + $this->setType(self::INNER_SYMBOL); + } + + protected function INOUT_SYMBOL() + { + $this->setType(self::INOUT_SYMBOL); + } + + protected function INSENSITIVE_SYMBOL() + { + $this->setType(self::INSENSITIVE_SYMBOL); + } + + protected function INSERT_SYMBOL() + { + $this->setType(self::INSERT_SYMBOL); + } + + protected function INSERT_METHOD_SYMBOL() + { + $this->setType(self::INSERT_METHOD_SYMBOL); + } + + protected function INSTANCE_SYMBOL() + { + $this->setType(self::INSTANCE_SYMBOL); + } + + protected function INSTALL_SYMBOL() + { + $this->setType(self::INSTALL_SYMBOL); + } + + protected function INT_SYMBOL() + { + $this->setType(self::INT_SYMBOL); + } + + protected function INTEGER_SYMBOL() + { + $this->setType(self::INT_SYMBOL); // Synonym + } + + protected function INTERVAL_SYMBOL() + { + $this->setType(self::INTERVAL_SYMBOL); + } + + protected function INTO_SYMBOL() + { + $this->setType(self::INTO_SYMBOL); + } + + protected function INVISIBLE_SYMBOL() + { + $this->setType(self::INVISIBLE_SYMBOL); + } + + protected function INVOKER_SYMBOL() + { + $this->setType(self::INVOKER_SYMBOL); + } + + protected function IO_SYMBOL() + { + $this->setType(self::IO_SYMBOL); + } + + protected function IPC_SYMBOL() + { + $this->setType(self::IPC_SYMBOL); + } + + protected function IS_SYMBOL() + { + $this->setType(self::IS_SYMBOL); + } + + protected function ISOLATION_SYMBOL() + { + $this->setType(self::ISOLATION_SYMBOL); + } + + protected function ISSUER_SYMBOL() + { + $this->setType(self::ISSUER_SYMBOL); + } + + protected function ITERATE_SYMBOL() + { + $this->setType(self::ITERATE_SYMBOL); + } + + protected function JOIN_SYMBOL() + { + $this->setType(self::JOIN_SYMBOL); + } + + protected function JSON_SYMBOL() + { + $this->setType(self::JSON_SYMBOL); + } + + protected function JSON_TABLE_SYMBOL() + { + $this->setType(self::JSON_TABLE_SYMBOL); + } + + protected function JSON_ARRAYAGG_SYMBOL() + { + $this->setType(self::JSON_ARRAYAGG_SYMBOL); + } + + protected function JSON_OBJECTAGG_SYMBOL() + { + $this->setType(self::JSON_OBJECTAGG_SYMBOL); + } + + protected function KEYS_SYMBOL() + { + $this->setType(self::KEYS_SYMBOL); + } + + protected function KEY_SYMBOL() + { + $this->setType(self::KEY_SYMBOL); + } + + protected function KEY_BLOCK_SIZE_SYMBOL() + { + $this->setType(self::KEY_BLOCK_SIZE_SYMBOL); + } + + protected function KILL_SYMBOL() + { + $this->setType(self::KILL_SYMBOL); + } + + protected function LAG_SYMBOL() + { + $this->setType(self::LAG_SYMBOL); + } + + protected function LANGUAGE_SYMBOL() + { + $this->setType(self::LANGUAGE_SYMBOL); + } + + protected function LAST_SYMBOL() + { + $this->setType(self::LAST_SYMBOL); + } + + protected function LAST_VALUE_SYMBOL() + { + $this->setType(self::LAST_VALUE_SYMBOL); + } + + protected function LATERAL_SYMBOL() + { + $this->setType(self::LATERAL_SYMBOL); + } + + protected function LEAD_SYMBOL() + { + $this->setType(self::LEAD_SYMBOL); + } + + protected function LEADING_SYMBOL() + { + $this->setType(self::LEADING_SYMBOL); + } + + protected function LEAVE_SYMBOL() + { + $this->setType(self::LEAVE_SYMBOL); + } + + protected function LEAVES_SYMBOL() + { + $this->setType(self::LEAVES_SYMBOL); + } + + protected function LEFT_SYMBOL() + { + $this->setType(self::LEFT_SYMBOL); + } + + protected function LESS_SYMBOL() + { + $this->setType(self::LESS_SYMBOL); + } + + protected function LEVEL_SYMBOL() + { + $this->setType(self::LEVEL_SYMBOL); + } + + protected function LIKE_SYMBOL() + { + $this->setType(self::LIKE_SYMBOL); + } + + protected function LIMIT_SYMBOL() + { + $this->setType(self::LIMIT_SYMBOL); + } + + protected function LINEAR_SYMBOL() + { + $this->setType(self::LINEAR_SYMBOL); + } + + protected function LINES_SYMBOL() + { + $this->setType(self::LINES_SYMBOL); + } + + protected function LINESTRING_SYMBOL() + { + $this->setType(self::LINESTRING_SYMBOL); + } + + protected function LIST_SYMBOL() + { + $this->setType(self::LIST_SYMBOL); + } + + protected function LOAD_SYMBOL() + { + $this->setType(self::LOAD_SYMBOL); + } + + protected function LOCALTIME_SYMBOL() + { + $this->setType(self::NOW_SYMBOL); // Synonym + } + + protected function LOCALTIMESTAMP_SYMBOL() + { + $this->setType(self::NOW_SYMBOL); // Synonym + } + + protected function LOCAL_SYMBOL() + { + $this->setType(self::LOCAL_SYMBOL); + } + + protected function LOCATOR_SYMBOL() + { + $this->setType(self::LOCATOR_SYMBOL); + } + + protected function LOCK_SYMBOL() + { + $this->setType(self::LOCK_SYMBOL); + } + + protected function LOCKS_SYMBOL() + { + $this->setType(self::LOCKS_SYMBOL); + } + + protected function LOGFILE_SYMBOL() + { + $this->setType(self::LOGFILE_SYMBOL); + } + + protected function LOGS_SYMBOL() + { + $this->setType(self::LOGS_SYMBOL); + } + + protected function LONGBLOB_SYMBOL() + { + $this->setType(self::LONGBLOB_SYMBOL); + } + + protected function LONGTEXT_SYMBOL() + { + $this->setType(self::LONGTEXT_SYMBOL); + } + + protected function LONG_SYMBOL() + { + $this->setType(self::LONG_SYMBOL); + } + + protected function LOOP_SYMBOL() + { + $this->setType(self::LOOP_SYMBOL); + } + + protected function LOW_PRIORITY_SYMBOL() + { + $this->setType(self::LOW_PRIORITY_SYMBOL); + } + + protected function MASTER_SYMBOL() + { + $this->setType(self::MASTER_SYMBOL); + } + + protected function MASTER_AUTO_POSITION_SYMBOL() + { + $this->setType(self::MASTER_AUTO_POSITION_SYMBOL); + } + + protected function MASTER_BIND_SYMBOL() + { + $this->setType(self::MASTER_BIND_SYMBOL); + } + + protected function MASTER_COMPRESSION_ALGORITHM_SYMBOL() + { + $this->setType(self::MASTER_COMPRESSION_ALGORITHM_SYMBOL); + } + + protected function MASTER_CONNECT_RETRY_SYMBOL() + { + $this->setType(self::MASTER_CONNECT_RETRY_SYMBOL); + } + + protected function MASTER_DELAY_SYMBOL() + { + $this->setType(self::MASTER_DELAY_SYMBOL); + } + + protected function MASTER_HEARTBEAT_PERIOD_SYMBOL() + { + $this->setType(self::MASTER_HEARTBEAT_PERIOD_SYMBOL); + } + + protected function MASTER_HOST_SYMBOL() + { + $this->setType(self::MASTER_HOST_SYMBOL); + } + + protected function NETWORK_NAMESPACE_SYMBOL() + { + $this->setType(self::NETWORK_NAMESPACE_SYMBOL); + } + + protected function MASTER_LOG_FILE_SYMBOL() + { + $this->setType(self::MASTER_LOG_FILE_SYMBOL); + } + + protected function MASTER_LOG_POS_SYMBOL() + { + $this->setType(self::MASTER_LOG_POS_SYMBOL); + } + + protected function MASTER_PASSWORD_SYMBOL() + { + $this->setType(self::MASTER_PASSWORD_SYMBOL); + } + + protected function MASTER_PORT_SYMBOL() + { + $this->setType(self::MASTER_PORT_SYMBOL); + } + + protected function MASTER_PUBLIC_KEY_PATH_SYMBOL() + { + $this->setType(self::MASTER_PUBLIC_KEY_PATH_SYMBOL); + } + + protected function MASTER_RETRY_COUNT_SYMBOL() + { + $this->setType(self::MASTER_RETRY_COUNT_SYMBOL); + } + + protected function MASTER_SERVER_ID_SYMBOL() + { + $this->setType(self::MASTER_SERVER_ID_SYMBOL); + } + + protected function MASTER_SSL_CAPATH_SYMBOL() + { + $this->setType(self::MASTER_SSL_CAPATH_SYMBOL); + } + + protected function MASTER_SSL_CA_SYMBOL() + { + $this->setType(self::MASTER_SSL_CA_SYMBOL); + } + + protected function MASTER_SSL_CERT_SYMBOL() + { + $this->setType(self::MASTER_SSL_CERT_SYMBOL); + } + + protected function MASTER_SSL_CIPHER_SYMBOL() + { + $this->setType(self::MASTER_SSL_CIPHER_SYMBOL); + } + + protected function MASTER_SSL_CRL_SYMBOL() + { + $this->setType(self::MASTER_SSL_CRL_SYMBOL); + } + + protected function MASTER_SSL_CRLPATH_SYMBOL() + { + $this->setType(self::MASTER_SSL_CRLPATH_SYMBOL); + } + + protected function MASTER_SSL_KEY_SYMBOL() + { + $this->setType(self::MASTER_SSL_KEY_SYMBOL); + } + + protected function MASTER_SSL_SYMBOL() + { + $this->setType(self::MASTER_SSL_SYMBOL); + } + + protected function MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL() + { + $this->setType(self::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL); + } + + protected function MASTER_TLS_VERSION_SYMBOL() + { + $this->setType(self::MASTER_TLS_VERSION_SYMBOL); + } + + protected function MASTER_TLS_CIPHERSUITES_SYMBOL() + { + $this->setType(self::MASTER_TLS_CIPHERSUITES_SYMBOL); + } + + protected function MASTER_USER_SYMBOL() + { + $this->setType(self::MASTER_USER_SYMBOL); + } + + protected function MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL() + { + $this->setType(self::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL); + } + + protected function MATCH_SYMBOL() + { + $this->setType(self::MATCH_SYMBOL); + } + + protected function MAX_SYMBOL() + { + $this->setType($this->determineFunction(self::MAX_SYMBOL)); // SQL-2003-N + } + + protected function MAX_CONNECTIONS_PER_HOUR_SYMBOL() + { + $this->setType(self::MAX_CONNECTIONS_PER_HOUR_SYMBOL); + } + + protected function MAX_QUERIES_PER_HOUR_SYMBOL() + { + $this->setType(self::MAX_QUERIES_PER_HOUR_SYMBOL); + } + + protected function MAX_ROWS_SYMBOL() + { + $this->setType(self::MAX_ROWS_SYMBOL); + } + + protected function MAX_SIZE_SYMBOL() + { + $this->setType(self::MAX_SIZE_SYMBOL); + } + + protected function MAX_STATEMENT_TIME_SYMBOL() + { + $this->setType(self::MAX_STATEMENT_TIME_SYMBOL); + } + + protected function MAX_UPDATES_PER_HOUR_SYMBOL() + { + $this->setType(self::MAX_UPDATES_PER_HOUR_SYMBOL); + } + + protected function MAX_USER_CONNECTIONS_SYMBOL() + { + $this->setType(self::MAX_USER_CONNECTIONS_SYMBOL); + } + + protected function MAXVALUE_SYMBOL() + { + $this->setType(self::MAXVALUE_SYMBOL); + } + + protected function MEDIUM_SYMBOL() + { + $this->setType(self::MEDIUM_SYMBOL); + } + + protected function MEDIUMBLOB_SYMBOL() + { + $this->setType(self::MEDIUMBLOB_SYMBOL); + } + + protected function MEDIUMINT_SYMBOL() + { + $this->setType(self::MEDIUMINT_SYMBOL); + } + + protected function MEDIUMTEXT_SYMBOL() + { + $this->setType(self::MEDIUMTEXT_SYMBOL); + } + + protected function MEMBER_SYMBOL() + { + $this->setType(self::MEMBER_SYMBOL); + } + + protected function MEMORY_SYMBOL() + { + $this->setType(self::MEMORY_SYMBOL); + } + + protected function MERGE_SYMBOL() + { + $this->setType(self::MERGE_SYMBOL); + } + + protected function MESSAGE_TEXT_SYMBOL() + { + $this->setType(self::MESSAGE_TEXT_SYMBOL); + } + + protected function MICROSECOND_SYMBOL() + { + $this->setType(self::MICROSECOND_SYMBOL); + } + + protected function MIDDLEINT_SYMBOL() + { + $this->setType(self::MEDIUMINT_SYMBOL); // Synonym + } + + protected function MIGRATE_SYMBOL() + { + $this->setType(self::MIGRATE_SYMBOL); + } + + protected function MINUTE_SYMBOL() + { + $this->setType(self::MINUTE_SYMBOL); + } + + protected function MINUTE_MICROSECOND_SYMBOL() + { + $this->setType(self::MINUTE_MICROSECOND_SYMBOL); + } + + protected function MINUTE_SECOND_SYMBOL() + { + $this->setType(self::MINUTE_SECOND_SYMBOL); + } + + protected function MIN_SYMBOL() + { + $this->setType($this->determineFunction(self::MIN_SYMBOL)); // SQL-2003-N + } + + protected function MIN_ROWS_SYMBOL() + { + $this->setType(self::MIN_ROWS_SYMBOL); + } + + protected function MODE_SYMBOL() + { + $this->setType(self::MODE_SYMBOL); + } + + protected function MODIFIES_SYMBOL() + { + $this->setType(self::MODIFIES_SYMBOL); + } + + protected function MODIFY_SYMBOL() + { + $this->setType(self::MODIFY_SYMBOL); + } + + protected function MOD_SYMBOL() + { + $this->setType(self::MOD_SYMBOL); + } + + protected function MONTH_SYMBOL() + { + $this->setType(self::MONTH_SYMBOL); + } + + protected function MULTILINESTRING_SYMBOL() + { + $this->setType(self::MULTILINESTRING_SYMBOL); + } + + protected function MULTIPOINT_SYMBOL() + { + $this->setType(self::MULTIPOINT_SYMBOL); + } + + protected function MULTIPOLYGON_SYMBOL() + { + $this->setType(self::MULTIPOLYGON_SYMBOL); + } + + protected function MUTEX_SYMBOL() + { + $this->setType(self::MUTEX_SYMBOL); + } + + protected function MYSQL_ERRNO_SYMBOL() + { + $this->setType(self::MYSQL_ERRNO_SYMBOL); + } + + protected function NAME_SYMBOL() + { + $this->setType(self::NAME_SYMBOL); + } + + protected function NAMES_SYMBOL() + { + $this->setType(self::NAMES_SYMBOL); + } + + protected function NATIONAL_SYMBOL() + { + $this->setType(self::NATIONAL_SYMBOL); + } + + protected function NATURAL_SYMBOL() + { + $this->setType(self::NATURAL_SYMBOL); + } + + protected function NCHAR_SYMBOL() + { + $this->setType(self::NCHAR_SYMBOL); + } + + protected function NDBCLUSTER_SYMBOL() + { + $this->setType(self::NDBCLUSTER_SYMBOL); + } + + protected function NDB_SYMBOL() + { + $this->setType(self::NDBCLUSTER_SYMBOL); // Synonym + } + + protected function NEG_SYMBOL() + { + $this->setType(self::NEG_SYMBOL); + } + + protected function NESTED_SYMBOL() + { + $this->setType(self::NESTED_SYMBOL); + } + + protected function NEVER_SYMBOL() + { + $this->setType(self::NEVER_SYMBOL); + } + + protected function NEW_SYMBOL() + { + $this->setType(self::NEW_SYMBOL); + } + + protected function NEXT_SYMBOL() + { + $this->setType(self::NEXT_SYMBOL); + } + + protected function NODEGROUP_SYMBOL() + { + $this->setType(self::NODEGROUP_SYMBOL); + } + + protected function NONE_SYMBOL() + { + $this->setType(self::NONE_SYMBOL); + } + + protected function NONBLOCKING_SYMBOL() + { + $this->setType(self::NONBLOCKING_SYMBOL); + } + + protected function NOT2_SYMBOL() + { + $this->setType(self::NOT2_SYMBOL); + } + + protected function NOT_SYMBOL() + { + if ($this->isSqlModeActive(MySQLLexer::HighNotPrecedence)) { + $this->setType(self::NOT2_SYMBOL); + } else { + $this->setType(self::NOT_SYMBOL); + } + } + + protected function NOW_SYMBOL() + { + $this->setType($this->determineFunction(self::NOW_SYMBOL)); + } + + protected function NOWAIT_SYMBOL() + { + $this->setType(self::NOWAIT_SYMBOL); + } + + protected function NO_SYMBOL() + { + $this->setType(self::NO_SYMBOL); + } + + protected function NO_WAIT_SYMBOL() + { + $this->setType(self::NO_WAIT_SYMBOL); + } + + protected function NO_WRITE_TO_BINLOG_SYMBOL() + { + $this->setType(self::NO_WRITE_TO_BINLOG_SYMBOL); + } + + protected function NULL_SYMBOL() + { + $this->setType(self::NULL_SYMBOL); + } + + protected function NULLS_SYMBOL() + { + $this->setType(self::NULLS_SYMBOL); + } + + protected function NUMBER_SYMBOL() + { + $this->setType(self::NUMBER_SYMBOL); + } + + protected function NUMERIC_SYMBOL() + { + $this->setType(self::NUMERIC_SYMBOL); + } + + protected function NVARCHAR_SYMBOL() + { + $this->setType(self::NVARCHAR_SYMBOL); + } + + protected function NTH_VALUE_SYMBOL() + { + $this->setType(self::NTH_VALUE_SYMBOL); + } + + protected function NTILE_SYMBOL() + { + $this->setType(self::NTILE_SYMBOL); + } + + protected function OF_SYMBOL() + { + $this->setType(self::OF_SYMBOL); + } + + protected function OFF_SYMBOL() + { + $this->setType(self::OFF_SYMBOL); + } + + protected function OFFLINE_SYMBOL() + { + $this->setType(self::OFFLINE_SYMBOL); + } + + protected function OFFSET_SYMBOL() + { + $this->setType(self::OFFSET_SYMBOL); + } + + protected function OJ_SYMBOL() + { + $this->setType(self::OJ_SYMBOL); + } + + protected function OLD_PASSWORD_SYMBOL() + { + $this->setType(self::OLD_PASSWORD_SYMBOL); + } + + protected function OLD_SYMBOL() + { + $this->setType(self::OLD_SYMBOL); + } + + protected function ON_SYMBOL() + { + $this->setType(self::ON_SYMBOL); + } + + protected function ONLINE_SYMBOL() + { + $this->setType(self::ONLINE_SYMBOL); + } + + protected function ONE_SYMBOL() + { + $this->setType(self::ONE_SYMBOL); + } + + protected function ONLY_SYMBOL() + { + $this->setType(self::ONLY_SYMBOL); + } + + protected function OPEN_SYMBOL() + { + $this->setType(self::OPEN_SYMBOL); + } + + protected function OPTIONAL_SYMBOL() + { + $this->setType(self::OPTIONAL_SYMBOL); + } + + protected function OPTIONALLY_SYMBOL() + { + $this->setType(self::OPTIONALLY_SYMBOL); + } + + protected function OPTION_SYMBOL() + { + $this->setType(self::OPTION_SYMBOL); + } + + protected function OPTIONS_SYMBOL() + { + $this->setType(self::OPTIONS_SYMBOL); + } + + protected function OPTIMIZE_SYMBOL() + { + $this->setType(self::OPTIMIZE_SYMBOL); + } + + protected function OPTIMIZER_COSTS_SYMBOL() + { + $this->setType(self::OPTIMIZER_COSTS_SYMBOL); + } + + protected function ORDER_SYMBOL() + { + $this->setType(self::ORDER_SYMBOL); + } + + protected function ORDINALITY_SYMBOL() + { + $this->setType(self::ORDINALITY_SYMBOL); + } + + protected function ORGANIZATION_SYMBOL() + { + $this->setType(self::ORGANIZATION_SYMBOL); + } + + protected function OR_SYMBOL() + { + $this->setType(self::OR_SYMBOL); + } + + protected function OTHERS_SYMBOL() + { + $this->setType(self::OTHERS_SYMBOL); + } + + protected function OUTER_SYMBOL() + { + $this->setType(self::OUTER_SYMBOL); + } + + protected function OUTFILE_SYMBOL() + { + $this->setType(self::OUTFILE_SYMBOL); + } + + protected function OUT_SYMBOL() + { + $this->setType(self::OUT_SYMBOL); + } + + protected function OWNER_SYMBOL() + { + $this->setType(self::OWNER_SYMBOL); + } + + protected function PACK_KEYS_SYMBOL() + { + $this->setType(self::PACK_KEYS_SYMBOL); + } + + protected function PAGE_SYMBOL() + { + $this->setType(self::PAGE_SYMBOL); + } + + protected function PARSER_SYMBOL() + { + $this->setType(self::PARSER_SYMBOL); + } + + protected function PARTITIONS_SYMBOL() + { + $this->setType(self::PARTITIONS_SYMBOL); + } + + protected function PARTITION_SYMBOL() + { + $this->setType(self::PARTITION_SYMBOL); + } + + protected function PARTIAL_SYMBOL() + { + $this->setType(self::PARTIAL_SYMBOL); + } + + protected function PARTITIONING_SYMBOL() + { + $this->setType(self::PARTITIONING_SYMBOL); + } + + protected function PASSWORD_SYMBOL() + { + $this->setType(self::PASSWORD_SYMBOL); + } + + protected function PATH_SYMBOL() + { + $this->setType(self::PATH_SYMBOL); + } + + protected function PERCENT_RANK_SYMBOL() + { + $this->setType(self::PERCENT_RANK_SYMBOL); + } + + protected function PERSIST_SYMBOL() + { + $this->setType(self::PERSIST_SYMBOL); + } + + protected function PERSIST_ONLY_SYMBOL() + { + $this->setType(self::PERSIST_ONLY_SYMBOL); + } + + protected function PHASE_SYMBOL() + { + $this->setType(self::PHASE_SYMBOL); + } + + protected function PLUGIN_SYMBOL() + { + $this->setType(self::PLUGIN_SYMBOL); + } + + protected function PLUGINS_SYMBOL() + { + $this->setType(self::PLUGINS_SYMBOL); + } + + protected function PLUGIN_DIR_SYMBOL() + { + $this->setType(self::PLUGIN_DIR_SYMBOL); + } + + protected function POINT_SYMBOL() + { + $this->setType(self::POINT_SYMBOL); + } + + protected function POLYGON_SYMBOL() + { + $this->setType(self::POLYGON_SYMBOL); + } + + protected function PORT_SYMBOL() + { + $this->setType(self::PORT_SYMBOL); + } + + protected function POSITION_SYMBOL() + { + $this->setType($this->determineFunction(self::POSITION_SYMBOL)); // SQL-2003-N + } + + protected function PRECEDES_SYMBOL() + { + $this->setType(self::PRECEDES_SYMBOL); + } + + protected function PRECEDING_SYMBOL() + { + $this->setType(self::PRECEDING_SYMBOL); + } + + protected function PRECISION_SYMBOL() + { + $this->setType(self::PRECISION_SYMBOL); + } + + protected function PREPARE_SYMBOL() + { + $this->setType(self::PREPARE_SYMBOL); + } + + protected function PRESERVE_SYMBOL() + { + $this->setType(self::PRESERVE_SYMBOL); + } + + protected function PREV_SYMBOL() + { + $this->setType(self::PREV_SYMBOL); + } + + protected function PRIMARY_SYMBOL() + { + $this->setType(self::PRIMARY_SYMBOL); + } + + protected function PRIVILEGES_SYMBOL() + { + $this->setType(self::PRIVILEGES_SYMBOL); + } + + protected function PRIVILEGE_CHECKS_USER_SYMBOL() + { + $this->setType(self::PRIVILEGE_CHECKS_USER_SYMBOL); + } + + protected function PROCEDURE_SYMBOL() + { + $this->setType(self::PROCEDURE_SYMBOL); + } + + protected function PROCESS_SYMBOL() + { + $this->setType(self::PROCESS_SYMBOL); + } + + protected function PROCESSLIST_SYMBOL() + { + $this->setType(self::PROCESSLIST_SYMBOL); + } + + protected function PROFILE_SYMBOL() + { + $this->setType(self::PROFILE_SYMBOL); + } + + protected function PROFILES_SYMBOL() + { + $this->setType(self::PROFILES_SYMBOL); + } + + protected function PROXY_SYMBOL() + { + $this->setType(self::PROXY_SYMBOL); + } + + protected function PURGE_SYMBOL() + { + $this->setType(self::PURGE_SYMBOL); + } + + protected function QUARTER_SYMBOL() + { + $this->setType(self::QUARTER_SYMBOL); + } + + protected function QUERY_SYMBOL() + { + $this->setType(self::QUERY_SYMBOL); + } + + protected function QUICK_SYMBOL() + { + $this->setType(self::QUICK_SYMBOL); + } + + protected function RANDOM_SYMBOL() + { + $this->setType(self::RANDOM_SYMBOL); + } + + protected function RANGE_SYMBOL() + { + $this->setType(self::RANGE_SYMBOL); + } + + protected function RANK_SYMBOL() + { + $this->setType(self::RANK_SYMBOL); + } + + protected function READS_SYMBOL() + { + $this->setType(self::READS_SYMBOL); + } + + protected function READ_ONLY_SYMBOL() + { + $this->setType(self::READ_ONLY_SYMBOL); + } + + protected function READ_SYMBOL() + { + $this->setType(self::READ_SYMBOL); + } + + protected function READ_WRITE_SYMBOL() + { + $this->setType(self::READ_WRITE_SYMBOL); + } + + protected function REAL_SYMBOL() + { + $this->setType(self::REAL_SYMBOL); + } + + protected function REBUILD_SYMBOL() + { + $this->setType(self::REBUILD_SYMBOL); + } + + protected function RECOVER_SYMBOL() + { + $this->setType(self::RECOVER_SYMBOL); + } + + protected function REDOFILE_SYMBOL() + { + $this->setType(self::REDOFILE_SYMBOL); + } + + protected function REDO_BUFFER_SIZE_SYMBOL() + { + $this->setType(self::REDO_BUFFER_SIZE_SYMBOL); + } + + protected function REDUNDANT_SYMBOL() + { + $this->setType(self::REDUNDANT_SYMBOL); + } + + protected function REFERENCES_SYMBOL() + { + $this->setType(self::REFERENCES_SYMBOL); + } + + protected function REFERENCE_SYMBOL() + { + $this->setType(self::REFERENCE_SYMBOL); + } + + protected function RECURSIVE_SYMBOL() + { + $this->setType(self::RECURSIVE_SYMBOL); + } + + protected function REGEXP_SYMBOL() + { + $this->setType(self::REGEXP_SYMBOL); + } + + protected function RELAY_SYMBOL() + { + $this->setType(self::RELAY_SYMBOL); + } + + protected function RELAYLOG_SYMBOL() + { + $this->setType(self::RELAYLOG_SYMBOL); + } + + protected function RELAY_LOG_FILE_SYMBOL() + { + $this->setType(self::RELAY_LOG_FILE_SYMBOL); + } + + protected function RELAY_LOG_POS_SYMBOL() + { + $this->setType(self::RELAY_LOG_POS_SYMBOL); + } + + protected function RELAY_THREAD_SYMBOL() + { + $this->setType(self::RELAY_THREAD_SYMBOL); + } + + protected function RELEASE_SYMBOL() + { + $this->setType(self::RELEASE_SYMBOL); + } + + protected function RELOAD_SYMBOL() + { + $this->setType(self::RELOAD_SYMBOL); + } + + protected function REMOTE_SYMBOL() + { + $this->setType(self::REMOTE_SYMBOL); + } + + protected function REMOVE_SYMBOL() + { + $this->setType(self::REMOVE_SYMBOL); + } + + protected function RENAME_SYMBOL() + { + $this->setType(self::RENAME_SYMBOL); + } + + protected function REORGANIZE_SYMBOL() + { + $this->setType(self::REORGANIZE_SYMBOL); + } + + protected function REPAIR_SYMBOL() + { + $this->setType(self::REPAIR_SYMBOL); + } + + protected function REPEAT_SYMBOL() + { + $this->setType(self::REPEAT_SYMBOL); + } + + protected function REPEATABLE_SYMBOL() + { + $this->setType(self::REPEATABLE_SYMBOL); + } + + protected function REPLACE_SYMBOL() + { + $this->setType(self::REPLACE_SYMBOL); + } + + protected function REPLICATION_SYMBOL() + { + $this->setType(self::REPLICATION_SYMBOL); + } + + protected function REPLICATE_DO_DB_SYMBOL() + { + $this->setType(self::REPLICATE_DO_DB_SYMBOL); + } + + protected function REPLICATE_DO_TABLE_SYMBOL() + { + $this->setType(self::REPLICATE_DO_TABLE_SYMBOL); + } + + protected function REPLICATE_IGNORE_DB_SYMBOL() + { + $this->setType(self::REPLICATE_IGNORE_DB_SYMBOL); + } + + protected function REPLICATE_IGNORE_TABLE_SYMBOL() + { + $this->setType(self::REPLICATE_IGNORE_TABLE_SYMBOL); + } + + protected function REPLICATE_REWRITE_DB_SYMBOL() + { + $this->setType(self::REPLICATE_REWRITE_DB_SYMBOL); + } + + protected function REPLICATE_WILD_DO_TABLE_SYMBOL() + { + $this->setType(self::REPLICATE_WILD_DO_TABLE_SYMBOL); + } + + protected function REPLICATE_WILD_IGNORE_TABLE_SYMBOL() + { + $this->setType(self::REPLICATE_WILD_IGNORE_TABLE_SYMBOL); + } + + protected function REQUIRE_SYMBOL() + { + $this->setType(self::REQUIRE_SYMBOL); + } + + protected function REQUIRE_ROW_FORMAT_SYMBOL() + { + $this->setType(self::REQUIRE_ROW_FORMAT_SYMBOL); + } + + protected function REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL() + { + $this->setType(self::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL); + } + + protected function RESOURCE_SYMBOL() + { + $this->setType(self::RESOURCE_SYMBOL); + } + + protected function RESPECT_SYMBOL() + { + $this->setType(self::RESPECT_SYMBOL); + } + + protected function RESTART_SYMBOL() + { + $this->setType(self::RESTART_SYMBOL); + } + + protected function RESTORE_SYMBOL() + { + $this->setType(self::RESTORE_SYMBOL); + } + + protected function RESTRICT_SYMBOL() + { + $this->setType(self::RESTRICT_SYMBOL); + } + + protected function RESUME_SYMBOL() + { + $this->setType(self::RESUME_SYMBOL); + } + + protected function RETAIN_SYMBOL() + { + $this->setType(self::RETAIN_SYMBOL); + } + + protected function RETURN_SYMBOL() + { + $this->setType(self::RETURN_SYMBOL); + } + + protected function RETURNED_SQLSTATE_SYMBOL() + { + $this->setType(self::RETURNED_SQLSTATE_SYMBOL); + } + + protected function RETURNS_SYMBOL() + { + $this->setType(self::RETURNS_SYMBOL); + } + + protected function REUSE_SYMBOL() + { + $this->setType(self::REUSE_SYMBOL); + } + + protected function REVERSE_SYMBOL() + { + $this->setType(self::REVERSE_SYMBOL); + } + + protected function REVOKE_SYMBOL() + { + $this->setType(self::REVOKE_SYMBOL); + } + + protected function RIGHT_SYMBOL() + { + $this->setType(self::RIGHT_SYMBOL); + } + + protected function RLIKE_SYMBOL() + { + $this->setType(self::REGEXP_SYMBOL); // Synonym + } + + protected function ROLE_SYMBOL() + { + $this->setType(self::ROLE_SYMBOL); + } + + protected function ROLLBACK_SYMBOL() + { + $this->setType(self::ROLLBACK_SYMBOL); + } + + protected function ROLLUP_SYMBOL() + { + $this->setType(self::ROLLUP_SYMBOL); + } + + protected function ROTATE_SYMBOL() + { + $this->setType(self::ROTATE_SYMBOL); + } + + protected function ROW_SYMBOL() + { + $this->setType(self::ROW_SYMBOL); + } + + protected function ROWS_SYMBOL() + { + $this->setType(self::ROWS_SYMBOL); + } + + protected function ROW_COUNT_SYMBOL() + { + $this->setType(self::ROW_COUNT_SYMBOL); + } + + protected function ROW_FORMAT_SYMBOL() + { + $this->setType(self::ROW_FORMAT_SYMBOL); + } + + protected function ROW_NUMBER_SYMBOL() + { + $this->setType(self::ROW_NUMBER_SYMBOL); + } + + protected function RTREE_SYMBOL() + { + $this->setType(self::RTREE_SYMBOL); + } + + protected function SAVEPOINT_SYMBOL() + { + $this->setType(self::SAVEPOINT_SYMBOL); + } + + protected function SCHEMA_NAME_SYMBOL() + { + $this->setType(self::SCHEMA_NAME_SYMBOL); + } + + protected function SCHEMAS_SYMBOL() + { + $this->setType(self::DATABASES_SYMBOL); // Synonym + } + + protected function SCHEMA_SYMBOL() + { + $this->setType(self::DATABASE_SYMBOL); // Synonym + } + + protected function SCHEDULE_SYMBOL() + { + $this->setType(self::SCHEDULE_SYMBOL); + } + + protected function SECOND_SYMBOL() + { + $this->setType(self::SECOND_SYMBOL); + } + + protected function SECOND_MICROSECOND_SYMBOL() + { + $this->setType(self::SECOND_MICROSECOND_SYMBOL); + } + + protected function SECONDARY_SYMBOL() + { + $this->setType(self::SECONDARY_SYMBOL); + } + + protected function SECONDARY_ENGINE_SYMBOL() + { + $this->setType(self::SECONDARY_ENGINE_SYMBOL); + } + + protected function SECONDARY_LOAD_SYMBOL() + { + $this->setType(self::SECONDARY_LOAD_SYMBOL); + } + + protected function SECONDARY_UNLOAD_SYMBOL() + { + $this->setType(self::SECONDARY_UNLOAD_SYMBOL); + } + + protected function SECURITY_SYMBOL() + { + $this->setType(self::SECURITY_SYMBOL); + } + + protected function SELECT_SYMBOL() + { + $this->setType(self::SELECT_SYMBOL); + } + + protected function SENSITIVE_SYMBOL() + { + $this->setType(self::SENSITIVE_SYMBOL); + } + + protected function SEPARATOR_SYMBOL() + { + $this->setType(self::SEPARATOR_SYMBOL); + } + + protected function SERIALIZABLE_SYMBOL() + { + $this->setType(self::SERIALIZABLE_SYMBOL); + } + + protected function SERIAL_SYMBOL() + { + $this->setType(self::SERIAL_SYMBOL); + } + + protected function SERVER_SYMBOL() + { + $this->setType(self::SERVER_SYMBOL); + } + + protected function SERVER_OPTIONS_SYMBOL() + { + $this->setType(self::SERVER_OPTIONS_SYMBOL); + } + + protected function SESSION_SYMBOL() + { + $this->setType(self::SESSION_SYMBOL); + } + + protected function SESSION_USER_SYMBOL() + { + $this->setType($this->determineFunction(self::USER_SYMBOL)); // Synonym + } + + protected function SET_SYMBOL() + { + $this->setType(self::SET_SYMBOL); + } + + protected function SET_VAR_SYMBOL() + { + $this->setType(self::SET_VAR_SYMBOL); + } + + protected function SHARE_SYMBOL() + { + $this->setType(self::SHARE_SYMBOL); + } + + protected function SHOW_SYMBOL() + { + $this->setType(self::SHOW_SYMBOL); + } + + protected function SHUTDOWN_SYMBOL() + { + $this->setType(self::SHUTDOWN_SYMBOL); + } + + protected function SIGNAL_SYMBOL() + { + $this->setType(self::SIGNAL_SYMBOL); + } + + protected function SIGNED_SYMBOL() + { + $this->setType(self::SIGNED_SYMBOL); + } + + protected function SIMPLE_SYMBOL() + { + $this->setType(self::SIMPLE_SYMBOL); + } + + protected function SKIP_SYMBOL() + { + $this->setType(self::SKIP_SYMBOL); + } + + protected function SLAVE_SYMBOL() + { + $this->setType(self::SLAVE_SYMBOL); + } + + protected function SLOW_SYMBOL() + { + $this->setType(self::SLOW_SYMBOL); + } + + protected function SMALLINT_SYMBOL() + { + $this->setType(self::SMALLINT_SYMBOL); + } + + protected function SNAPSHOT_SYMBOL() + { + $this->setType(self::SNAPSHOT_SYMBOL); + } + + protected function SOME_SYMBOL() + { + $this->setType(self::ANY_SYMBOL); // Synonym + } + + protected function SOCKET_SYMBOL() + { + $this->setType(self::SOCKET_SYMBOL); + } + + protected function SONAME_SYMBOL() + { + $this->setType(self::SONAME_SYMBOL); + } + + protected function SOUNDS_SYMBOL() + { + $this->setType(self::SOUNDS_SYMBOL); + } + + protected function SOURCE_SYMBOL() + { + $this->setType(self::SOURCE_SYMBOL); + } + + protected function SPATIAL_SYMBOL() + { + $this->setType(self::SPATIAL_SYMBOL); + } + + protected function SPECIFIC_SYMBOL() + { + $this->setType(self::SPECIFIC_SYMBOL); + } + + protected function SQLEXCEPTION_SYMBOL() + { + $this->setType(self::SQLEXCEPTION_SYMBOL); + } + + protected function SQLSTATE_SYMBOL() + { + $this->setType(self::SQLSTATE_SYMBOL); + } + + protected function SQLWARNING_SYMBOL() + { + $this->setType(self::SQLWARNING_SYMBOL); + } + + protected function SQL_AFTER_GTIDS_SYMBOL() + { + $this->setType(self::SQL_AFTER_GTIDS_SYMBOL); + } + + protected function SQL_AFTER_MTS_GAPS_SYMBOL() + { + $this->setType(self::SQL_AFTER_MTS_GAPS_SYMBOL); + } + + protected function SQL_BEFORE_GTIDS_SYMBOL() + { + $this->setType(self::SQL_BEFORE_GTIDS_SYMBOL); + } + + protected function SQL_BIG_RESULT_SYMBOL() + { + $this->setType(self::SQL_BIG_RESULT_SYMBOL); + } + + protected function SQL_BUFFER_RESULT_SYMBOL() + { + $this->setType(self::SQL_BUFFER_RESULT_SYMBOL); + } + + protected function SQL_CALC_FOUND_ROWS_SYMBOL() + { + $this->setType(self::SQL_CALC_FOUND_ROWS_SYMBOL); + } + + protected function SQL_CACHE_SYMBOL() + { + $this->setType(self::SQL_CACHE_SYMBOL); + } + + protected function SQL_NO_CACHE_SYMBOL() + { + $this->setType(self::SQL_NO_CACHE_SYMBOL); + } + + protected function SQL_SMALL_RESULT_SYMBOL() + { + $this->setType(self::SQL_SMALL_RESULT_SYMBOL); + } + + protected function SQL_SYMBOL() + { + $this->setType(self::SQL_SYMBOL); + } + + protected function SQL_THREAD_SYMBOL() + { + $this->setType(self::SQL_THREAD_SYMBOL); + } + + protected function SQL_TSI_SECOND_SYMBOL() + { + $this->setType(self::SECOND_SYMBOL); // Synonym + } + + protected function SQL_TSI_MINUTE_SYMBOL() + { + $this->setType(self::MINUTE_SYMBOL); // Synonym + } + + protected function SQL_TSI_HOUR_SYMBOL() + { + $this->setType(self::HOUR_SYMBOL); // Synonym + } + + protected function SQL_TSI_DAY_SYMBOL() + { + $this->setType(self::DAY_SYMBOL); // Synonym + } + + protected function SQL_TSI_WEEK_SYMBOL() + { + $this->setType(self::WEEK_SYMBOL); // Synonym + } + + protected function SQL_TSI_MONTH_SYMBOL() + { + $this->setType(self::MONTH_SYMBOL); // Synonym + } + + protected function SQL_TSI_QUARTER_SYMBOL() + { + $this->setType(self::QUARTER_SYMBOL); // Synonym + } + + protected function SQL_TSI_YEAR_SYMBOL() + { + $this->setType(self::YEAR_SYMBOL); // Synonym + } + + protected function SRID_SYMBOL() + { + $this->setType(self::SRID_SYMBOL); + } + + protected function SSL_SYMBOL() + { + $this->setType(self::SSL_SYMBOL); + } + + protected function STACKED_SYMBOL() + { + $this->setType(self::STACKED_SYMBOL); + } + + protected function STARTING_SYMBOL() + { + $this->setType(self::STARTING_SYMBOL); + } + + protected function STARTS_SYMBOL() + { + $this->setType(self::STARTS_SYMBOL); + } + + protected function START_SYMBOL() + { + $this->setType(self::START_SYMBOL); + } + + protected function STATS_AUTO_RECALC_SYMBOL() + { + $this->setType(self::STATS_AUTO_RECALC_SYMBOL); + } + + protected function STATS_PERSISTENT_SYMBOL() + { + $this->setType(self::STATS_PERSISTENT_SYMBOL); + } + + protected function STATS_SAMPLE_PAGES_SYMBOL() + { + $this->setType(self::STATS_SAMPLE_PAGES_SYMBOL); + } + + protected function STATUS_SYMBOL() + { + $this->setType(self::STATUS_SYMBOL); + } + + protected function STD_SYMBOL() + { + $this->setType($this->determineFunction(self::STD_SYMBOL)); + } + + protected function STDDEV_SYMBOL() + { + $this->setType($this->determineFunction(self::STD_SYMBOL)); // Synonym + } + + protected function STDDEV_POP_SYMBOL() + { + $this->setType($this->determineFunction(self::STD_SYMBOL)); // Synonym + } + + protected function STDDEV_SAMP_SYMBOL() + { + $this->setType($this->determineFunction(self::STDDEV_SAMP_SYMBOL)); // SQL-2003-N + } + + protected function STOP_SYMBOL() + { + $this->setType(self::STOP_SYMBOL); + } + + protected function STORAGE_SYMBOL() + { + $this->setType(self::STORAGE_SYMBOL); + } + + protected function STORED_SYMBOL() + { + $this->setType(self::STORED_SYMBOL); + } + + protected function STRAIGHT_JOIN_SYMBOL() + { + $this->setType(self::STRAIGHT_JOIN_SYMBOL); + } + + protected function STREAM_SYMBOL() + { + $this->setType(self::STREAM_SYMBOL); + } + + protected function STRING_SYMBOL() + { + $this->setType(self::STRING_SYMBOL); + } + + protected function SUBCLASS_ORIGIN_SYMBOL() + { + $this->setType(self::SUBCLASS_ORIGIN_SYMBOL); + } + + protected function SUBDATE_SYMBOL() + { + $this->setType($this->determineFunction(self::SUBDATE_SYMBOL)); + } + + protected function SUBJECT_SYMBOL() + { + $this->setType(self::SUBJECT_SYMBOL); + } + + protected function SUBPARTITION_SYMBOL() + { + $this->setType(self::SUBPARTITION_SYMBOL); + } + + protected function SUBPARTITIONS_SYMBOL() + { + $this->setType(self::SUBPARTITIONS_SYMBOL); + } + + protected function SUBSTR_SYMBOL() + { + $this->setType($this->determineFunction(self::SUBSTRING_SYMBOL)); // Synonym + } + + protected function SUBSTRING_SYMBOL() + { + $this->setType($this->determineFunction(self::SUBSTRING_SYMBOL)); // SQL-2003-N + } + + protected function SUM_SYMBOL() + { + $this->setType($this->determineFunction(self::SUM_SYMBOL)); // SQL-2003-N + } + + protected function SUPER_SYMBOL() + { + $this->setType(self::SUPER_SYMBOL); + } + + protected function SUSPEND_SYMBOL() + { + $this->setType(self::SUSPEND_SYMBOL); + } + + protected function SWAPS_SYMBOL() + { + $this->setType(self::SWAPS_SYMBOL); + } + + protected function SWITCHES_SYMBOL() + { + $this->setType(self::SWITCHES_SYMBOL); + } + + protected function SYSDATE_SYMBOL() + { + $this->setType($this->determineFunction(self::SYSDATE_SYMBOL)); + } + + protected function SYSTEM_SYMBOL() + { + $this->setType(self::SYSTEM_SYMBOL); + } + + protected function SYSTEM_USER_SYMBOL() + { + $this->setType($this->determineFunction(self::USER_SYMBOL)); + } + + protected function TABLE_CHECKSUM_SYMBOL() + { + $this->setType(self::TABLE_CHECKSUM_SYMBOL); + } + + protected function TABLE_SYMBOL() + { + $this->setType(self::TABLE_SYMBOL); + } + + protected function TABLES_SYMBOL() + { + $this->setType(self::TABLES_SYMBOL); + } + + protected function TABLESPACE_SYMBOL() + { + $this->setType(self::TABLESPACE_SYMBOL); + } + + protected function TABLE_NAME_SYMBOL() + { + $this->setType(self::TABLE_NAME_SYMBOL); + } + + protected function TEMPORARY_SYMBOL() + { + $this->setType(self::TEMPORARY_SYMBOL); + } + + protected function TEMPTABLE_SYMBOL() + { + $this->setType(self::TEMPTABLE_SYMBOL); + } + + protected function TERMINATED_SYMBOL() + { + $this->setType(self::TERMINATED_SYMBOL); + } + + protected function TEXT_SYMBOL() + { + $this->setType(self::TEXT_SYMBOL); + } + + protected function THAN_SYMBOL() + { + $this->setType(self::THAN_SYMBOL); + } + + protected function THEN_SYMBOL() + { + $this->setType(self::THEN_SYMBOL); + } + + protected function THREAD_PRIORITY_SYMBOL() + { + $this->setType(self::THREAD_PRIORITY_SYMBOL); + } + + protected function TIES_SYMBOL() + { + $this->setType(self::TIES_SYMBOL); + } + + protected function TIME_SYMBOL() + { + $this->setType(self::TIME_SYMBOL); + } + + protected function TIMESTAMP_SYMBOL() + { + $this->setType(self::TIMESTAMP_SYMBOL); + } + + protected function TIMESTAMP_ADD_SYMBOL() + { + $this->setType(self::TIMESTAMP_ADD_SYMBOL); + } + + protected function TIMESTAMP_DIFF_SYMBOL() + { + $this->setType(self::TIMESTAMP_DIFF_SYMBOL); + } + + protected function TINYBLOB_SYMBOL() + { + $this->setType(self::TINYBLOB_SYMBOL); + } + + protected function TINYINT_SYMBOL() + { + $this->setType(self::TINYINT_SYMBOL); + } + + protected function TINYTEXT_SYMBOL() + { + $this->setType(self::TINYTEXT_SYMBOL); + } + + protected function TO_SYMBOL() + { + $this->setType(self::TO_SYMBOL); + } + + protected function TRAILING_SYMBOL() + { + $this->setType(self::TRAILING_SYMBOL); + } + + protected function TRANSACTION_SYMBOL() + { + $this->setType(self::TRANSACTION_SYMBOL); + } + + protected function TRIGGERS_SYMBOL() + { + $this->setType(self::TRIGGERS_SYMBOL); + } + + protected function TRIGGER_SYMBOL() + { + $this->setType(self::TRIGGER_SYMBOL); + } + + protected function TRIM_SYMBOL() + { + $this->setType($this->determineFunction(self::TRIM_SYMBOL)); // SQL-2003-N + } + + protected function TRUE_SYMBOL() + { + $this->setType(self::TRUE_SYMBOL); + } + + protected function TRUNCATE_SYMBOL() + { + $this->setType(self::TRUNCATE_SYMBOL); + } + + protected function TYPES_SYMBOL() + { + $this->setType(self::TYPES_SYMBOL); + } + + protected function TYPE_SYMBOL() + { + $this->setType(self::TYPE_SYMBOL); + } + + protected function UDF_RETURNS_SYMBOL() + { + $this->setType(self::UDF_RETURNS_SYMBOL); + } + + protected function UNBOUNDED_SYMBOL() + { + $this->setType(self::UNBOUNDED_SYMBOL); + } + + protected function UNCOMMITTED_SYMBOL() + { + $this->setType(self::UNCOMMITTED_SYMBOL); + } + + protected function UNDEFINED_SYMBOL() + { + $this->setType(self::UNDEFINED_SYMBOL); + } + + protected function UNDO_BUFFER_SIZE_SYMBOL() + { + $this->setType(self::UNDO_BUFFER_SIZE_SYMBOL); + } + + protected function UNDOFILE_SYMBOL() + { + $this->setType(self::UNDOFILE_SYMBOL); + } + + protected function UNDO_SYMBOL() + { + $this->setType(self::UNDO_SYMBOL); + } + + protected function UNICODE_SYMBOL() + { + $this->setType(self::UNICODE_SYMBOL); + } + + protected function UNION_SYMBOL() + { + $this->setType(self::UNION_SYMBOL); + } + + protected function UNIQUE_SYMBOL() + { + $this->setType(self::UNIQUE_SYMBOL); + } + + protected function UNKNOWN_SYMBOL() + { + $this->setType(self::UNKNOWN_SYMBOL); + } + + protected function UNINSTALL_SYMBOL() + { + $this->setType(self::UNINSTALL_SYMBOL); + } + + protected function UNSIGNED_SYMBOL() + { + $this->setType(self::UNSIGNED_SYMBOL); + } + + protected function UPDATE_SYMBOL() + { + $this->setType(self::UPDATE_SYMBOL); + } + + protected function UPGRADE_SYMBOL() + { + $this->setType(self::UPGRADE_SYMBOL); + } + + protected function USAGE_SYMBOL() + { + $this->setType(self::USAGE_SYMBOL); + } + + protected function USER_RESOURCES_SYMBOL() + { + $this->setType(self::USER_RESOURCES_SYMBOL); + } + + protected function USER_SYMBOL() + { + $this->setType(self::USER_SYMBOL); + } + + protected function USE_FRM_SYMBOL() + { + $this->setType(self::USE_FRM_SYMBOL); + } + + protected function USE_SYMBOL() + { + $this->setType(self::USE_SYMBOL); + } + + protected function USING_SYMBOL() + { + $this->setType(self::USING_SYMBOL); + } + + protected function UTC_DATE_SYMBOL() + { + $this->setType(self::UTC_DATE_SYMBOL); + } + + protected function UTC_TIME_SYMBOL() + { + $this->setType(self::UTC_TIME_SYMBOL); + } + + protected function UTC_TIMESTAMP_SYMBOL() + { + $this->setType(self::UTC_TIMESTAMP_SYMBOL); + } + + protected function VALIDATION_SYMBOL() + { + $this->setType(self::VALIDATION_SYMBOL); + } + + protected function VALUE_SYMBOL() + { + $this->setType(self::VALUE_SYMBOL); + } + + protected function VALUES_SYMBOL() + { + $this->setType(self::VALUES_SYMBOL); + } + + protected function VARBINARY_SYMBOL() + { + $this->setType(self::VARBINARY_SYMBOL); + } + + protected function VARCHAR_SYMBOL() + { + $this->setType(self::VARCHAR_SYMBOL); + } + + protected function VARCHARACTER_SYMBOL() + { + $this->setType(self::VARCHAR_SYMBOL); // Synonym + } + + protected function VARIABLES_SYMBOL() + { + $this->setType(self::VARIABLES_SYMBOL); + } + + protected function VARIANCE_SYMBOL() + { + $this->setType($this->determineFunction(self::VARIANCE_SYMBOL)); + } + + protected function VARYING_SYMBOL() + { + $this->setType(self::VARYING_SYMBOL); + } + + protected function VAR_POP_SYMBOL() + { + $this->setType($this->determineFunction(self::VARIANCE_SYMBOL)); // Synonym + } + + protected function VAR_SAMP_SYMBOL() + { + $this->setType($this->determineFunction(self::VAR_SAMP_SYMBOL)); + } + + protected function VCPU_SYMBOL() + { + $this->setType(self::VCPU_SYMBOL); + } + + protected function VIEW_SYMBOL() + { + $this->setType(self::VIEW_SYMBOL); + } + + protected function VIRTUAL_SYMBOL() + { + $this->setType(self::VIRTUAL_SYMBOL); + } + + protected function VISIBLE_SYMBOL() + { + $this->setType(self::VISIBLE_SYMBOL); + } + + protected function WAIT_SYMBOL() + { + $this->setType(self::WAIT_SYMBOL); + } + + protected function WARNINGS_SYMBOL() + { + $this->setType(self::WARNINGS_SYMBOL); + } + + protected function WEEK_SYMBOL() + { + $this->setType(self::WEEK_SYMBOL); + } + + protected function WHEN_SYMBOL() + { + $this->setType(self::WHEN_SYMBOL); + } + + protected function WEIGHT_STRING_SYMBOL() + { + $this->setType(self::WEIGHT_STRING_SYMBOL); + } + + protected function WHERE_SYMBOL() + { + $this->setType(self::WHERE_SYMBOL); + } + + protected function WHILE_SYMBOL() + { + $this->setType(self::WHILE_SYMBOL); + } + + protected function WINDOW_SYMBOL() + { + $this->setType(self::WINDOW_SYMBOL); + } + + protected function WITH_SYMBOL() + { + $this->setType(self::WITH_SYMBOL); + } + + protected function WITHOUT_SYMBOL() + { + $this->setType(self::WITHOUT_SYMBOL); + } + + protected function WORK_SYMBOL() + { + $this->setType(self::WORK_SYMBOL); + } + + protected function WRAPPER_SYMBOL() + { + $this->setType(self::WRAPPER_SYMBOL); + } + + protected function WRITE_SYMBOL() + { + $this->setType(self::WRITE_SYMBOL); + } + + protected function XA_SYMBOL() + { + $this->setType(self::XA_SYMBOL); + } + + protected function X509_SYMBOL() + { + $this->setType(self::X509_SYMBOL); + } + + protected function XID_SYMBOL() + { + $this->setType(self::XID_SYMBOL); + } + + protected function XML_SYMBOL() + { + $this->setType(self::XML_SYMBOL); + } + + protected function XOR_SYMBOL() + { + $this->setType(self::XOR_SYMBOL); + } + + protected function YEAR_MONTH_SYMBOL() + { + $this->setType(self::YEAR_MONTH_SYMBOL); + } + + protected function YEAR_SYMBOL() + { + $this->setType(self::YEAR_SYMBOL); + } + + protected function ZEROFILL_SYMBOL() + { + $this->setType(self::ZEROFILL_SYMBOL); + } + + protected function INT1_SYMBOL() + { + $this->setType(self::TINYINT_SYMBOL); // Synonym + } + + protected function INT2_SYMBOL() + { + $this->setType(self::SMALLINT_SYMBOL); // Synonym + } + + protected function INT3_SYMBOL() + { + $this->setType(self::MEDIUMINT_SYMBOL); // Synonym + } + + protected function INT4_SYMBOL() + { + $this->setType(self::INT_SYMBOL); // Synonym + } + + protected function INT8_SYMBOL() + { + $this->setType(self::BIGINT_SYMBOL); // Synonym + } + + protected function IDENTIFIER() + { + $this->setType(self::IDENTIFIER); + } + + protected function MYSQL_COMMENT_START() + { + // TODO: use a lexer mode instead of a member variable. + // Currently not used by the PHP target. + return; + } + + protected function VERSION_COMMENT_END() + { + // Currently not used by the PHP target. + return; + } + + protected function VERSION_COMMENT_START() + { + $this->consume(); // Consume the '/*'. + $this->consume(); // Consume the '!'. + while (safe_ctype_digit($this->c)) { + $this->consume(); + } + if ($this->checkVersion($this->getText())) { + // If the version check passes, consume the rest of the comment + while ($this->c !== null) { + if ($this->c === '*' && $this->n === '/') { + $this->consume(); // Consume the '*'. + $this->consume(); // Consume the '/'. + break; + } + $this->consume(); + } + } else { + // If the version check fails, skip to the end of the comment. + $this->skipCommentContent(); + } + + $this->channel = self::HIDDEN; + } + + protected function BLOCK_COMMENT() + { + $this->consume(); // Consume the '/'. + $this->consume(); // Consume the '*'. + $this->skipCommentContent(); + $this->channel = self::HIDDEN; + } + + // Helper functions ----------------------------------------------------------------------------------------------------- + + private function determineNumericType($text): int + { + if (preg_match('/^0[xX][0-9a-fA-F]+$/', $text)) { + return self::HEX_NUMBER; + } elseif (preg_match('/^0[bB][01]+$/', $text)) { + return self::BIN_NUMBER; + } elseif (preg_match('/^\d+$/', $text)) { + if (PHP_INT_MAX >= (int)$text) { + return self::INT_NUMBER; + } + return self::LONG_NUMBER; + } + return self::INVALID_INPUT; + } + + /** + * This is a place holder to support features of MySQLBaseLexer which are not yet implemented + * in the PHP target. + * + * @return int + */ + protected function determineFunction(int $type): int + { + return $type; + } +} + +class MySQLToken +{ + private $type; + private $text; + private $channel; + + public function __construct($type, $text, $channel=null) + { + $this->type = $type; + $this->text = $text; + $this->channel = $channel; + } + + public function getType() + { + return $this->type; + } + + public function getText() + { + return $this->text; + } + + public function getChannel() + { + return $this->channel; + } + + public function __toString() + { + return $this->text . ' (' . $this->type . ')'; + } +} diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php new file mode 100644 index 00000000..c9244419 --- /dev/null +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php @@ -0,0 +1,16610 @@ +type = $type; + if(is_array($value_or_children)) { + $this->children = $value_or_children; + } else { + $this->children = $children; + $this->value = $value_or_children; + } + } + + static public function fromToken(MySQLToken $token) + { + return new ASTNode( + MySQLLexer::getTokenName($token->getType()), + $token->getText() + ); + } + + public function __tostring() + { + return 'Token<' . $this->type . ($this->value ? ', ' . $this->value : '') . '>'; + } +} + + +class MySQLParser { + private $lexer; + private $serverVersion; + + public function __construct($lexer) + { + $this->lexer = $lexer; + $this->serverVersion = $lexer->getServerVersion(); + } + + public function query() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::EOF || $token->getType() === MySQLLexer::SEMICOLON_SYMBOL) { + return new ASTNode('query', [new ASTNode('EOF')]); + } + $children = []; + + while ($this->isSimpleStatementStart($this->lexer->peekNextToken())) { + $children[] = $this->simpleStatement(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::SEMICOLON_SYMBOL) { + $this->match(MySQLLexer::SEMICOLON_SYMBOL); + } + } + + if ($token->getType() === MySQLLexer::BEGIN_SYMBOL) { + $children[] = $this->beginWork(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::SEMICOLON_SYMBOL) { + $this->match(MySQLLexer::SEMICOLON_SYMBOL); + } + } + + if ( + $this->lexer->peekNextToken()->getType() !== MySQLLexer::EOF && + $this->lexer->peekNextToken()->getType() !== MySQLLexer::SEMICOLON_SYMBOL + ) { + throw new \Exception('Unexpected token: ' . $this->lexer->peekNextToken()->getText()); + } + + return new ASTNode('query', $children); + } + + public function simpleStatement() + { + $token = $this->lexer->peekNextToken(); + + switch ($token->getType()) { + // DDL + case MySQLLexer::ALTER_SYMBOL: + return $this->alterStatement(); + case MySQLLexer::CREATE_SYMBOL: + return $this->createStatement(); + case MySQLLexer::DROP_SYMBOL: + return $this->dropStatement(); + case MySQLLexer::RENAME_SYMBOL: + return $this->renameTableStatement(); + case MySQLLexer::TRUNCATE_SYMBOL: + return $this->truncateTableStatement(); + case MySQLLexer::IMPORT_SYMBOL: + if ($this->serverVersion >= 80000) { + return $this->importStatement(); + } + break; + + // DML + case MySQLLexer::CALL_SYMBOL: + return $this->callStatement(); + case MySQLLexer::DELETE_SYMBOL: + return $this->deleteStatement(); + case MySQLLexer::DO_SYMBOL: + return $this->doStatement(); + case MySQLLexer::HANDLER_SYMBOL: + return $this->handlerStatement(); + case MySQLLexer::INSERT_SYMBOL: + return $this->insertStatement(); + case MySQLLexer::LOAD_SYMBOL: + return $this->loadStatement(); + case MySQLLexer::REPLACE_SYMBOL: + return $this->replaceStatement(); + case MySQLLexer::WITH_SYMBOL: + case MySQLLexer::SELECT_SYMBOL: + return $this->selectStatement(); + case MySQLLexer::UPDATE_SYMBOL: + return $this->updateStatement(); + case MySQLLexer::START_SYMBOL: + case MySQLLexer::COMMIT_SYMBOL: + case MySQLLexer::SAVEPOINT_SYMBOL: + case MySQLLexer::ROLLBACK_SYMBOL: + case MySQLLexer::RELEASE_SYMBOL: + case MySQLLexer::LOCK_SYMBOL: + case MySQLLexer::UNLOCK_SYMBOL: + case MySQLLexer::XA_SYMBOL: + return $this->transactionOrLockingStatement(); + case MySQLLexer::PURGE_SYMBOL: + case MySQLLexer::CHANGE_SYMBOL: + case MySQLLexer::RESET_SYMBOL: + return $this->replicationStatement(); + case MySQLLexer::PREPARE_SYMBOL: + case MySQLLexer::EXECUTE_SYMBOL: + case MySQLLexer::DEALLOCATE_SYMBOL: + return $this->preparedStatement(); + + // Data Directory + case MySQLLexer::CLONE_SYMBOL: + if ($this->serverVersion >= 80000) { + return $this->cloneStatement(); + } + break; + + // Database administration + case MySQLLexer::CREATE_SYMBOL: + case MySQLLexer::DROP_SYMBOL: + case MySQLLexer::GRANT_SYMBOL: + case MySQLLexer::RENAME_SYMBOL: + case MySQLLexer::REVOKE_SYMBOL: + return $this->accountManagementStatement(); + case MySQLLexer::ANALYZE_SYMBOL: + case MySQLLexer::CHECK_SYMBOL: + case MySQLLexer::CHECKSUM_SYMBOL: + case MySQLLexer::OPTIMIZE_SYMBOL: + case MySQLLexer::REPAIR_SYMBOL: + return $this->tableAdministrationStatement(); + case MySQLLexer::SET_SYMBOL: + return $this->setStatement(); + case MySQLLexer::SHOW_SYMBOL: + return $this->showStatement(); + case MySQLLexer::BINLOG_SYMBOL: + case MySQLLexer::CACHE_SYMBOL: + case MySQLLexer::FLUSH_SYMBOL: + case MySQLLexer::KILL_SYMBOL: + case MySQLLexer::LOAD_SYMBOL: + return $this->otherAdministrativeStatement(); + + case MySQLLexer::SHUTDOWN_SYMBOL: + if ($this->serverVersion >= 50709) { + return $this->otherAdministrativeStatement(); + } + break; + + case MySQLLexer::ALTER_SYMBOL: + if ($this->serverVersion >= 50606) { + return $this->accountManagementStatement(); + } + break; + + // Resource groups + case MySQLLexer::CREATE_SYMBOL: + case MySQLLexer::ALTER_SYMBOL: + case MySQLLexer::SET_SYMBOL: + case MySQLLexer::DROP_SYMBOL: + if ($this->serverVersion >= 80000 && + $this->lexer->peekNextToken(2)->getType() === MySQLLexer::RESOURCE_SYMBOL) { + return $this->resourceGroupManagement(); + } + break; + + // MySQL utility statements + case MySQLLexer::EXPLAIN_SYMBOL: + case MySQLLexer::DESCRIBE_SYMBOL: + case MySQLLexer::DESC_SYMBOL: + case MySQLLexer::HELP_SYMBOL: + case MySQLLexer::USE_SYMBOL: + return $this->utilityStatement(); + + case MySQLLexer::RESTART_SYMBOL: + if ($this->serverVersion >= 80011) { + return $this->utilityStatement(); + } + break; + + case MySQLLexer::GET_SYMBOL: + if ($this->serverVersion >= 50604) { + return $this->getDiagnostics(); + } + break; + case MySQLLexer::SIGNAL_SYMBOL: + return $this->signalStatement(); + case MySQLLexer::RESIGNAL_SYMBOL: + return $this->resignalStatement(); + + // Plugin + case MySQLLexer::INSTALL_SYMBOL: + case MySQLLexer::UNINSTALL_SYMBOL: + return $this->installUninstallStatment(); + } + + throw new \Exception("Unknown simple statement starting with: " . $token->getText()); + } + + private function isSimpleStatementStart($token) + { + return $this->isDdlStatementStart($token) || + $this->isDmlStatementStart($token) || + $this->isAccountManagementStatementStart($token) || + $this->isTableAdministrationStatementStart($token) || + $this->isUtilityStatementStart($token) || + $token->getType() === MySQLLexer::SET_SYMBOL || + $token->getType() === MySQLLexer::SHOW_SYMBOL || + ($this->serverVersion >= 80000 && $token->getType() === MySQLLexer::CLONE_SYMBOL) || + $this->isOtherAdministrativeStatementStart($token) || + ($this->serverVersion >= 80000 && + $this->lexer->peekNextToken(2)->getType() === MySQLLexer::RESOURCE_SYMBOL) || + $token->getType() === MySQLLexer::INSTALL_SYMBOL || + $token->getType() === MySQLLexer::UNINSTALL_SYMBOL; + } + + private function isDdlStatementStart($token) + { + return $token->getType() === MySQLLexer::ALTER_SYMBOL || + $token->getType() === MySQLLexer::CREATE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + $token->getType() === MySQLLexer::TRUNCATE_SYMBOL || + ($this->serverVersion >= 80000 && $token->getType() === MySQLLexer::IMPORT_SYMBOL); + } + + private function isDmlStatementStart($token) + { + return $token->getType() === MySQLLexer::CALL_SYMBOL || + $token->getType() === MySQLLexer::DELETE_SYMBOL || + $token->getType() === MySQLLexer::DO_SYMBOL || + $token->getType() === MySQLLexer::HANDLER_SYMBOL || + $token->getType() === MySQLLexer::INSERT_SYMBOL || + $token->getType() === MySQLLexer::LOAD_SYMBOL || + $token->getType() === MySQLLexer::REPLACE_SYMBOL || + $token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::SELECT_SYMBOL || + $token->getType() === MySQLLexer::UPDATE_SYMBOL || + $this->isTransactionOrLockingStatementStart($token) || + $this->isReplicationStatementStart($token) || + $this->isPreparedStatementStart($token); + } + + private function isAccountManagementStatementStart($token) + { + return $token->getType() === MySQLLexer::CREATE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::GRANT_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + $token->getType() === MySQLLexer::REVOKE_SYMBOL || + ($this->serverVersion >= 50606 && $token->getType() === MySQLLexer::ALTER_SYMBOL) || + ($this->serverVersion >= 80000 && $token->getType() === MySQLLexer::SET_SYMBOL); + } + + private function isTableAdministrationStatementStart($token) + { + switch ($token->getType()) { + case MySQLLexer::ANALYZE_SYMBOL: + case MySQLLexer::CHECK_SYMBOL: + case MySQLLexer::CHECKSUM_SYMBOL: + case MySQLLexer::OPTIMIZE_SYMBOL: + case MySQLLexer::REPAIR_SYMBOL: + return true; + default: + return false; + } + + } + + private function isUtilityStatementStart($token) + { + return $token->getType() === MySQLLexer::EXPLAIN_SYMBOL || + $token->getType() === MySQLLexer::DESCRIBE_SYMBOL || + $token->getType() === MySQLLexer::DESC_SYMBOL || + $token->getType() === MySQLLexer::HELP_SYMBOL || + $token->getType() === MySQLLexer::USE_SYMBOL || + ($this->serverVersion >= 80011 && $token->getType() === MySQLLexer::RESTART_SYMBOL); + } + + private function isTransactionOrLockingStatementStart($token) + { + switch ($token->getType()) { + case MySQLLexer::START_SYMBOL: + case MySQLLexer::COMMIT_SYMBOL: + case MySQLLexer::SAVEPOINT_SYMBOL: + case MySQLLexer::ROLLBACK_SYMBOL: + case MySQLLexer::RELEASE_SYMBOL: + case MySQLLexer::LOCK_SYMBOL: + case MySQLLexer::UNLOCK_SYMBOL: + case MySQLLexer::XA_SYMBOL: + return true; + default: + return false; + } + + } + + private function isReplicationStatementStart($token) + { + return $token->getType() === MySQLLexer::PURGE_SYMBOL || + $token->getType() === MySQLLexer::CHANGE_SYMBOL || + $token->getType() === MySQLLexer::RESET_SYMBOL || + $token->getType() === MySQLLexer::START_SYMBOL || + $token->getType() === MySQLLexer::STOP_SYMBOL || + ($this->serverVersion >= 50700 && $token->getType() === MySQLLexer::LOAD_SYMBOL); + } + + private function isPreparedStatementStart($token) + { + switch ($token->getType()) { + case MySQLLexer::PREPARE_SYMBOL: + case MySQLLexer::EXECUTE_SYMBOL: + case MySQLLexer::DEALLOCATE_SYMBOL: + return true; + default: + return false; + } + + } + + private function isOtherAdministrativeStatementStart($token) + { + return $token->getType() === MySQLLexer::BINLOG_SYMBOL || + $token->getType() === MySQLLexer::CACHE_SYMBOL || + $token->getType() === MySQLLexer::FLUSH_SYMBOL || + $token->getType() === MySQLLexer::KILL_SYMBOL || + $token->getType() === MySQLLexer::LOAD_SYMBOL || + ($this->serverVersion >= 50709 && $token->getType() === MySQLLexer::SHUTDOWN_SYMBOL); + } + + //----------------- DDL statements ------------------------------------------------------------------------------------- + + public function alterStatement() + { + $this->match(MySQLLexer::ALTER_SYMBOL); + $token = $this->lexer->peekNextToken(); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::ALTER_SYMBOL))]; + + if ($token->getType() === MySQLLexer::TABLE_SYMBOL) { + $children[] = $this->alterTable(); + } elseif ($token->getType() === MySQLLexer::DATABASE_SYMBOL) { + $children[] = $this->alterDatabase(); + } elseif ($token->getType() === MySQLLexer::PROCEDURE_SYMBOL) { + $children[] = $this->match(MySQLLexer::PROCEDURE_SYMBOL); + $children[] = $this->procedureRef(); + $nextToken = $this->lexer->peekNextToken(); + if ($nextToken->getType() === MySQLLexer::COMMENT_SYMBOL || + $nextToken->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $nextToken->getType() === MySQLLexer::NO_SYMBOL || + $nextToken->getType() === MySQLLexer::CONTAINS_SYMBOL || + $nextToken->getType() === MySQLLexer::READS_SYMBOL || + $nextToken->getType() === MySQLLexer::MODIFIES_SYMBOL || + $nextToken->getType() === MySQLLexer::SQL_SYMBOL) { + $children[] = $this->routineAlterOptions(); + } + } elseif ($token->getType() === MySQLLexer::FUNCTION_SYMBOL) { + $children[] = $this->match(MySQLLexer::FUNCTION_SYMBOL); + $children[] = $this->functionRef(); + $nextToken = $this->lexer->peekNextToken(); + if ($nextToken->getType() === MySQLLexer::COMMENT_SYMBOL || + $nextToken->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $nextToken->getType() === MySQLLexer::NO_SYMBOL || + $nextToken->getType() === MySQLLexer::CONTAINS_SYMBOL || + $nextToken->getType() === MySQLLexer::READS_SYMBOL || + $nextToken->getType() === MySQLLexer::MODIFIES_SYMBOL || + $nextToken->getType() === MySQLLexer::SQL_SYMBOL) { + $children[] = $this->routineAlterOptions(); + } + } elseif ($token->getType() === MySQLLexer::VIEW_SYMBOL) { + $children[] = $this->alterView(); + } elseif ($token->getType() === MySQLLexer::EVENT_SYMBOL) { + $children[] = $this->alterEvent(); + } elseif ($token->getType() === MySQLLexer::TABLESPACE_SYMBOL) { + $children[] = $this->alterTablespace(); + } elseif ($this->serverVersion >= 80014 && $token->getType() === MySQLLexer::UNDO_SYMBOL) { + $children[] = $this->alterUndoTablespace(); + } elseif ($token->getType() === MySQLLexer::LOGFILE_SYMBOL) { + $children[] = $this->alterLogfileGroup(); + } elseif ($this->serverVersion >= 50713 && $token->getType() === MySQLLexer::INSTANCE_SYMBOL) { + $children[] = $this->match(MySQLLexer::INSTANCE_SYMBOL); + $children[] = $this->match(MySQLLexer::ROTATE_SYMBOL); + $children[] = $this->textOrIdentifier(); + $children[] = $this->match(MySQLLexer::MASTER_SYMBOL); + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterStatement: ' . $token->getText()); + } + + return new ASTNode('alterStatement', $children); + } + + public function alterDatabase() + { + $children = []; + + $children[] = $this->match(MySQLLexer::DATABASE_SYMBOL); + $children[] = $this->schemaRef(); + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DEFAULT_SYMBOL || + $token->getType() === MySQLLexer::CHARSET_SYMBOL || + $token->getType() === MySQLLexer::COLLATE_SYMBOL || + ($this->serverVersion >= 80016 && $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL)) { + do { + $children[] = $this->createDatabaseOption(); + } while ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHARSET_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::COLLATE_SYMBOL || + ($this->serverVersion >= 80016 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENCRYPTION_SYMBOL)); + } elseif ($this->serverVersion < 80000 && $token->getType() === MySQLLexer::UPGRADE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UPGRADE_SYMBOL); + $children[] = $this->match(MySQLLexer::DATA_SYMBOL); + $children[] = $this->match(MySQLLexer::DIRECTORY_SYMBOL); + $children[] = $this->match(MySQLLexer::NAME_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterDatabase: ' . $token->getText()); + } + + return new ASTNode('alterDatabase', $children); + } + + public function alterEvent() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + $children[] = $this->match(MySQLLexer::EVENT_SYMBOL); + $children[] = $this->eventRef(); + + if ($this->lexer->peekNextToken()->getText() === 'ON SCHEDULE') { + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::SCHEDULE_SYMBOL); + $children[] = $this->schedule(); + } + + if ($this->lexer->peekNextToken()->getText() === 'ON COMPLETION') { + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::COMPLETION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::NOT_SYMBOL) { + $children[] = $this->match(MySQLLexer::NOT_SYMBOL); + } + $children[] = $this->match(MySQLLexer::PRESERVE_SYMBOL); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RENAME_SYMBOL) { + $children[] = $this->match(MySQLLexer::RENAME_SYMBOL); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->identifier(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENABLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DISABLE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ENABLE_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::DISABLE_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'ON SLAVE') { + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::SLAVE_SYMBOL); + } + } + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMENT_SYMBOL); + $children[] = $this->textLiteral(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DO_SYMBOL) { + $children[] = $this->match(MySQLLexer::DO_SYMBOL); + $children[] = $this->compoundStatement(); + } + + return new ASTNode('alterEvent', $children); + } + + public function alterLogfileGroup() + { + $children = []; + + $children[] = $this->match(MySQLLexer::LOGFILE_SYMBOL); + $children[] = $this->match(MySQLLexer::GROUP_SYMBOL); + $children[] = $this->logfileGroupRef(); + $children[] = $this->match(MySQLLexer::ADD_SYMBOL); + $children[] = $this->match(MySQLLexer::UNDOFILE_SYMBOL); + $children[] = $this->textLiteral(); + switch ($this->lexer->peekNextToken()->getType()) { + case MySQLLexer::INITIAL_SIZE_SYMBOL: + case MySQLLexer::ENGINE_SYMBOL: + case MySQLLexer::WAIT_SYMBOL: + case MySQLLexer::NO_WAIT_SYMBOL: + $children[] = $this->alterLogfileGroupOptions(); + break; + } + + return new ASTNode('alterLogfileGroup', $children); + } + + public function alterLogfileGroupOptions() + { + $children = []; + + $children[] = $this->alterLogfileGroupOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->alterLogfileGroupOption(); + } + + return new ASTNode('alterLogfileGroupOptions', $children); + } + + public function alterLogfileGroupOption() + { + $token = $this->lexer->peekNextToken(); + switch ($token->getType()) { + case MySQLLexer::INITIAL_SIZE_SYMBOL: + return $this->tsOptionInitialSize(); + case MySQLLexer::ENGINE_SYMBOL: + return $this->tsOptionEngine(); + case MySQLLexer::WAIT_SYMBOL: + case MySQLLexer::NO_WAIT_SYMBOL: + return $this->tsOptionWait(); + default: + throw new \Exception('Unexpected token in alterLogfileGroupOption: ' . $token->getText()); + } + } + + public function alterServer() + { + $children = []; + + $children[] = $this->match(MySQLLexer::SERVER_SYMBOL); + $children[] = $this->serverRef(); + $children[] = $this->serverOptions(); + + return new ASTNode('alterServer', $children); + } + + public function alterTable() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ONLINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::OFFLINE_SYMBOL) { + $children[] = $this->onlineOption(); + } + + if ($this->serverVersion < 50700 && $this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + $children[] = $this->match(MySQLLexer::IGNORE_SYMBOL); + } + + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + $children[] = $this->tableRef(); + switch ($this->lexer->peekNextToken()->getType()) { + case MySQLLexer::ADD_SYMBOL: + case MySQLLexer::ALGORITHM_SYMBOL: + case MySQLLexer::CHANGE_SYMBOL: + case MySQLLexer::CONVERT_SYMBOL: + case MySQLLexer::DISABLE_SYMBOL: + case MySQLLexer::DISCARD_SYMBOL: + case MySQLLexer::DROP_SYMBOL: + case MySQLLexer::ENABLE_SYMBOL: + case MySQLLexer::FORCE_SYMBOL: + case MySQLLexer::IMPORT_SYMBOL: + case MySQLLexer::LOCK_SYMBOL: + case MySQLLexer::MODIFY_SYMBOL: + case MySQLLexer::ORDER_SYMBOL: + case MySQLLexer::PARTITION_SYMBOL: + case MySQLLexer::RENAME_SYMBOL: + case MySQLLexer::REMOVE_SYMBOL: + case MySQLLexer::REORGANIZE_SYMBOL: + $children[] = $this->alterTableActions(); + break; + + case MySQLLexer::SECONDARY_LOAD_SYMBOL: + case MySQLLexer::SECONDARY_UNLOAD_SYMBOL: + if ($this->serverVersion >= 80014) { + $children[] = $this->alterTableActions(); + } + break; + case MySQLLexer::TRUNCATE_SYMBOL: + case MySQLLexer::WITH_SYMBOL: + case MySQLLexer::WITHOUT_SYMBOL: + $children[] = $this->alterTableActions(); + break; + + case MySQLLexer::UPGRADE_SYMBOL: + if ($this->serverVersion >= 50708 && $this->serverVersion < 80000) { + $children[] = $this->alterTableActions(); + } + break; + } + + return new ASTNode('alterTable', $children); + } + + public function alterTableActions() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $token->getType() === MySQLLexer::CHANGE_SYMBOL || + $token->getType() === MySQLLexer::CONVERT_SYMBOL || + $token->getType() === MySQLLexer::DISABLE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::ENABLE_SYMBOL || + $token->getType() === MySQLLexer::FORCE_SYMBOL || + $token->getType() === MySQLLexer::LOCK_SYMBOL || + $token->getType() === MySQLLexer::MODIFY_SYMBOL || + $token->getType() === MySQLLexer::ORDER_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + $token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::WITHOUT_SYMBOL || + ($this->serverVersion >= 50708 && $this->serverVersion < 80000 && + $token->getType() === MySQLLexer::UPGRADE_SYMBOL)) { + $children[] = $this->alterCommandList(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::REMOVE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->partitionClause(); + } else { + $children[] = $this->removePartitioning(); + } + } + } elseif ($token->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->partitionClause(); + } elseif ($token->getType() === MySQLLexer::REMOVE_SYMBOL) { + $children[] = $this->removePartitioning(); + } elseif ($token->getType() === MySQLLexer::DISCARD_SYMBOL || + $token->getType() === MySQLLexer::IMPORT_SYMBOL || + $token->getType() === MySQLLexer::REORGANIZE_SYMBOL || + ($this->serverVersion >= 80014 && + ($this->lexer->peekNextToken()->getType() === MySQLLexer::SECONDARY_LOAD_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::SECONDARY_UNLOAD_SYMBOL)) || + $token->getType() === MySQLLexer::TRUNCATE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITH_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITHOUT_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + } + $children[] = $this->alterCommandsModifierList(); + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + } + $children[] = $this->standaloneAlterCommands(); + } else { + throw new \Exception('Unexpected token in alterTableActions: ' . $token->getText()); + } + + return new ASTNode('alterTableActions', $children); + } + + public function alterCommandList() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $token->getType() === MySQLLexer::LOCK_SYMBOL || + $token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::WITHOUT_SYMBOL) { + return $this->alterCommandsModifierList(); + } elseif ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::CHANGE_SYMBOL || + $token->getType() === MySQLLexer::CONVERT_SYMBOL || + $token->getType() === MySQLLexer::DISABLE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::ENABLE_SYMBOL || + $token->getType() === MySQLLexer::FORCE_SYMBOL || + $token->getType() === MySQLLexer::MODIFY_SYMBOL || + $token->getType() === MySQLLexer::ORDER_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + ($this->serverVersion >= 50708 && $this->serverVersion < 80000 && + $token->getType() === MySQLLexer::UPGRADE_SYMBOL)) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITH_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITHOUT_SYMBOL) { + $children = []; + $children[] = $this->alterCommandsModifierList(); + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->alterList(); + return new ASTNode('alterCommandList', $children); + } else { + return $this->alterList(); + } + } else { + throw new \Exception('Unexpected token in alterCommandList: ' . $token->getText()); + } + } + + public function alterCommandsModifierList() + { + $children = []; + + $children[] = $this->alterCommandsModifier(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->alterCommandsModifier(); + } + + return new ASTNode('alterCommandsModifierList', $children); + } + + public function standaloneAlterCommands() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::DISCARD_SYMBOL) { + $children[] = $this->match(MySQLLexer::DISCARD_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::IMPORT_SYMBOL) { + $children[] = $this->match(MySQLLexer::IMPORT_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::ANALYZE_SYMBOL || + $token->getType() === MySQLLexer::CHECK_SYMBOL || + $token->getType() === MySQLLexer::COALESCE_SYMBOL || + $token->getType() === MySQLLexer::DISCARD_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::EXCHANGE_SYMBOL || + $token->getType() === MySQLLexer::IMPORT_SYMBOL || + $token->getType() === MySQLLexer::OPTIMIZE_SYMBOL || + $token->getType() === MySQLLexer::REBUILD_SYMBOL || + $token->getType() === MySQLLexer::REORGANIZE_SYMBOL || + $token->getType() === MySQLLexer::REPAIR_SYMBOL || + $token->getType() === MySQLLexer::TRUNCATE_SYMBOL) { + $children[] = $this->alterPartition(); + } elseif ($this->serverVersion >= 80014 && + ($token->getType() === MySQLLexer::SECONDARY_LOAD_SYMBOL || + $token->getType() === MySQLLexer::SECONDARY_UNLOAD_SYMBOL)) { + if ($token->getType() === MySQLLexer::SECONDARY_LOAD_SYMBOL) { + $children[] = $this->match(MySQLLexer::SECONDARY_LOAD_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::SECONDARY_UNLOAD_SYMBOL); + } + } else { + throw new \Exception('Unexpected token in standaloneAlterCommands: ' . $token->getText()); + } + + return new ASTNode('standaloneAlterCommands', $children); + } + + public function alterCommandsModifier() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ALGORITHM_SYMBOL) { + return $this->alterAlgorithmOption(); + } elseif ($token->getType() === MySQLLexer::LOCK_SYMBOL) { + return $this->alterLockOption(); + } elseif ($this->serverVersion >= 50706 && + ($token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::WITHOUT_SYMBOL)) { + return $this->withValidation(); + } else { + throw new \Exception('Unexpected token in alterCommandsModifier: ' . $token->getText()); + } + } + + public function alterPartition() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ADD_SYMBOL) { + $children[] = $this->match(MySQLLexer::ADD_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->partitionDefinitions(); + } else { + $children[] = $this->match(MySQLLexer::PARTITIONS_SYMBOL); + $children[] = $this->real_ulong_number(); + } + } elseif ($token->getType() === MySQLLexer::DROP_SYMBOL) { + $children[] = $this->match(MySQLLexer::DROP_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->identifierList(); + } elseif ($token->getType() === MySQLLexer::REBUILD_SYMBOL) { + $children[] = $this->match(MySQLLexer::REBUILD_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + $children[] = $this->allOrPartitionNameList(); + } elseif ($token->getType() === MySQLLexer::OPTIMIZE_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPTIMIZE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + $children[] = $this->allOrPartitionNameList(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + } elseif ($token->getType() === MySQLLexer::ANALYZE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ANALYZE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + $children[] = $this->allOrPartitionNameList(); + } elseif ($token->getType() === MySQLLexer::CHECK_SYMBOL) { + $children[] = $this->match(MySQLLexer::CHECK_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->allOrPartitionNameList(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::FOR_SYMBOL) { + $children[] = $this->checkOption(); + } + } elseif ($token->getType() === MySQLLexer::REPAIR_SYMBOL) { + $children[] = $this->match(MySQLLexer::REPAIR_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + $children[] = $this->allOrPartitionNameList(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::QUICK_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::EXTENDED_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::USE_FRM_SYMBOL) { + $children[] = $this->repairType(); + } + } elseif ($token->getType() === MySQLLexer::COALESCE_SYMBOL) { + $children[] = $this->match(MySQLLexer::COALESCE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + $children[] = $this->real_ulong_number(); + } elseif ($token->getType() === MySQLLexer::TRUNCATE_SYMBOL) { + $children[] = $this->match(MySQLLexer::TRUNCATE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->allOrPartitionNameList(); + } elseif ($token->getType() === MySQLLexer::REORGANIZE_SYMBOL) { + $children[] = $this->match(MySQLLexer::REORGANIZE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WRITE_TO_BINLOG_SYMBOL) { + $children[] = $this->noWriteToBinLog(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->identifierList(); + $children[] = $this->match(MySQLLexer::INTO_SYMBOL); + $children[] = $this->partitionDefinitions(); + } + } elseif ($token->getType() === MySQLLexer::EXCHANGE_SYMBOL) { + $children[] = $this->match(MySQLLexer::EXCHANGE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->identifier(); + $children[] = $this->match(MySQLLexer::WITH_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + $children[] = $this->tableRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::WITH_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITHOUT_SYMBOL) { + $children[] = $this->withValidation(); + } + } elseif ($this->serverVersion >= 50704 && $token->getType() === MySQLLexer::DISCARD_SYMBOL) { + $children[] = $this->match(MySQLLexer::DISCARD_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->allOrPartitionNameList(); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + } elseif ($this->serverVersion >= 50704 && $token->getType() === MySQLLexer::IMPORT_SYMBOL) { + $children[] = $this->match(MySQLLexer::IMPORT_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->allOrPartitionNameList(); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterPartition: ' . $token->getText()); + } + + return new ASTNode('alterPartition', $children); + } + + public function alterList() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::CHANGE_SYMBOL || + $token->getType() === MySQLLexer::CONVERT_SYMBOL || + $token->getType() === MySQLLexer::DISABLE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::ENABLE_SYMBOL || + $token->getType() === MySQLLexer::FORCE_SYMBOL || + $token->getType() === MySQLLexer::MODIFY_SYMBOL || + $token->getType() === MySQLLexer::ORDER_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + ($this->serverVersion >= 50708 && $this->serverVersion < 80000 && + $token->getType() === MySQLLexer::UPGRADE_SYMBOL)) { + $children[] = $this->alterListItem(); + } elseif ($token->getType() === MySQLLexer::ENGINE_SYMBOL || + $token->getType() === MySQLLexer::AUTO_INCREMENT_SYMBOL || + $token->getType() === MySQLLexer::AVG_ROW_LENGTH_SYMBOL || + $token->getType() === MySQLLexer::CHECKSUM_SYMBOL || + $token->getType() === MySQLLexer::TABLE_CHECKSUM_SYMBOL || + ($this->serverVersion >= 50708 && $token->getType() === MySQLLexer::COMPRESSION_SYMBOL) || + $token->getType() === MySQLLexer::CONNECTION_SYMBOL || + $token->getType() === MySQLLexer::DATA_SYMBOL || + $token->getType() === MySQLLexer::DELAY_KEY_WRITE_SYMBOL || + ($this->serverVersion >= 50711 && $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) || + $token->getType() === MySQLLexer::INDEX_SYMBOL || + $token->getType() === MySQLLexer::INSERT_METHOD_SYMBOL || + $token->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $token->getType() === MySQLLexer::MAX_ROWS_SYMBOL || + $token->getType() === MySQLLexer::MIN_ROWS_SYMBOL || + $token->getType() === MySQLLexer::PACK_KEYS_SYMBOL || + $token->getType() === MySQLLexer::PASSWORD_SYMBOL || + $token->getType() === MySQLLexer::ROW_FORMAT_SYMBOL || + $token->getType() === MySQLLexer::STATS_AUTO_RECALC_SYMBOL || + $token->getType() === MySQLLexer::STATS_PERSISTENT_SYMBOL || + $token->getType() === MySQLLexer::STATS_SAMPLE_PAGES_SYMBOL || + $token->getType() === MySQLLexer::STORAGE_SYMBOL || + $token->getType() === MySQLLexer::TABLESPACE_SYMBOL || + $token->getType() === MySQLLexer::UNION_SYMBOL || + $token->getType() === MySQLLexer::CHARSET_SYMBOL || + $token->getType() === MySQLLexer::CHAR_SYMBOL || + $token->getType() === MySQLLexer::COLLATE_SYMBOL) { + $children[] = $this->createTableOptionsSpaceSeparated(); + } else { + throw new \Exception('Unexpected token in alterList: ' . $token->getText()); + } + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::CHANGE_SYMBOL || + $token->getType() === MySQLLexer::CONVERT_SYMBOL || + $token->getType() === MySQLLexer::DISABLE_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL || + $token->getType() === MySQLLexer::ENABLE_SYMBOL || + $token->getType() === MySQLLexer::FORCE_SYMBOL || + $token->getType() === MySQLLexer::MODIFY_SYMBOL || + $token->getType() === MySQLLexer::ORDER_SYMBOL || + $token->getType() === MySQLLexer::RENAME_SYMBOL || + ($this->serverVersion >= 50708 && $this->serverVersion < 80000 && + $token->getType() === MySQLLexer::UPGRADE_SYMBOL)) { + $children[] = $this->alterListItem(); + } elseif ($token->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $token->getType() === MySQLLexer::LOCK_SYMBOL || + $token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::WITHOUT_SYMBOL) { + $children[] = $this->alterCommandsModifier(); + } elseif ($token->getType() === MySQLLexer::ENGINE_SYMBOL || + $token->getType() === MySQLLexer::AUTO_INCREMENT_SYMBOL || + $token->getType() === MySQLLexer::AVG_ROW_LENGTH_SYMBOL || + $token->getType() === MySQLLexer::CHECKSUM_SYMBOL || + $token->getType() === MySQLLexer::TABLE_CHECKSUM_SYMBOL || + ($this->serverVersion >= 50708 && + $token->getType() === MySQLLexer::COMPRESSION_SYMBOL) || + $token->getType() === MySQLLexer::CONNECTION_SYMBOL || + $token->getType() === MySQLLexer::DATA_SYMBOL || + $token->getType() === MySQLLexer::DELAY_KEY_WRITE_SYMBOL || + ($this->serverVersion >= 50711 && + $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) || + $token->getType() === MySQLLexer::INDEX_SYMBOL || + $token->getType() === MySQLLexer::INSERT_METHOD_SYMBOL || + $token->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $token->getType() === MySQLLexer::MAX_ROWS_SYMBOL || + $token->getType() === MySQLLexer::MIN_ROWS_SYMBOL || + $token->getType() === MySQLLexer::PACK_KEYS_SYMBOL || + $token->getType() === MySQLLexer::PASSWORD_SYMBOL || + $token->getType() === MySQLLexer::ROW_FORMAT_SYMBOL || + $token->getType() === MySQLLexer::STATS_AUTO_RECALC_SYMBOL || + $token->getType() === MySQLLexer::STATS_PERSISTENT_SYMBOL || + $token->getType() === MySQLLexer::STATS_SAMPLE_PAGES_SYMBOL || + $token->getType() === MySQLLexer::STORAGE_SYMBOL || + $token->getType() === MySQLLexer::TABLESPACE_SYMBOL || + $token->getType() === MySQLLexer::UNION_SYMBOL || + $token->getType() === MySQLLexer::CHARSET_SYMBOL || + $token->getType() === MySQLLexer::CHAR_SYMBOL || + $token->getType() === MySQLLexer::COLLATE_SYMBOL) { + $children[] = $this->createTableOptionsSpaceSeparated(); + } else { + throw new \Exception('Unexpected token in alterList: ' . $token->getText()); + } + } + + return new ASTNode('alterList', $children); + } + + public function alterListItem() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::ADD_SYMBOL) { + $children[] = $this->match(MySQLLexer::ADD_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->identifier(); + $children[] = $this->fieldDefinition(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::CHECK_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::REFERENCES_SYMBOL) { + $children[] = $this->checkOrReferences(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AFTER_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::FIRST_SYMBOL) { + $children[] = $this->place(); + } + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = $this->tableElementList(); + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterListItem: ' . $token->getText()); + } + } elseif ($token->getType() === MySQLLexer::ALTER_SYMBOL) { + $children[] = $this->match(MySQLLexer::ALTER_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + } + $children[] = $this->columnInternalRef(); + if ($this->lexer->peekNextToken()->getText() === 'SET DEFAULT') { + $children[] = $this->match(MySQLLexer::SET_SYMBOL); + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + if ($this->serverVersion >= 80014 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->exprWithParentheses(); + } else { + $children[] = $this->signedLiteral(); + } + } elseif ($this->lexer->peekNextToken()->getText() === 'DROP DEFAULT') { + $children[] = $this->match(MySQLLexer::DROP_SYMBOL); + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } elseif ($this->serverVersion >= 80000 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + $children[] = $this->indexRef(); + $children[] = $this->visibility(); + } elseif ($this->serverVersion >= 80017 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHECK_SYMBOL) { + $children[] = $this->match(MySQLLexer::CHECK_SYMBOL); + $children[] = $this->identifier(); + $children[] = $this->constraintEnforcement(); + } elseif ($this->serverVersion >= 80019 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONSTRAINT_SYMBOL) { + $children[] = $this->match(MySQLLexer::CONSTRAINT_SYMBOL); + $children[] = $this->identifier(); + $children[] = $this->constraintEnforcement(); + } else { + throw new \Exception('Unexpected token in alterListItem: ' . $token->getText()); + } + } elseif ($token->getType() === MySQLLexer::CHANGE_SYMBOL) { + $children[] = $this->match(MySQLLexer::CHANGE_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + } + $children[] = $this->columnInternalRef(); + $children[] = $this->identifier(); + $children[] = $this->fieldDefinition(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AFTER_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::FIRST_SYMBOL) { + $children[] = $this->place(); + } + } elseif ($token->getType() === MySQLLexer::MODIFY_SYMBOL) { + $children[] = $this->match(MySQLLexer::MODIFY_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + } + $children[] = $this->columnInternalRef(); + $children[] = $this->fieldDefinition(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AFTER_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::FIRST_SYMBOL) { + $children[] = $this->place(); + } + } elseif ($token->getType() === MySQLLexer::DROP_SYMBOL) { + $children[] = $this->match(MySQLLexer::DROP_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + $children[] = $this->columnInternalRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RESTRICT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CASCADE_SYMBOL) { + $children[] = $this->restrict(); + } + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::FOREIGN_SYMBOL) { + $children[] = $this->match(MySQLLexer::FOREIGN_SYMBOL); + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + + if ($this->serverVersion >= 50700) { + $children[] = $this->columnInternalRef(); + } else { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->columnInternalRef(); + } + } + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::PRIMARY_SYMBOL) { + $children[] = $this->match(MySQLLexer::PRIMARY_SYMBOL); + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INDEX_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_SYMBOL) { + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + } + $children[] = $this->indexRef(); + } elseif ($this->serverVersion >= 80017 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHECK_SYMBOL) { + $children[] = $this->match(MySQLLexer::CHECK_SYMBOL); + $children[] = $this->identifier(); + } elseif ($this->serverVersion >= 80019 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONSTRAINT_SYMBOL) { + $children[] = $this->match(MySQLLexer::CONSTRAINT_SYMBOL); + $children[] = $this->identifier(); + } + } elseif ($token->getType() === MySQLLexer::DISABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::DISABLE_SYMBOL); + $children[] = $this->match(MySQLLexer::KEYS_SYMBOL); + } elseif ($token->getType() === MySQLLexer::ENABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ENABLE_SYMBOL); + $children[] = $this->match(MySQLLexer::KEYS_SYMBOL); + } elseif ($token->getType() === MySQLLexer::RENAME_SYMBOL) { + $children[] = $this->match(MySQLLexer::RENAME_SYMBOL); + + if ($this->serverVersion >= 80000 && $this->lexer->peekNextToken()->getType() === MySQLLexer::COLUMN_SYMBOL) { + $children[] = $this->match(MySQLLexer::COLUMN_SYMBOL); + $children[] = $this->columnInternalRef(); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->identifier(); + } else { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TO_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TO_SYMBOL) { + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::AS_SYMBOL); + } + } + $children[] = $this->tableName(); + } + } elseif ($this->serverVersion >= 50700 && + ($token->getType() === MySQLLexer::KEY_SYMBOL || + $token->getType() === MySQLLexer::INDEX_SYMBOL)) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_SYMBOL) { + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + } + $children[] = $this->indexRef(); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->indexName(); + } elseif ($token->getType() === MySQLLexer::CONVERT_SYMBOL) { + $children[] = $this->match(MySQLLexer::CONVERT_SYMBOL); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->charset(); + if ($this->serverVersion >= 80014 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } else { + $children[] = $this->charsetName(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COLLATE_SYMBOL) { + $children[] = $this->collate(); + } + } elseif ($token->getType() === MySQLLexer::FORCE_SYMBOL) { + $children[] = $this->match(MySQLLexer::FORCE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::ORDER_SYMBOL) { + $children[] = $this->match(MySQLLexer::ORDER_SYMBOL); + $children[] = $this->match(MySQLLexer::BY_SYMBOL); + $children[] = $this->alterOrderList(); + } elseif ($this->serverVersion >= 50708 && $this->serverVersion < 80000 && + $token->getType() === MySQLLexer::UPGRADE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UPGRADE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITIONING_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterListItem: ' . $token->getText()); + } + + return new ASTNode('alterListItem', $children); + } + + public function alterAlgorithmOption() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ALGORITHM_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } elseif ($this->isIdentifierStart($token)) { + $children[] = $this->identifier(); + } else { + throw new \Exception('Unexpected token in alterAlgorithmOption: ' . $token->getText()); + } + + return new ASTNode('alterAlgorithmOption', $children); + } + + public function alterLockOption() + { + $children = []; + + $children[] = $this->match(MySQLLexer::LOCK_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } elseif ($this->isIdentifierStart($token)) { + $children[] = $this->identifier(); + } else { + throw new \Exception('Unexpected token in alterLockOption: ' . $token->getText()); + } + + return new ASTNode('alterLockOption', $children); + } + + public function indexLockAndAlgorithm() + { + $token1 = $this->lexer->peekNextToken(); + $token2 = $this->lexer->peekNextToken(2); + + if ($token1->getType() === MySQLLexer::ALGORITHM_SYMBOL && + ($token2->getType() === MySQLLexer::LOCK_SYMBOL || $token2->getType() === MySQLLexer::EOF)) { + $children = []; + $children[] = $this->alterAlgorithmOption(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL) { + $children[] = $this->alterLockOption(); + } + return new ASTNode('indexLockAndAlgorithm', $children); + } elseif ($token1->getType() === MySQLLexer::LOCK_SYMBOL && + ($token2->getType() === MySQLLexer::ALGORITHM_SYMBOL || $token2->getType() === MySQLLexer::EOF)) { + $children = []; + $children[] = $this->alterLockOption(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL) { + $children[] = $this->alterAlgorithmOption(); + } + return new ASTNode('indexLockAndAlgorithm', $children); + } else { + throw new \Exception('Unexpected token in indexLockAndAlgorithm: ' . $token1->getText()); + } + } + + public function place() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::AFTER_SYMBOL) { + $this->match(MySQLLexer::AFTER_SYMBOL); + $children = [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::AFTER_SYMBOL)), + $this->identifier() + ]; + + return new ASTNode('place', $children); + } elseif ($token->getType() === MySQLLexer::FIRST_SYMBOL) { + $this->match(MySQLLexer::FIRST_SYMBOL); + + return new ASTNode( + 'place', + [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FIRST_SYMBOL)) + ] + ); + } else { + throw new \Exception('Unexpected token in place: ' . $token->getText()); + } + } + + public function restrict() +{ + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::RESTRICT_SYMBOL: + case MySQLLexer::CASCADE_SYMBOL: + case MySQLLexer::CASCADE_SYMBOL: + return ASTNode::fromToken($token); + break; + default: + throw new \Exception('Unexpected token in indexType: ' . $token->getText()); + } +} + + public function withValidation() + { + $this->match($this->lexer->peekNextToken()->getType()); + $children = [new ASTNode(MySQLLexer::getTokenName($this->lexer->peekNextToken()->getType()))]; + $children[] = $this->match(MySQLLexer::VALIDATION_SYMBOL); + + return new ASTNode('withValidation', $children); + } + + public function alterOrderList() + { + $children = []; + + $children[] = $this->identifier(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ASC_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DESC_SYMBOL) { + $children[] = $this->direction(); + } + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->identifier(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ASC_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DESC_SYMBOL) { + $children[] = $this->direction(); + } + } + + return new ASTNode('alterOrderList', $children); + } + + public function removePartitioning() + { + $children = []; + + $children[] = $this->match(MySQLLexer::REMOVE_SYMBOL); + $children[] = $this->match(MySQLLexer::PARTITIONING_SYMBOL); + + return new ASTNode('removePartitioning', $children); + } + + public function alterTablespace() + { + $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::TABLESPACE_SYMBOL))]; + $children[] = $this->tablespaceRef(); + $token = $this->lexer->peekNextToken(); + + if ($this->serverVersion < 80000) { + if ($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL) { + $this->match($this->lexer->peekNextToken()->getType()); + $children[] = new ASTNode(MySQLLexer::getTokenName($this->lexer->peekNextToken()->getType())); + $children[] = $this->match(MySQLLexer::DATAFILE_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::CHANGE_SYMBOL) { + $children[] = $this->match(MySQLLexer::CHANGE_SYMBOL); + $children[] = $this->match(MySQLLexer::DATAFILE_SYMBOL); + $children[] = $this->textLiteral(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MAX_SIZE_SYMBOL) { + do { + $children[] = $this->changeTablespaceOption(); + } while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL); + } + } elseif ($token->getType() === MySQLLexer::READ_ONLY_SYMBOL) { + $children[] = $this->match(MySQLLexer::READ_ONLY_SYMBOL); + } elseif ($token->getType() === MySQLLexer::READ_WRITE_SYMBOL) { + $children[] = $this->match(MySQLLexer::READ_WRITE_SYMBOL); + } elseif ($token->getText() === 'NOT ACCESSIBLE') { + $children[] = $this->match(MySQLLexer::NOT_SYMBOL); + $children[] = $this->match(MySQLLexer::ACCESSIBLE_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterTablespace: ' . $token->getText()); + } + } else { + if (($token->getType() === MySQLLexer::ADD_SYMBOL || + $token->getType() === MySQLLexer::DROP_SYMBOL) && + $this->lexer->peekNextToken(2)->getType() === MySQLLexer::DATAFILE_SYMBOL) { + $this->match($this->lexer->peekNextToken()->getType()); + $children[] = new ASTNode(MySQLLexer::getTokenName($this->lexer->peekNextToken()->getType())); + $children[] = $this->match(MySQLLexer::DATAFILE_SYMBOL); + $children[] = $this->textLiteral(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MAX_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENCRYPTION_SYMBOL) { + $children[] = $this->alterTablespaceOptions(); + } + } elseif ($token->getType() === MySQLLexer::RENAME_SYMBOL) { + $children[] = $this->match(MySQLLexer::RENAME_SYMBOL); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->identifier(); + } elseif ($token->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL || + $token->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL || + $token->getType() === MySQLLexer::MAX_SIZE_SYMBOL || + $token->getType() === MySQLLexer::ENGINE_SYMBOL || + $token->getType() === MySQLLexer::WAIT_SYMBOL || + $token->getType() === MySQLLexer::NO_WAIT_SYMBOL || + $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) { + $children[] = $this->alterTablespaceOptions(); + } else { + throw new \Exception('Unexpected token in alterTablespace: ' . $token->getText()); + } + } + + return new ASTNode('alterTablespace', $children); + } + + public function alterUndoTablespace() + { + $children = []; + + $children[] = $this->match(MySQLLexer::UNDO_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children[] = $this->tablespaceRef(); + $children[] = $this->match(MySQLLexer::SET_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ACTIVE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ACTIVE_SYMBOL); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::INACTIVE_SYMBOL) { + $children[] = $this->match(MySQLLexer::INACTIVE_SYMBOL); + } else { + throw new \Exception('Unexpected token in alterUndoTablespace: ' . $this->lexer->peekNextToken()->getText()); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL) { + $children[] = $this->undoTableSpaceOptions(); + } + + return new ASTNode('alterUndoTablespace', $children); + } + + public function undoTableSpaceOptions() + { + $children = []; + + $children[] = $this->undoTableSpaceOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->undoTableSpaceOption(); + } + + return new ASTNode('undoTableSpaceOptions', $children); + } + + public function undoTableSpaceOption() + { + return $this->tsOptionEngine(); + } + + public function alterTablespaceOptions() + { + $children = []; + + $children[] = $this->alterTablespaceOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->alterTablespaceOption(); + } + + return new ASTNode('alterTablespaceOptions', $children); + } + + public function alterTablespaceOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL) { + return $this->tsOptionInitialSize(); + } elseif ($token->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL) { + return $this->tsOptionAutoextendSize(); + } elseif ($token->getType() === MySQLLexer::MAX_SIZE_SYMBOL) { + return $this->tsOptionMaxSize(); + } elseif ($token->getType() === MySQLLexer::ENGINE_SYMBOL) { + return $this->tsOptionEngine(); + } elseif ($token->getType() === MySQLLexer::WAIT_SYMBOL || + $token->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + return $this->tsOptionWait(); + } elseif ($token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) { + return $this->tsOptionEncryption(); + } else { + throw new \Exception('Unexpected token in alterTablespaceOption: ' . $token->getText()); + } + } + + public function changeTablespaceOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL) { + return $this->tsOptionInitialSize(); + } elseif ($token->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL) { + return $this->tsOptionAutoextendSize(); + } elseif ($token->getType() === MySQLLexer::MAX_SIZE_SYMBOL) { + return $this->tsOptionMaxSize(); + } else { + throw new \Exception('Unexpected token in changeTablespaceOption: ' . $token->getText()); + } + } + + public function alterView() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL) { + $children[] = $this->viewAlgorithm(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + if ($this->lexer->peekNextToken()->getText() === 'SQL SECURITY') { + $children[] = $this->viewSuid(); + } + + $children[] = $this->match(MySQLLexer::VIEW_SYMBOL); + $children[] = $this->viewRef(); + $children[] = $this->viewTail(); + + return new ASTNode('alterView', $children); + } + + // This is not the full view_tail from sql_yacc.yy as we have either a view name or a view reference, + // depending on whether we come from createView or alterView. Everything until this difference is duplicated in those rules. + public function viewTail() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->columnInternalRefList(); + } + + $children[] = $this->match(MySQLLexer::AS_SYMBOL); + $children[] = $this->viewSelect(); + + return new ASTNode('viewTail', $children); + } + + public function viewSelect() + { + $children = []; + + $children[] = $this->queryExpressionOrParens(); + + if ($this->lexer->peekNextToken()->getText() === 'WITH CHECK OPTION') { + $children[] = $this->viewCheckOption(); + } + + return new ASTNode('viewSelect', $children); + } + + public function viewCheckOption() + { + $children = []; + + $children[] = $this->match(MySQLLexer::WITH_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::CASCADED_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::CASCADED_SYMBOL) { + $children[] = $this->match(MySQLLexer::CASCADED_SYMBOL); + } else { + $this->match(MySQLLexer::LOCAL_SYMBOL); + $children[] = ASTNode::fromToken($token); + } + } + + $children[] = $this->match(MySQLLexer::CHECK_SYMBOL); + $children[] = $this->match(MySQLLexer::OPTION_SYMBOL); + + return new ASTNode('viewCheckOption', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function createStatement() + { + $this->match(MySQLLexer::CREATE_SYMBOL); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::CREATE_SYMBOL))]; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DATABASE_SYMBOL) { + $children[] = $this->createDatabase(); + } elseif ($token->getType() === MySQLLexer::TABLE_SYMBOL || + $token->getType() === MySQLLexer::TEMPORARY_SYMBOL) { + $children[] = $this->createTable(); + } elseif ($token->getType() === MySQLLexer::FUNCTION_SYMBOL) { + $children[] = $this->createFunction(); + } elseif ($token->getType() === MySQLLexer::PROCEDURE_SYMBOL) { + $children[] = $this->createProcedure(); + } elseif ($token->getType() === MySQLLexer::AGGREGATE_SYMBOL) { + $children[] = $this->createUdf(); + } elseif ($token->getType() === MySQLLexer::LOGFILE_SYMBOL) { + $children[] = $this->createLogfileGroup(); + } elseif ($token->getType() === MySQLLexer::VIEW_SYMBOL) { + $children[] = $this->createView(); + } elseif ($token->getType() === MySQLLexer::TRIGGER_SYMBOL) { + $children[] = $this->createTrigger(); + } elseif ($token->getType() === MySQLLexer::INDEX_SYMBOL || + $token->getType() === MySQLLexer::FULLTEXT_SYMBOL || + $token->getType() === MySQLLexer::SPATIAL_SYMBOL) { + $children[] = $this->createIndex(); + } elseif ($token->getType() === MySQLLexer::SERVER_SYMBOL) { + $children[] = $this->createServer(); + } elseif ($token->getType() === MySQLLexer::TABLESPACE_SYMBOL) { + $children[] = $this->createTablespace(); + } elseif ($this->serverVersion >= 80000 && $token->getType() === MySQLLexer::ROLE_SYMBOL) { + $children[] = $this->createRole(); + } elseif ($this->serverVersion >= 80011 && $token->getType() === MySQLLexer::SPATIAL_SYMBOL) { + $children[] = $this->createSpatialReference(); + } elseif ($this->serverVersion >= 80014 && $token->getType() === MySQLLexer::UNDO_SYMBOL) { + $children[] = $this->createUndoTablespace(); + } elseif ($token->getType() === MySQLLexer::ONLINE_SYMBOL || + $token->getType() === MySQLLexer::OFFLINE_SYMBOL) { + if ($this->lexer->peekNextToken(2)->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->createIndex(); + } else { + $children[] = $this->createTable(); + } + } elseif ($token->getType() === MySQLLexer::UNIQUE_SYMBOL) { + if ($this->lexer->peekNextToken(2)->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->createIndex(); + } else { + $children[] = $this->createTable(); + } + } else { + throw new \Exception('Unexpected token in createStatement: ' . $token->getText()); + } + + return new ASTNode('createStatement', $children); + } + + public function createDatabase() + { + $children = []; + + $children[] = $this->match(MySQLLexer::DATABASE_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF NOT EXISTS') { + $children[] = $this->ifNotExists(); + } + $children[] = $this->schemaName(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHARSET_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::COLLATE_SYMBOL || + ($this->serverVersion >= 80016 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENCRYPTION_SYMBOL)) { + $children[] = $this->createDatabaseOption(); + } + + return new ASTNode('createDatabase', $children); + } + + public function createDatabaseOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DEFAULT_SYMBOL || + $token->getType() === MySQLLexer::CHAR_SYMBOL || + $token->getType() === MySQLLexer::CHARSET_SYMBOL) { + return $this->defaultCharset(); + } elseif ($token->getType() === MySQLLexer::DEFAULT_SYMBOL || + $token->getType() === MySQLLexer::COLLATE_SYMBOL) { + return $this->defaultCollation(); + } elseif ($this->serverVersion >= 80016 && $token->getType() === MySQLLexer::DEFAULT_SYMBOL || + $this->serverVersion >= 80016 && $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) { + return $this->defaultEncryption(); + } else { + throw new \Exception('Unexpected token in createDatabaseOption: ' . $token->getText()); + } + } + + public function createTable() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TEMPORARY_SYMBOL) { + $children[] = $this->match(MySQLLexer::TEMPORARY_SYMBOL); + } + + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + + if ($this->lexer->peekNextToken()->getText() === 'IF NOT EXISTS') { + $children[] = $this->ifNotExists(); + } + + $children[] = $this->tableName(); + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::PRIMARY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::UNIQUE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INDEX_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::FULLTEXT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::SPATIAL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::FOREIGN_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHECK_SYMBOL || + ($this->serverVersion >= 80017 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONSTRAINT_SYMBOL)) { + $children[] = $this->tableElementList(); + } + + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + + if ($this->isCreateTableOptionStart($this->lexer->peekNextToken())) { + $children[] = $this->createTableOptions(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->partitionClause(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::REPLACE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL) { + $children[] = $this->duplicateAsQueryExpression(); + } + } elseif ($token->getType() === MySQLLexer::LIKE_SYMBOL) { + $children[] = $this->match(MySQLLexer::LIKE_SYMBOL); + $children[] = $this->tableRef(); + } elseif ($token->getText() === 'OPEN PARENTHESIS' && $this->lexer->peekNextToken(2)->getType() === MySQLLexer::LIKE_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = $this->match(MySQLLexer::LIKE_SYMBOL); + $children[] = $this->tableRef(); + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } else { + throw new \Exception('Unexpected token in createTable: ' . $token->getText()); + } + + return new ASTNode('createTable', $children); + } + + public function timeFunctionParameters() + { + $children = []; + $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::OPEN_PAR_SYMBOL)); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INT_NUMBER) { + $children[] = $this->fractionalPrecision(); + } + $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::CLOSE_PAR_SYMBOL)); + return new ASTNode('timeFunctionParameters', $children); + } + + public function substringFunction() + { + $children = []; + $this->match(MySQLLexer::SUBSTRING_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::SUBSTRING_SYMBOL)); + $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::OPEN_PAR_SYMBOL)); + $children[] = $this->expr(); + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::COMMA_SYMBOL) { + $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::COMMA_SYMBOL)); + $children[] = $this->expr(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::COMMA_SYMBOL)); + $children[] = $this->expr(); + } + } elseif ($token->getType() === MySQLLexer::FROM_SYMBOL) { + $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FROM_SYMBOL)); + $children[] = $this->expr(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::FOR_SYMBOL) { + $this->match(MySQLLexer::FOR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FOR_SYMBOL)); + $children[] = $this->expr(); + } + } else { + throw new \Exception('Unexpected token in substringFunction: ' . $token->getText()); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + return new ASTNode('substringFunction', $children); + } + + public function defaultCharset() + { + $children = []; + if($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $this->match(MySQLLexer::DEFAULT_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::DEFAULT_SYMBOL)); + } + $children[] = $this->charset(); + return new ASTNode('defaultCharset', $children); + } + + public function defaultCollation() + { + $children = []; + + if($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $this->match(MySQLLexer::DEFAULT_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::DEFAULT_SYMBOL)); + } + $this->match(MySQLLexer::COLLATE_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::DEFAULT_SYMBOL)); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $this->match(MySQLLexer::EQUAL_OPERATOR); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::EQUAL_OPERATOR)); + } + $children[] = $this->collationName(); + return new ASTNode('defaultCollation', $children); + } + public function collationName() + { + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::IDENTIFIER: + case MySQLLexer::BACK_TICK_QUOTED_ID: + case MySQLLexer::DOUBLE_QUOTED_TEXT: + case MySQLLexer::SINGLE_QUOTED_TEXT: + return ASTNode::fromToken($token); + case MySQLLexer::DEFAULT_SYMBOL: + if ($this->serverVersion < 80011) { + return ASTNode::fromToken($token); + } + case MySQLLexer::BINARY_SYMBOL: + if ($this->serverVersion >= 80018) { + return ASTNode::fromToken($token); + } + default: + if ($this->isIdentifierKeyword($token)) { + return $this->identifierKeyword(); + } + + throw new \Exception('Unexpected token in collationName: ' . $token->getText()); + } + } + + public function defaultEncryption() + { + $children = []; + $this->match(MySQLLexer::DEFAULT_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::DEFAULT_SYMBOL)); + $this->match(MySQLLexer::ENCRYPTION_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::ENCRYPTION_SYMBOL)); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $this->match(MySQLLexer::EQUAL_OPERATOR); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::EQUAL_OPERATOR)); + } + $children[] = $this->textStringLiteral(); + return new ASTNode('defaultEncryption', $children); + } + + public function dateTimeTtype() + { + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::DATE_SYMBOL: + case MySQLLexer::TIME_SYMBOL: + case MySQLLexer::DATETIME_SYMBOL: + case MySQLLexer::TIMESTAMP_SYMBOL: + return ASTNode::fromToken($token); + default: + throw new \Exception('Unexpected token in dateTimeTtype: ' . $token->getText()); + } + } + + public function trimFunction() + { + $children = []; + $this->match(MySQLLexer::TRIM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::TRIM_SYMBOL)); + $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::OPEN_PAR_SYMBOL)); + $token = $this->lexer->peekNextToken(); + switch ($token->getType()) { + case MySQLLexer::LEADING_SYMBOL: + $this->match(MySQLLexer::LEADING_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::LEADING_SYMBOL)); + if ($this->isExprStart($this->lexer->peekNextToken())) { + $children[] = $this->expr(); + } + $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FROM_SYMBOL)); + $children[] = $this->expr(); + break; + case MySQLLexer::TRAILING_SYMBOL: + $this->match(MySQLLexer::TRAILING_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::TRAILING_SYMBOL)); + if ($this->isExprStart($this->lexer->peekNextToken())) { + $children[] = $this->expr(); + } + $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FROM_SYMBOL)); + $children[] = $this->expr(); + break; + case MySQLLexer::BOTH_SYMBOL: + $this->match(MySQLLexer::BOTH_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::BOTH_SYMBOL)); + if ($this->isExprStart($this->lexer->peekNextToken())) { + $children[] = $this->expr(); + } + $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FROM_SYMBOL)); + $children[] = $this->expr(); + break; + default: + $children[] = $this->expr(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::FROM_SYMBOL) { + $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FROM_SYMBOL)); + $children[] = $this->expr(); + } + break; + } + $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::CLOSE_PAR_SYMBOL)); + return new ASTNode('trimFunction', $children); + } + + public function typeDatetimePrecision() + { + $children = []; + $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::OPEN_PAR_SYMBOL)); + $this->match(MySQLLexer::INT_NUMBER); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::INT_NUMBER)); + $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + $children[] = new ASTNode(MySQLLexer::getTokenName(MySQLLexer::CLOSE_PAR_SYMBOL)); + return new ASTNode('typeDatetimePrecision', $children); + } + + public function tableElementList() + { + $children = []; + + $children[] = $this->tableElement(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->tableElement(); + } + + return new ASTNode('tableElementList', $children); + } + + public function tableElement() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::IDENTIFIER || + $token->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token)) { + return $this->columnDefinition(); + } elseif ($token->getType() === MySQLLexer::PRIMARY_SYMBOL || + $token->getType() === MySQLLexer::UNIQUE_SYMBOL || + $token->getType() === MySQLLexer::KEY_SYMBOL || + $token->getType() === MySQLLexer::INDEX_SYMBOL || + $token->getType() === MySQLLexer::FULLTEXT_SYMBOL || + $token->getType() === MySQLLexer::SPATIAL_SYMBOL || + $token->getType() === MySQLLexer::FOREIGN_SYMBOL || + $token->getType() === MySQLLexer::CHECK_SYMBOL || + $token->getType() === MySQLLexer::CONSTRAINT_SYMBOL) { + return $this->tableConstraintDef(); + } else { + throw new \Exception('Unexpected token in tableElement: ' . $token->getText()); + } + } + + public function duplicateAsQueryExpression() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::REPLACE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::REPLACE_SYMBOL) { + $children[] = $this->match(MySQLLexer::REPLACE_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::IGNORE_SYMBOL); + } + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL) { + $children[] = $this->match(MySQLLexer::AS_SYMBOL); + } + + $children[] = $this->queryExpressionOrParens(); + return new ASTNode('duplicateAsQueryExpression', $children); + } + + public function queryExpressionOrParens() + { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + return $this->queryExpressionParens(); + } else { + return $this->queryExpression(); + } + } + + public function createRoutine() + { + $this->match(MySQLLexer::CREATE_SYMBOL); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::CREATE_SYMBOL))]; + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::PROCEDURE_SYMBOL) { + $children[] = $this->createProcedure(); + } elseif ($token->getType() === MySQLLexer::FUNCTION_SYMBOL) { + $children[] = $this->createFunction(); + } elseif ($token->getType() === MySQLLexer::AGGREGATE_SYMBOL) { + $children[] = $this->createUdf(); + } else { + throw new \Exception('Unexpected token in createRoutine: ' . $token->getText()); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::SEMICOLON_SYMBOL) { + $this->match(MySQLLexer::SEMICOLON_SYMBOL); + } + + if ($this->lexer->peekNextToken()->getType() !== MySQLLexer::EOF) { + throw new \Exception('Unexpected token: ' . $this->lexer->peekNextToken()->getText()); + } + + return new ASTNode('createRoutine', $children); + } + + public function createProcedure() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + $children[] = $this->match(MySQLLexer::PROCEDURE_SYMBOL); + $children[] = $this->procedureName(); + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IN_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::OUT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INOUT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->procedureParameter(); + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->procedureParameter(); + } + } + + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONTAINS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::READS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MODIFIES_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::SQL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DETERMINISTIC_SYMBOL) { + $children[] = $this->routineCreateOption(); + } + + $children[] = $this->compoundStatement(); + return new ASTNode('createProcedure', $children); + } + + public function createFunction() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + $children[] = $this->match(MySQLLexer::FUNCTION_SYMBOL); + $children[] = $this->functionName(); + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->functionParameter(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->functionParameter(); + } + } + + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + $children[] = $this->match(MySQLLexer::RETURNS_SYMBOL); + $children[] = $this->typeWithOptCollate(); + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONTAINS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::READS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MODIFIES_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::SQL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DETERMINISTIC_SYMBOL) { + $children[] = $this->routineCreateOption(); + } + + $children[] = $this->compoundStatement(); + return new ASTNode('createFunction', $children); + } + + public function createUdf() + { + $children = []; + + $children[] = $this->match(MySQLLexer::AGGREGATE_SYMBOL); + $children[] = $this->match(MySQLLexer::FUNCTION_SYMBOL); + $children[] = $this->udfName(); + $children[] = $this->match(MySQLLexer::RETURNS_SYMBOL); + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::STRING_SYMBOL) { + $children[] = $this->match(MySQLLexer::STRING_SYMBOL); + } elseif ($token->getType() === MySQLLexer::INT_SYMBOL) { + $children[] = $this->match(MySQLLexer::INT_SYMBOL); + } elseif ($token->getType() === MySQLLexer::REAL_SYMBOL) { + $children[] = $this->match(MySQLLexer::REAL_SYMBOL); + } elseif ($token->getType() === MySQLLexer::DECIMAL_SYMBOL) { + $children[] = $this->match(MySQLLexer::DECIMAL_SYMBOL); + } else { + throw new \Exception('Unexpected token in createUdf: ' . $token->getText()); + } + + $children[] = $this->match(MySQLLexer::SONAME_SYMBOL); + $children[] = $this->textLiteral(); + return new ASTNode('createUdf', $children); + } + + public function routineCreateOption() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::COMMENT_SYMBOL || + $token->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $token->getType() === MySQLLexer::NO_SYMBOL || + $token->getType() === MySQLLexer::CONTAINS_SYMBOL || + $token->getType() === MySQLLexer::READS_SYMBOL || + $token->getType() === MySQLLexer::MODIFIES_SYMBOL || + $token->getType() === MySQLLexer::SQL_SYMBOL) { + return $this->routineOption(); + } elseif ($token->getType() === MySQLLexer::DETERMINISTIC_SYMBOL || + $token->getText() === 'NOT DETERMINISTIC') { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::NOT_SYMBOL) { + $children[] = $this->match(MySQLLexer::NOT_SYMBOL); + } + $children[] = $this->match(MySQLLexer::DETERMINISTIC_SYMBOL); + return new ASTNode('routineCreateOption', $children); + } else { + throw new \Exception('Unexpected token in routineCreateOption: ' . $token->getText()); + } + } + + public function routineAlterOptions() + { + $children = []; + + do { + $children[] = $this->routineCreateOption(); + } while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LANGUAGE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONTAINS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::READS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MODIFIES_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::SQL_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DETERMINISTIC_SYMBOL); + + return new ASTNode('routineAlterOptions', $children); + } + + public function routineOption() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::COMMENT_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMENT_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::LANGUAGE_SYMBOL) { + $children[] = $this->match(MySQLLexer::LANGUAGE_SYMBOL); + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + } elseif ($token->getType() === MySQLLexer::NO_SYMBOL) { + $children[] = $this->match(MySQLLexer::NO_SYMBOL); + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + } elseif ($token->getType() === MySQLLexer::CONTAINS_SYMBOL) { + $children[] = $this->match(MySQLLexer::CONTAINS_SYMBOL); + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + } elseif ($token->getType() === MySQLLexer::READS_SYMBOL) { + $children[] = $this->match(MySQLLexer::READS_SYMBOL); + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + $children[] = $this->match(MySQLLexer::DATA_SYMBOL); + } elseif ($token->getType() === MySQLLexer::MODIFIES_SYMBOL) { + $children[] = $this->match(MySQLLexer::MODIFIES_SYMBOL); + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + $children[] = $this->match(MySQLLexer::DATA_SYMBOL); + } elseif ($token->getText() === 'SQL SECURITY') { + $children[] = $this->match(MySQLLexer::SQL_SYMBOL); + $children[] = $this->match(MySQLLexer::SECURITY_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFINER_SYMBOL); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::INVOKER_SYMBOL) { + $children[] = $this->match(MySQLLexer::INVOKER_SYMBOL); + } else { + throw new \Exception( + 'Unexpected token in routineOption: ' . $this->lexer->peekNextToken()->getText() + ); + } + } else { + throw new \Exception('Unexpected token in routineOption: ' . $token->getText()); + } + + return new ASTNode('routineOption', $children); + } + + public function createIndex() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ONLINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::OFFLINE_SYMBOL) { + $children[] = $this->onlineOption(); + } + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::UNIQUE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UNIQUE_SYMBOL); + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + if ($this->serverVersion >= 80014 && + ($this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ON_SYMBOL)) { + $children[] = $this->indexName(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL) { + $children[] = $this->indexTypeClause(); + } + } else { + $children[] = $this->indexNameAndType(); + } + $children[] = $this->createIndexTarget(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::VISIBLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INVISIBLE_SYMBOL) { + $children[] = $this->indexOption(); + } + } else { + $children[] = $this->indexNameAndType(); + $children[] = $this->createIndexTarget(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::VISIBLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INVISIBLE_SYMBOL) { + $children[] = $this->indexOption(); + } + } + } elseif ($token->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + if ($this->serverVersion >= 80014 && + ($this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ON_SYMBOL)) { + $children[] = $this->indexName(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL) { + $children[] = $this->indexTypeClause(); + } + } else { + $children[] = $this->indexNameAndType(); + } + $children[] = $this->createIndexTarget(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::USING_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::TYPE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::VISIBLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INVISIBLE_SYMBOL) { + $children[] = $this->indexOption(); + } + } elseif ($token->getType() === MySQLLexer::FULLTEXT_SYMBOL) { + $children[] = $this->match(MySQLLexer::FULLTEXT_SYMBOL); + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + $children[] = $this->indexName(); + $children[] = $this->createIndexTarget(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WITH_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::VISIBLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INVISIBLE_SYMBOL) { + $children[] = $this->fulltextIndexOption(); + } + } elseif ($token->getType() === MySQLLexer::SPATIAL_SYMBOL) { + $children[] = $this->match(MySQLLexer::SPATIAL_SYMBOL); + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + $children[] = $this->indexName(); + $children[] = $this->createIndexTarget(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::KEY_BLOCK_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::VISIBLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::INVISIBLE_SYMBOL) { + $children[] = $this->spatialIndexOption(); + } + } else { + throw new \Exception('Unexpected token in createIndex: ' . $token->getText()); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL) { + $children[] = $this->indexLockAndAlgorithm(); + } + + return new ASTNode('createIndex', $children); + } + + /* + The syntax for defining an index is: + + ... INDEX [index_name] [USING|TYPE] ... + + The problem is that whereas USING is a reserved word, TYPE is not. We can + still handle it if an index name is supplied, i.e.: + + ... INDEX type TYPE ... + + here the index's name is unmbiguously 'type', but for this: + + ... INDEX TYPE ... + + it's impossible to know what this actually mean - is 'type' the name or the + type? For this reason we accept the TYPE syntax only if a name is supplied. +*/ + public function indexNameAndType() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if (($token->getType() === MySQLLexer::IDENTIFIER || + $token->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token))) { + $children[] = $this->indexName(); + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::USING_SYMBOL) { + $children[] = $this->match(MySQLLexer::USING_SYMBOL); + $children[] = $this->indexType(); + } elseif ($token->getType() === MySQLLexer::TYPE_SYMBOL) { + $children[] = $this->match(MySQLLexer::TYPE_SYMBOL); + $children[] = $this->indexType(); + } + + return new ASTNode('indexNameAndType', $children); + } else { + throw new \Exception('Unexpected token in indexNameAndType: ' . $token->getText()); + } + } + + public function createIndexTarget() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->tableRef(); + $children[] = $this->keyListVariants(); + return new ASTNode('createIndexTarget', $children); + } + + public function createLogfileGroup() + { + $children = []; + + $children[] = $this->match(MySQLLexer::LOGFILE_SYMBOL); + $children[] = $this->match(MySQLLexer::GROUP_SYMBOL); + $children[] = $this->logfileGroupName(); + $children[] = $this->match(MySQLLexer::ADD_SYMBOL); + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::UNDOFILE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UNDOFILE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::REDOFILE_SYMBOL) { + $children[] = $this->match(MySQLLexer::REDOFILE_SYMBOL); + } else { + throw new \Exception('Unexpected token in createLogfileGroup: ' . $token->getText()); + } + + $children[] = $this->textLiteral(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::UNDO_BUFFER_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::REDO_BUFFER_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NODEGROUP_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL) { + $children[] = $this->logfileGroupOptions(); + } + + return new ASTNode('createLogfileGroup', $children); + } + + public function logfileGroupOptions() + { + $children = []; + + $children[] = $this->logfileGroupOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->logfileGroupOption(); + } + + return new ASTNode('logfileGroupOptions', $children); + } + + public function logfileGroupOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL) { + return $this->tsOptionInitialSize(); + } elseif ($token->getType() === MySQLLexer::UNDO_BUFFER_SIZE_SYMBOL || + $token->getType() === MySQLLexer::REDO_BUFFER_SIZE_SYMBOL) { + return $this->tsOptionUndoRedoBufferSize(); + } elseif ($token->getType() === MySQLLexer::NODEGROUP_SYMBOL) { + return $this->tsOptionNodegroup(); + } elseif ($token->getType() === MySQLLexer::ENGINE_SYMBOL) { + return $this->tsOptionEngine(); + } elseif ($token->getType() === MySQLLexer::WAIT_SYMBOL || + $token->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + return $this->tsOptionWait(); + } elseif ($token->getType() === MySQLLexer::COMMENT_SYMBOL) { + return $this->tsOptionComment(); + } else { + throw new \Exception('Unexpected token in logfileGroupOption: ' . $token->getText()); + } + } + + public function createServer() + { + $children = []; + + $children[] = $this->match(MySQLLexer::SERVER_SYMBOL); + $children[] = $this->serverName(); + $children[] = $this->match(MySQLLexer::FOREIGN_SYMBOL); + $children[] = $this->match(MySQLLexer::DATA_SYMBOL); + $children[] = $this->match(MySQLLexer::WRAPPER_SYMBOL); + $children[] = $this->textOrIdentifier(); + $children[] = $this->serverOptions(); + + return new ASTNode('createServer', $children); + } + + public function serverOptions() + { + $children = []; + + $children[] = $this->match(MySQLLexer::OPTIONS_SYMBOL); + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = $this->serverOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->serverOption(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + + return new ASTNode('serverOptions', $children); + } + + // Options for CREATE/ALTER SERVER, used for the federated storage engine. + public function serverOption() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::HOST_SYMBOL) { + $children[] = $this->match(MySQLLexer::HOST_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::DATABASE_SYMBOL) { + $children[] = $this->match(MySQLLexer::DATABASE_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::USER_SYMBOL) { + $children[] = $this->match(MySQLLexer::USER_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::PASSWORD_SYMBOL) { + $children[] = $this->match(MySQLLexer::PASSWORD_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::SOCKET_SYMBOL) { + $children[] = $this->match(MySQLLexer::SOCKET_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::OWNER_SYMBOL) { + $children[] = $this->match(MySQLLexer::OWNER_SYMBOL); + $children[] = $this->textLiteral(); + } elseif ($token->getType() === MySQLLexer::PORT_SYMBOL) { + $children[] = $this->match(MySQLLexer::PORT_SYMBOL); + $children[] = $this->ulong_number(); + } else { + throw new \Exception('Unexpected token in serverOption: ' . $token->getText()); + } + + return new ASTNode('serverOption', $children); + } + + public function createTablespace() + { + $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::TABLESPACE_SYMBOL))]; + $children[] = $this->tablespaceName(); + $children[] = $this->tsDataFileName(); + + if ($this->lexer->peekNextToken()->getText() === 'USE LOGFILE GROUP') { + $children[] = $this->match(MySQLLexer::USE_SYMBOL); + $children[] = $this->match(MySQLLexer::LOGFILE_SYMBOL); + $children[] = $this->match(MySQLLexer::GROUP_SYMBOL); + $children[] = $this->logfileGroupRef(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::MAX_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::EXTENT_SIZE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NODEGROUP_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL || + ($this->serverVersion >= 50707 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::FILE_BLOCK_SIZE_SYMBOL) || + ($this->serverVersion >= 80014 && + $this->lexer->peekNextToken()->getType() === MySQLLexer::ENCRYPTION_SYMBOL)) { + $children[] = $this->tablespaceOptions(); + } + + return new ASTNode('createTablespace', $children); + } + + public function createUndoTablespace() + { + $children = []; + + $children[] = $this->match(MySQLLexer::UNDO_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children[] = $this->tablespaceName(); + $children[] = $this->match(MySQLLexer::ADD_SYMBOL); + $children[] = $this->tsDataFile(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL) { + $children[] = $this->undoTableSpaceOptions(); + } + + return new ASTNode('createUndoTablespace', $children); + } + + public function tsDataFileName() + { + $token = $this->lexer->peekNextToken(); + if ($this->serverVersion >= 80014) { + if ($token->getType() === MySQLLexer::ADD_SYMBOL) { + $this->match(MySQLLexer::ADD_SYMBOL); + $children = [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::ADD_SYMBOL)), + $this->tsDataFile() + ]; + return new ASTNode('tsDataFileName', $children); + } else { + return new ASTNode('tsDataFileName', []); + } + } else { + if ($token->getType() === MySQLLexer::ADD_SYMBOL) { + $this->match(MySQLLexer::ADD_SYMBOL); + $children = [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::ADD_SYMBOL)), + $this->tsDataFile() + ]; + return new ASTNode('tsDataFileName', $children); + } else { + throw new \Exception( + 'Unexpected token in tsDataFileName: ' . $token->getText() + ); + } + } + } + + public function tsDataFile() + { + $children = []; + + $children[] = $this->match(MySQLLexer::DATAFILE_SYMBOL); + $children[] = $this->textLiteral(); + + return new ASTNode('tsDataFile', $children); + } + + public function tablespaceOptions() + { + $children = []; + + $children[] = $this->tablespaceOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->tablespaceOption(); + } + + return new ASTNode('tablespaceOptions', $children); + } + + public function tablespaceOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::INITIAL_SIZE_SYMBOL) { + return $this->tsOptionInitialSize(); + } elseif ($token->getType() === MySQLLexer::AUTOEXTEND_SIZE_SYMBOL) { + return $this->tsOptionAutoextendSize(); + } elseif ($token->getType() === MySQLLexer::MAX_SIZE_SYMBOL) { + return $this->tsOptionMaxSize(); + } elseif ($token->getType() === MySQLLexer::EXTENT_SIZE_SYMBOL) { + return $this->tsOptionExtentSize(); + } elseif ($token->getType() === MySQLLexer::NODEGROUP_SYMBOL) { + return $this->tsOptionNodegroup(); + } elseif ($token->getType() === MySQLLexer::ENGINE_SYMBOL) { + return $this->tsOptionEngine(); + } elseif ($token->getType() === MySQLLexer::WAIT_SYMBOL || + $token->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + return $this->tsOptionWait(); + } elseif ($token->getType() === MySQLLexer::COMMENT_SYMBOL) { + return $this->tsOptionComment(); + } elseif ($this->serverVersion >= 50707 && $token->getType() === MySQLLexer::FILE_BLOCK_SIZE_SYMBOL) { + return $this->tsOptionFileblockSize(); + } elseif ($this->serverVersion >= 80014 && $token->getType() === MySQLLexer::ENCRYPTION_SYMBOL) { + return $this->tsOptionEncryption(); + } else { + throw new \Exception('Unexpected token in tablespaceOption: ' . $token->getText()); + } + } + + public function tsOptionInitialSize() + { + $children = []; + + $children[] = $this->match(MySQLLexer::INITIAL_SIZE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionInitialSize', $children); + } + + public function tsOptionUndoRedoBufferSize() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::UNDO_BUFFER_SIZE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UNDO_BUFFER_SIZE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::REDO_BUFFER_SIZE_SYMBOL) { + $children[] = $this->match(MySQLLexer::REDO_BUFFER_SIZE_SYMBOL); + } else { + throw new \Exception('Unexpected token in tsOptionUndoRedoBufferSize: ' . $token->getText()); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionUndoRedoBufferSize', $children); + } + + public function tsOptionAutoextendSize() + { + $children = []; + + $children[] = $this->match(MySQLLexer::AUTOEXTEND_SIZE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionAutoextendSize', $children); + } + + public function tsOptionMaxSize() + { + $children = []; + + $children[] = $this->match(MySQLLexer::MAX_SIZE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionMaxSize', $children); + } + + public function tsOptionExtentSize() + { + $children = []; + + $children[] = $this->match(MySQLLexer::EXTENT_SIZE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionExtentSize', $children); + } + + public function tsOptionNodegroup() + { + $children = []; + + $children[] = $this->match(MySQLLexer::NODEGROUP_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->real_ulong_number(); + return new ASTNode('tsOptionNodegroup', $children); + } + + public function tsOptionEngine() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::STORAGE_SYMBOL) { + $children[] = $this->match(MySQLLexer::STORAGE_SYMBOL); + } + + $children[] = $this->match(MySQLLexer::ENGINE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->engineRef(); + return new ASTNode('tsOptionEngine', $children); + } + + public function tsOptionWait() +{ + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::WAIT_SYMBOL: + case MySQLLexer::NO_WAIT_SYMBOL: + return ASTNode::fromToken($token); + default: + throw new \Exception('Unexpected token in indexType: ' . $token->getText()); + } +} + + public function tsOptionComment() + { + $children = []; + + $children[] = $this->match(MySQLLexer::COMMENT_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + $children[] = $this->textLiteral(); + return new ASTNode('tsOptionComment', $children); + } + + public function tsOptionFileblockSize() + { + $children = []; + + $children[] = $this->match(MySQLLexer::FILE_BLOCK_SIZE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + + $children[] = $this->sizeNumber(); + return new ASTNode('tsOptionFileblockSize', $children); + } + + public function tsOptionEncryption() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ENCRYPTION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } + $children[] = $this->textStringLiteral(); + return new ASTNode('tsOptionEncryption', $children); + } + + public function createTrigger() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + $children[] = $this->match(MySQLLexer::TRIGGER_SYMBOL); + $children[] = $this->triggerName(); + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::BEFORE_SYMBOL) { + $children[] = $this->match(MySQLLexer::BEFORE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::AFTER_SYMBOL) { + $children[] = $this->match(MySQLLexer::AFTER_SYMBOL); + } else { + throw new \Exception('Unexpected token in createTrigger: ' . $token->getText()); + } + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::INSERT_SYMBOL) { + $children[] = $this->match(MySQLLexer::INSERT_SYMBOL); + } elseif ($token->getType() === MySQLLexer::UPDATE_SYMBOL) { + $children[] = $this->match(MySQLLexer::UPDATE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::DELETE_SYMBOL) { + $children[] = $this->match(MySQLLexer::DELETE_SYMBOL); + } else { + throw new \Exception('Unexpected token in createTrigger: ' . $token->getText()); + } + + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->tableRef(); + $children[] = $this->match(MySQLLexer::FOR_SYMBOL); + $children[] = $this->match(MySQLLexer::EACH_SYMBOL); + $children[] = $this->match(MySQLLexer::ROW_SYMBOL); + + if ($this->serverVersion >= 50700 && + ($this->lexer->peekNextToken()->getType() === MySQLLexer::FOLLOWS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::PRECEDES_SYMBOL)) { + $children[] = $this->triggerFollowsPrecedesClause(); + } + + $children[] = $this->compoundStatement(); + return new ASTNode('createTrigger', $children); + } + + public function triggerFollowsPrecedesClause() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::FOLLOWS_SYMBOL) { + $this->match(MySQLLexer::FOLLOWS_SYMBOL); + $children = [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::FOLLOWS_SYMBOL)), + $this->textOrIdentifier() + ]; + return new ASTNode('triggerFollowsPrecedesClause', $children); + } elseif ($token->getType() === MySQLLexer::PRECEDES_SYMBOL) { + $this->match(MySQLLexer::PRECEDES_SYMBOL); + $children = [ + new ASTNode(MySQLLexer::getTokenName(MySQLLexer::PRECEDES_SYMBOL)), + $this->textOrIdentifier() + ]; + return new ASTNode('triggerFollowsPrecedesClause', $children); + } else { + throw new \Exception('Unexpected token in triggerFollowsPrecedesClause: ' . $token->getText()); + } + } + + public function createEvent() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::DEFINER_SYMBOL) { + $children[] = $this->definerClause(); + } + + $children[] = $this->match(MySQLLexer::EVENT_SYMBOL); + + if ($this->lexer->peekNextToken()->getText() === 'IF NOT EXISTS') { + $children[] = $this->ifNotExists(); + } + + $children[] = $this->eventName(); + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::SCHEDULE_SYMBOL); + $children[] = $this->schedule(); + + if ($this->lexer->peekNextToken()->getText() === 'ON COMPLETION') { + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::COMPLETION_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::NOT_SYMBOL) { + $children[] = $this->match(MySQLLexer::NOT_SYMBOL); + } + $children[] = ASTNode::fromToken($this->match(MySQLLexer::PRESERVE_SYMBOL)); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENABLE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DISABLE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ENABLE_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::DISABLE_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'ON SLAVE') { + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::SLAVE_SYMBOL); + } + } + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMENT_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMENT_SYMBOL); + $children[] = $this->textLiteral(); + } + + $children[] = $this->match(MySQLLexer::DO_SYMBOL); + $children[] = $this->compoundStatement(); + return new ASTNode('createEvent', $children); + } + + public function createRole() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ROLE_SYMBOL); + + if ($this->lexer->peekNextToken()->getText() === 'IF NOT EXISTS') { + $children[] = $this->ifNotExists(); + } + + $children[] = $this->roleList(); + return new ASTNode('createRole', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function dropStatement() + { + $this->match(MySQLLexer::DROP_SYMBOL); + $children = [new ASTNode(MySQLLexer::getTokenName(MySQLLexer::DROP_SYMBOL))]; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::DATABASE_SYMBOL) { + $children[] = $this->dropDatabase(); + } elseif ($token->getType() === MySQLLexer::TABLE_SYMBOL || + $token->getType() === MySQLLexer::TEMPORARY_SYMBOL) { + $children[] = $this->dropTable(); + } elseif ($token->getType() === MySQLLexer::FUNCTION_SYMBOL) { + $children[] = $this->dropFunction(); + } elseif ($token->getType() === MySQLLexer::PROCEDURE_SYMBOL) { + $children[] = $this->dropProcedure(); + } elseif ($token->getType() === MySQLLexer::VIEW_SYMBOL) { + $children[] = $this->dropView(); + } elseif ($token->getType() === MySQLLexer::TRIGGER_SYMBOL) { + $children[] = $this->dropTrigger(); + } elseif ($token->getType() === MySQLLexer::EVENT_SYMBOL) { + $children[] = $this->dropEvent(); + } elseif ($token->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->dropIndex(); + } elseif ($token->getType() === MySQLLexer::SERVER_SYMBOL) { + $children[] = $this->dropServer(); + } elseif ($token->getType() === MySQLLexer::TABLESPACE_SYMBOL) { + $children[] = $this->dropTableSpace(); + } elseif ($this->serverVersion >= 80000 && $token->getType() === MySQLLexer::ROLE_SYMBOL) { + $children[] = $this->dropRole(); + } elseif ($this->serverVersion >= 80011 && $token->getType() === MySQLLexer::SPATIAL_SYMBOL) { + $children[] = $this->dropSpatialReference(); + } elseif ($this->serverVersion >= 80014 && $token->getType() === MySQLLexer::UNDO_SYMBOL) { + $children[] = $this->dropUndoTablespace(); + } elseif ($token->getType() === MySQLLexer::ONLINE_SYMBOL || + $token->getType() === MySQLLexer::OFFLINE_SYMBOL) { + if ($this->lexer->peekNextToken(2)->getType() === MySQLLexer::INDEX_SYMBOL) { + $children[] = $this->dropIndex(); + } else { + $children[] = $this->dropTable(); + } + } else { + throw new \Exception('Unexpected token in dropStatement: ' . $token->getText()); + } + + return new ASTNode('dropStatement', $children); + } + + public function dropDatabase() + { + $children = []; + + $children[] = $this->match(MySQLLexer::DATABASE_SYMBOL); + + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + + $children[] = $this->schemaRef(); + + return new ASTNode('dropDatabase', $children); + } + + public function dropEvent() + { + $children = []; + + $children[] = $this->match(MySQLLexer::EVENT_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->eventRef(); + return new ASTNode('dropEvent', $children); + } + + public function dropFunction() + { + $children = []; + + $children[] = $this->match(MySQLLexer::FUNCTION_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->functionRef(); + return new ASTNode('dropFunction', $children); + } + + public function dropProcedure() + { + $children = []; + + $children[] = $this->match(MySQLLexer::PROCEDURE_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->procedureRef(); + return new ASTNode('dropProcedure', $children); + } + + public function dropIndex() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ONLINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::OFFLINE_SYMBOL) { + $children[] = $this->onlineOption(); + } + + $children[] = $this->match(MySQLLexer::INDEX_SYMBOL); + $children[] = $this->indexRef(); + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->tableRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ALGORITHM_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL) { + $children[] = $this->indexLockAndAlgorithm(); + } + + return new ASTNode('dropIndex', $children); + } + + public function dropLogfileGroup() + { + $children = []; + + $children[] = $this->match(MySQLLexer::LOGFILE_SYMBOL); + $children[] = $this->match(MySQLLexer::GROUP_SYMBOL); + $children[] = $this->logfileGroupRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + $children[] = $this->dropLogfileGroupOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->dropLogfileGroupOption(); + } + } + + return new ASTNode('dropLogfileGroup', $children); + } + + public function dropLogfileGroupOption() + { + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::ENGINE_SYMBOL) { + return $this->tsOptionEngine(); + } elseif ($token->getType() === MySQLLexer::WAIT_SYMBOL || + $token->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + return $this->tsOptionWait(); + } else { + throw new \Exception('Unexpected token in dropLogfileGroupOption: ' . $token->getText()); + } + } + + public function dropServer() + { + $children = []; + + $children[] = $this->match(MySQLLexer::SERVER_SYMBOL); + + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + + $children[] = $this->serverRef(); + return new ASTNode('dropServer', $children); + } + + public function dropTable() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TEMPORARY_SYMBOL) { + $children[] = $this->match(MySQLLexer::TEMPORARY_SYMBOL); + } + + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::TABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::TABLES_SYMBOL) { + $children[] = $this->match(MySQLLexer::TABLES_SYMBOL); + } else { + throw new \Exception('Unexpected token in dropTable: ' . $token->getText()); + } + + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + + $children[] = $this->tableRefList(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RESTRICT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CASCADE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RESTRICT_SYMBOL) { + $children[] = $this->match(MySQLLexer::RESTRICT_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::CASCADE_SYMBOL); + } + } + + return new ASTNode('dropTable', $children); + } + + public function dropTableSpace() + { + $children = []; + + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children[] = $this->tablespaceRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::WAIT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::NO_WAIT_SYMBOL) { + $children[] = $this->dropLogfileGroupOption(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->dropLogfileGroupOption(); + } + } + + return new ASTNode('dropTableSpace', $children); + } + + public function dropTrigger() + { + $children = []; + + $children[] = $this->match(MySQLLexer::TRIGGER_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->triggerRef(); + + return new ASTNode('dropTrigger', $children); + } + + public function dropView() + { + $children = []; + + $children[] = $this->match(MySQLLexer::VIEW_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->viewRefList(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RESTRICT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CASCADE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::RESTRICT_SYMBOL) { + $children[] = $this->match(MySQLLexer::RESTRICT_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::CASCADE_SYMBOL); + } + } + + return new ASTNode('dropView', $children); + } + + public function dropRole() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ROLE_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->roleList(); + return new ASTNode('dropRole', $children); + } + + public function dropSpatialReference() + { + $children = []; + + $children[] = $this->match(MySQLLexer::SPATIAL_SYMBOL); + $children[] = $this->match(MySQLLexer::REFERENCE_SYMBOL); + $children[] = $this->match(MySQLLexer::SYSTEM_SYMBOL); + if ($this->lexer->peekNextToken()->getText() === 'IF EXISTS') { + $children[] = $this->ifExists(); + } + $children[] = $this->real_ulonglong_number(); + return new ASTNode('dropSpatialReference', $children); + } + + public function dropUndoTablespace() + { + $children = []; + + $children[] = $this->match(MySQLLexer::UNDO_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLESPACE_SYMBOL); + $children[] = $this->tablespaceRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ENGINE_SYMBOL) { + $children[] = $this->undoTableSpaceOptions(); + } + + return new ASTNode('dropUndoTablespace', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function renameTableStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::RENAME_SYMBOL); + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::TABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + } elseif ($token->getType() === MySQLLexer::TABLES_SYMBOL) { + $children[] = $this->match(MySQLLexer::TABLES_SYMBOL); + } else { + throw new \Exception('Unexpected token in renameTableStatement: ' . $token->getText()); + } + + $children[] = $this->renamePair(); + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->renamePair(); + } + + return new ASTNode('renameTableStatement', $children); + } + + public function renamePair() + { + $children = []; + + $children[] = $this->tableRef(); + $children[] = $this->match(MySQLLexer::TO_SYMBOL); + $children[] = $this->tableName(); + + return new ASTNode('renamePair', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function truncateTableStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::TRUNCATE_SYMBOL); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TABLE_SYMBOL) { + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + } + + $children[] = $this->tableRef(); + + return new ASTNode('truncateTableStatement', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function importStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::IMPORT_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + $children[] = $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = $this->textStringLiteralList(); + + return new ASTNode('importStatement', $children); + } + + //--------------- DML statements --------------------------------------------------------------------------------------- + + public function callStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::CALL_SYMBOL); + $children[] = $this->procedureRef(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + if ($this->isBoolPriStart($this->lexer->peekNextToken())) { + $children[] = $this->exprList(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } + + return new ASTNode('callStatement', $children); + } + + public function deleteStatement() + { + $children = []; + + if ($this->serverVersion >= 80000 && $this->lexer->peekNextToken()->getType() === MySQLLexer::WITH_SYMBOL) { + $children[] = $this->withClause(); + } + + $children[] = $this->match(MySQLLexer::DELETE_SYMBOL); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::QUICK_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + $children[] = $this->deleteStatementOption(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::FROM_SYMBOL) { + $children[] = $this->match(MySQLLexer::FROM_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->tableAliasRefList(); + $children[] = $this->match(MySQLLexer::USING_SYMBOL); + $children[] = $this->tableReferenceList(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::WHERE_SYMBOL) { + $children[] = $this->whereClause(); + } + } else { + $children[] = $this->tableRef(); + if ($this->serverVersion >= 80017 && + ($this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()))) { + $children[] = $this->tableAlias(); + } + if ($this->serverVersion >= 50602 && $this->lexer->peekNextToken()->getText() === 'PARTITION') { + $children[] = $this->partitionDelete(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::WHERE_SYMBOL) { + $children[] = $this->whereClause(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ORDER_SYMBOL) { + $children[] = $this->orderClause(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LIMIT_SYMBOL) { + $children[] = $this->simpleLimitClause(); + } + } + } else { + $children[] = $this->tableAliasRefList(); + $children[] = $this->match(MySQLLexer::FROM_SYMBOL); + $children[] = $this->tableReferenceList(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::WHERE_SYMBOL) { + $children[] = $this->whereClause(); + } + } + + return new ASTNode('deleteStatement', $children); + } + + public function partitionDelete() + { + $children = []; + + $children[] = $this->match(MySQLLexer::PARTITION_SYMBOL); + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = $this->identifierList(); + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + + return new ASTNode('partitionDelete', $children); + } + + public function deleteStatementOption() +{ + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::LOW_PRIORITY_SYMBOL: + case MySQLLexer::QUICK_SYMBOL: + case MySQLLexer::IGNORE_SYMBOL: + return ASTNode::fromToken($token); + default: + throw new \Exception('Unexpected token in indexType: ' . $token->getText()); + } +} + + public function doStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::DO_SYMBOL); + + if ($this->serverVersion < 50709) { + $children[] = $this->exprList(); + } else { + $children[] = $this->selectItemList(); + } + + return new ASTNode('doStatement', $children); + } + + public function handlerStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::HANDLER_SYMBOL); + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::IDENTIFIER || + $token->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token) || + $token->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->tableRef(); + $children[] = $this->match(MySQLLexer::OPEN_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken())) { + $children[] = $this->tableAlias(); + } + } else { + $children[] = $this->identifier(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::CLOSE_SYMBOL) { + $children[] = $this->match(MySQLLexer::CLOSE_SYMBOL); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::READ_SYMBOL) { + $children[] = $this->match(MySQLLexer::READ_SYMBOL); + $children[] = $this->handlerReadOrScan(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::WHERE_SYMBOL) { + $children[] = $this->whereClause(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LIMIT_SYMBOL) { + $children[] = $this->limitClause(); + } + } else { + throw new \Exception('Unexpected token in handlerStatement: ' . $this->lexer->peekNextToken()->getText()); + } + } + + return new ASTNode('handlerStatement', $children); + } + + public function handlerReadOrScan() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::FIRST_SYMBOL || + $token->getType() === MySQLLexer::NEXT_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::FIRST_SYMBOL) { + $children[] = $this->match(MySQLLexer::FIRST_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::NEXT_SYMBOL); + } + } else { + $children[] = $this->identifier(); + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::FIRST_SYMBOL) { + $children[] = $this->match(MySQLLexer::FIRST_SYMBOL); + } elseif ($token->getType() === MySQLLexer::NEXT_SYMBOL) { + $children[] = $this->match(MySQLLexer::NEXT_SYMBOL); + } elseif ($token->getType() === MySQLLexer::PREV_SYMBOL) { + $this->match(MySQLLexer::PREV_SYMBOL); + $children[] = ASTNode::fromToken($token); + } elseif ($token->getType() === MySQLLexer::LAST_SYMBOL) { + $children[] = $this->match(MySQLLexer::LAST_SYMBOL); + } elseif ($token->getType() === MySQLLexer::EQUAL_OPERATOR || + $token->getType() === MySQLLexer::LESS_THAN_OPERATOR || + $token->getType() === MySQLLexer::GREATER_THAN_OPERATOR || + $token->getType() === MySQLLexer::LESS_OR_EQUAL_OPERATOR || + $token->getType() === MySQLLexer::GREATER_OR_EQUAL_OPERATOR) { + if ($token->getType() === MySQLLexer::EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::EQUAL_OPERATOR); + } elseif ($token->getType() === MySQLLexer::LESS_THAN_OPERATOR) { + $children[] = $this->match(MySQLLexer::LESS_THAN_OPERATOR); + } elseif ($token->getType() === MySQLLexer::GREATER_THAN_OPERATOR) { + $children[] = $this->match(MySQLLexer::GREATER_THAN_OPERATOR); + } elseif ($token->getType() === MySQLLexer::LESS_OR_EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::LESS_OR_EQUAL_OPERATOR); + } elseif ($token->getType() === MySQLLexer::GREATER_OR_EQUAL_OPERATOR) { + $children[] = $this->match(MySQLLexer::GREATER_OR_EQUAL_OPERATOR); + } else { + throw new \Exception('Unexpected token in handlerReadOrScan: ' . $token->getText()); + } + + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + $children[] = $this->values(); + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } else { + throw new \Exception('Unexpected token in handlerReadOrScan: ' . $token->getText()); + } + } + + return new ASTNode('handlerReadOrScan', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function insertStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::INSERT_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DELAYED_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::HIGH_PRIORITY_SYMBOL) { + $children[] = $this->insertLockOption(); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + $children[] = $this->match(MySQLLexer::IGNORE_SYMBOL); + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INTO_SYMBOL) { + $children[] = $this->match(MySQLLexer::INTO_SYMBOL); + } + $children[] = $this->tableRef(); + + if ($this->serverVersion >= 50602 && $this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->usePartition(); + } + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::OPEN_PAR_SYMBOL || + $token->getType() === MySQLLexer::VALUES_SYMBOL || + $token->getType() === MySQLLexer::VALUE_SYMBOL) { + $children[] = $this->insertFromConstructor(); + + if ($this->serverVersion >= 80018 && $this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL) { + $children[] = $this->valuesReference(); + } + } elseif ($token->getType() === MySQLLexer::SET_SYMBOL) { + $children[] = $this->match(MySQLLexer::SET_SYMBOL); + $children[] = $this->updateList(); + + if ($this->serverVersion >= 80018 && $this->lexer->peekNextToken()->getType() === MySQLLexer::AS_SYMBOL) { + $children[] = $this->valuesReference(); + } + } else { + $children[] = $this->insertQueryExpression(); + } + + if ($this->lexer->peekNextToken()->getText() === 'ON DUPLICATE KEY UPDATE') { + $children[] = $this->insertUpdateList(); + } + + return new ASTNode('insertStatement', $children); + } + + public function insertLockOption() +{ + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::LOW_PRIORITY_SYMBOL: + case MySQLLexer::DELAYED_SYMBOL: + case MySQLLexer::HIGH_PRIORITY_SYMBOL: + return ASTNode::fromToken($token); + default: + throw new \Exception('Unexpected token in indexType: ' . $token->getText()); + } +} + + public function insertFromConstructor() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->fields(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } + + $children[] = $this->insertValues(); + return new ASTNode('insertFromConstructor', $children); + } + + public function fields() + { + $children = []; + + $children[] = $this->insertIdentifier(); + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->insertIdentifier(); + } + + return new ASTNode('fields', $children); + } + + public function insertValues() + { + $token = $this->lexer->peekNextToken(); + $children = []; + + if ($token->getType() === MySQLLexer::VALUES_SYMBOL) { + $children[] = $this->match(MySQLLexer::VALUES_SYMBOL); + } elseif ($token->getType() === MySQLLexer::VALUE_SYMBOL) { + $children[] = $this->match(MySQLLexer::VALUE_SYMBOL); + } else { + throw new \Exception('Unexpected token in insertValues: ' . $token->getText()); + } + + $children[] = $this->valueList(); + return new ASTNode('insertValues', $children); + } + + public function insertQueryExpression() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->fields(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } + + $children[] = $this->queryExpressionOrParens(); + return new ASTNode('insertQueryExpression', $children); + } + + public function valueList() + { + $children = []; + + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + + if ($this->isExprStart($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->values(); + } + + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + if ($this->isExprStart($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->values(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + } + + return new ASTNode('valueList', $children); + } + + public function values() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($this->isExprStart($token)) { + $children[] = $this->expr(); + } elseif ($token->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } else { + throw new \Exception('Unexpected token in values: ' . $token->getText()); + } + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $token = $this->lexer->peekNextToken(); + if ($this->isExprStart($token)) { + $children[] = $this->expr(); + } elseif ($token->getType() === MySQLLexer::DEFAULT_SYMBOL) { + $children[] = $this->match(MySQLLexer::DEFAULT_SYMBOL); + } else { + throw new \Exception('Unexpected token in values: ' . $token->getText()); + } + } + + return new ASTNode('values', $children); + } + + public function valuesReference() + { + $children = []; + + $children[] = $this->match(MySQLLexer::AS_SYMBOL); + $children[] = $this->identifier(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->columnInternalRefList(); + } + + return new ASTNode('valuesReference', $children); + } + + public function insertUpdateList() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ON_SYMBOL); + $children[] = $this->match(MySQLLexer::DUPLICATE_SYMBOL); + $children[] = $this->match(MySQLLexer::KEY_SYMBOL); + $children[] = $this->match(MySQLLexer::UPDATE_SYMBOL); + $children[] = $this->updateList(); + return new ASTNode('insertUpdateList', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function loadStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::LOAD_SYMBOL); + $children[] = $this->dataOrXml(); + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CONCURRENT_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL) { + $children[] = $this->match(MySQLLexer::LOW_PRIORITY_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::CONCURRENT_SYMBOL); + } + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOCAL_SYMBOL) { + $this->match(MySQLLexer::LOCAL_SYMBOL); + $children[] = ASTNode::fromToken($token); + } + + $children[] = $this->match(MySQLLexer::INFILE_SYMBOL); + $children[] = $this->textLiteral(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::REPLACE_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::REPLACE_SYMBOL) { + $children[] = $this->match(MySQLLexer::REPLACE_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::IGNORE_SYMBOL); + } + } + $children[] = $this->match(MySQLLexer::INTO_SYMBOL); + $children[] = $this->match(MySQLLexer::TABLE_SYMBOL); + $children[] = $this->tableRef(); + + if ($this->serverVersion >= 50602 && $this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->usePartition(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::CHARSET_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::CHAR_SYMBOL) { + $children[] = $this->charsetClause(); + } + + if ($this->lexer->peekNextToken()->getText() === 'ROWS IDENTIFIED BY') { + $children[] = $this->xmlRowsIdentifiedBy(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::FIELDS_SYMBOL) { + $children[] = $this->fieldsClause(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LINES_SYMBOL) { + $children[] = $this->linesClause(); + } + + $children[] = $this->loadDataFileTail(); + return new ASTNode('loadStatement', $children); + } + + public function dataOrXml() +{ + $token = $this->lexer->getNextToken(); + switch ($token->getType()) { + case MySQLLexer::DATA_SYMBOL: + case MySQLLexer::XML_SYMBOL: + return ASTNode::fromToken($token); + default: + throw new \Exception('Unexpected token in indexType: ' . $token->getText()); + } +} + + public function xmlRowsIdentifiedBy() + { + $children = []; + + $children[] = $this->match(MySQLLexer::ROWS_SYMBOL); + $children[] = $this->match(MySQLLexer::IDENTIFIED_SYMBOL); + $children[] = $this->match(MySQLLexer::BY_SYMBOL); + $children[] = $this->textString(); + return new ASTNode('xmlRowsIdentifiedBy', $children); + } + + public function loadDataFileTail() + { + $children = []; + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IGNORE_SYMBOL) { + $children[] = $this->match(MySQLLexer::IGNORE_SYMBOL); + $children[] = $this->match(MySQLLexer::INT_NUMBER); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LINES_SYMBOL) { + $children[] = $this->match(MySQLLexer::LINES_SYMBOL); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::ROWS_SYMBOL) { + $children[] = $this->match(MySQLLexer::ROWS_SYMBOL); + } else { + throw new \Exception('Unexpected token in loadDataFileTail: ' . $this->lexer->peekNextToken()->getText()); + } + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->loadDataFileTargetList(); + } + + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::SET_SYMBOL) { + $children[] = $this->match(MySQLLexer::SET_SYMBOL); + $children[] = $this->updateList(); + } + + return new ASTNode('loadDataFileTail', $children); + } + + public function loadDataFileTargetList() + { + $children = []; + + $children[] = $this->match(MySQLLexer::OPEN_PAR_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::IDENTIFIER || + $this->lexer->peekNextToken()->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($this->lexer->peekNextToken()) || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DOT_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AT_SIGN_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AT_TEXT_SUFFIX) { + $children[] = $this->fieldOrVariableList(); + } + $children[] = $this->match(MySQLLexer::CLOSE_PAR_SYMBOL); + + return new ASTNode('loadDataFileTargetList', $children); + } + + public function fieldOrVariableList() + { + $children = []; + $token = $this->lexer->peekNextToken(); + + if ($token->getType() === MySQLLexer::IDENTIFIER || + $token->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token) || + $token->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->columnRef(); + } elseif ($token->getType() === MySQLLexer::AT_SIGN_SYMBOL || + $token->getType() === MySQLLexer::AT_TEXT_SUFFIX) { + $children[] = $this->userVariable(); + } else { + throw new \Exception('Unexpected token in fieldOrVariableList: ' . $token->getText()); + } + + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::COMMA_SYMBOL) { + $children[] = $this->match(MySQLLexer::COMMA_SYMBOL); + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::IDENTIFIER || + $token->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token) || + $token->getType() === MySQLLexer::DOT_SYMBOL) { + $children[] = $this->columnRef(); + } elseif ($token->getType() === MySQLLexer::AT_SIGN_SYMBOL || + $token->getType() === MySQLLexer::AT_TEXT_SUFFIX) { + $children[] = $this->userVariable(); + } else { + throw new \Exception('Unexpected token in fieldOrVariableList: ' . $token->getText()); + } + } + + return new ASTNode('fieldOrVariableList', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function replaceStatement() + { + $children = []; + + $children[] = $this->match(MySQLLexer::REPLACE_SYMBOL); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::DELAYED_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::LOW_PRIORITY_SYMBOL) { + $children[] = $this->match(MySQLLexer::LOW_PRIORITY_SYMBOL); + } else { + $children[] = $this->match(MySQLLexer::DELAYED_SYMBOL); + } + } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::INTO_SYMBOL) { + $children[] = $this->match(MySQLLexer::INTO_SYMBOL); + } + $children[] = $this->tableRef(); + + if ($this->serverVersion >= 50602 && $this->lexer->peekNextToken()->getType() === MySQLLexer::PARTITION_SYMBOL) { + $children[] = $this->usePartition(); + } + + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::OPEN_PAR_SYMBOL || + $token->getType() === MySQLLexer::VALUES_SYMBOL || + $token->getType() === MySQLLexer::VALUE_SYMBOL) { + $children[] = $this->insertFromConstructor(); + } elseif ($token->getType() === MySQLLexer::SET_SYMBOL) { + $children[] = $this->match(MySQLLexer::SET_SYMBOL); + $children[] = $this->updateList(); + } else { + $children[] = $this->insertQueryExpression(); + } + + return new ASTNode('replaceStatement', $children); + } + + //---------------------------------------------------------------------------------------------------------------------- + + public function selectStatement() + { + $token = $this->lexer->peekNextToken(); + if ($token->getType() === MySQLLexer::OPEN_PAR_SYMBOL || + $token->getType() === MySQLLexer::WITH_SYMBOL || + $token->getType() === MySQLLexer::UNION_SYMBOL || + $token->getType() === MySQLLexer::SELECT_SYMBOL) { + $children = []; + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->queryExpressionParens(); + } else { + $children[] = $this->queryExpression(); + } + while ($this->lexer->peekNextToken()->getType() === MySQLLexer::FOR_SYMBOL || + $this->lexer->peekNextToken()->getType() === MySQLLexer::LOCK_SYMBOL) { + $children[] = $this->lockingClauseList(); + } + return new ASTNode('selectStatement', $children); + } elseif ($token->getType() === MySQLLexer::FOR_SYMBOL || + $token->getType() === MySQLLexer::LOCK_SYMBOL) { + $children = []; + $children[] = $this->lockingClauseList(); + $children[] = $this->intoClause(); + return new ASTNode('selectStatementWithInto', $children); + } else { + return $this->selectStatementWithInto(); + } + } + + /* + From the server grammar: + + MySQL has a syntax extension that allows into clauses in any one of two + places. They may appear either before the from clause or at the end. All in + a top-level select statement. This extends the standard syntax in two + ways. First, we don't have the restriction that the result can contain only + one row: the into clause might be INTO OUTFILE/DUMPFILE in which case any + number of rows is allowed. Hence MySQL does not have any special case for + the standard's syntax all the way down to the . So instead we solve it by writing an ambiguous grammar and use + precedence rules to sort out the shift/reduce conflict. + + The problem is when the parser has seen SELECT . Secondly, and this has more + severe implications for the parser, it makes the grammar ambiguous, because + in a from-clause-less select statement with an into clause, it is not clear + whether the into clause is the leading or the trailing one. + + While it's possible to write an unambiguous grammar, it would force us to + duplicate the entire , and sees an + INTO token. It can now either shift it or reduce what it has to a table-less + query expression. If it shifts the token, it will accept seeing a FROM token + next and hence the INTO will be interpreted as the leading INTO. If it + reduces what it has seen to a table-less select, however, it will interpret + INTO as the trailing into. But what if the next token is FROM? Obviously, + we want to always shift INTO. We do this by two precedence declarations: We + make the INTO token right-associative, and we give it higher precedence than + an empty from clause, using the artificial token EMPTY_FROM_CLAUSE. + + The remaining problem is that now we allow the leading INTO anywhere, when + it should be allowed on the top level only. We solve this by manually + throwing parse errors whenever we reduce a nested query expression if it + contains an into clause. +*/ +selectStatementWithInto: + OPEN_PAR_SYMBOL selectStatementWithInto CLOSE_PAR_SYMBOL + | queryExpression intoClause lockingClauseList? + | lockingClauseList intoClause +; + +queryExpression: + ({serverVersion >= 80000}? withClause)? ( + queryExpressionBody orderClause? limitClause? + | queryExpressionParens orderClause? limitClause? + ) ({serverVersion < 80000}? procedureAnalyseClause)? +; + +queryExpressionBody: + ( + queryPrimary + | queryExpressionParens UNION_SYMBOL unionOption? ( + queryPrimary + | queryExpressionParens + ) + ) (UNION_SYMBOL unionOption? ( queryPrimary | queryExpressionParens))* +; + +queryExpressionParens: + OPEN_PAR_SYMBOL ( + queryExpressionParens + | queryExpression lockingClauseList? + ) CLOSE_PAR_SYMBOL +; + +queryPrimary: + querySpecification + | {serverVersion >= 80019}? tableValueConstructor + | {serverVersion >= 80019}? explicitTable +; + +querySpecification: + SELECT_SYMBOL selectOption* selectItemList intoClause? fromClause? whereClause? groupByClause? havingClause? ( + {serverVersion >= 80000}? windowClause + )? +; + +subquery: + queryExpressionParens +; + +querySpecOption: + ALL_SYMBOL + | DISTINCT_SYMBOL + | STRAIGHT_JOIN_SYMBOL + | HIGH_PRIORITY_SYMBOL + | SQL_SMALL_RESULT_SYMBOL + | SQL_BIG_RESULT_SYMBOL + | SQL_BUFFER_RESULT_SYMBOL + | SQL_CALC_FOUND_ROWS_SYMBOL +; + +limitClause: + LIMIT_SYMBOL limitOptions +; + +simpleLimitClause: + LIMIT_SYMBOL limitOption +; + +limitOptions: + limitOption ((COMMA_SYMBOL | OFFSET_SYMBOL) limitOption)? +; + +limitOption: + identifier + | (PARAM_MARKER | ULONGLONG_NUMBER | LONG_NUMBER | INT_NUMBER) +; + +intoClause: + INTO_SYMBOL ( + OUTFILE_SYMBOL textStringLiteral charsetClause? fieldsClause? linesClause? + | DUMPFILE_SYMBOL textStringLiteral + | (textOrIdentifier | userVariable) ( + COMMA_SYMBOL (textOrIdentifier | userVariable) + )* + ) +; + +procedureAnalyseClause: + PROCEDURE_SYMBOL ANALYSE_SYMBOL OPEN_PAR_SYMBOL ( + INT_NUMBER (COMMA_SYMBOL INT_NUMBER)? + )? CLOSE_PAR_SYMBOL +; + +havingClause: + HAVING_SYMBOL expr +; + +windowClause: + WINDOW_SYMBOL windowDefinition (COMMA_SYMBOL windowDefinition)* +; + +windowDefinition: + windowName AS_SYMBOL windowSpec +; + +windowSpec: + OPEN_PAR_SYMBOL windowSpecDetails CLOSE_PAR_SYMBOL +; + +windowSpecDetails: + windowName? (PARTITION_SYMBOL BY_SYMBOL orderList)? orderClause? windowFrameClause? +; + +windowFrameClause: + windowFrameUnits windowFrameExtent windowFrameExclusion? +; + +windowFrameUnits: + ROWS_SYMBOL + | RANGE_SYMBOL + | GROUPS_SYMBOL +; + +windowFrameExtent: + windowFrameStart + | windowFrameBetween +; + +windowFrameStart: + UNBOUNDED_SYMBOL PRECEDING_SYMBOL + | ulonglong_number PRECEDING_SYMBOL + | PARAM_MARKER PRECEDING_SYMBOL + | INTERVAL_SYMBOL expr interval PRECEDING_SYMBOL + | CURRENT_SYMBOL ROW_SYMBOL +; + +windowFrameBetween: + BETWEEN_SYMBOL windowFrameBound AND_SYMBOL windowFrameBound +; + +windowFrameBound: + windowFrameStart + | UNBOUNDED_SYMBOL FOLLOWING_SYMBOL + | ulonglong_number FOLLOWING_SYMBOL + | PARAM_MARKER FOLLOWING_SYMBOL + | INTERVAL_SYMBOL expr interval FOLLOWING_SYMBOL +; + +windowFrameExclusion: + EXCLUDE_SYMBOL ( + CURRENT_SYMBOL ROW_SYMBOL + | GROUP_SYMBOL + | TIES_SYMBOL + | NO_SYMBOL OTHERS_SYMBOL + ) +; + +withClause: + WITH_SYMBOL RECURSIVE_SYMBOL? commonTableExpression ( + COMMA_SYMBOL commonTableExpression + )* +; + +commonTableExpression: + identifier columnInternalRefList? AS_SYMBOL subquery +; + +groupByClause: + GROUP_SYMBOL BY_SYMBOL orderList olapOption? +; + +olapOption: + WITH_SYMBOL ROLLUP_SYMBOL + | {serverVersion < 80000}? WITH_SYMBOL CUBE_SYMBOL +; + +orderClause: + ORDER_SYMBOL BY_SYMBOL orderList +; + +direction: + ASC_SYMBOL + | DESC_SYMBOL +; + +fromClause: + FROM_SYMBOL (DUAL_SYMBOL | tableReferenceList) +; + +tableReferenceList: + tableReference (COMMA_SYMBOL tableReference)* +; + +tableValueConstructor: + VALUES_SYMBOL rowValueExplicit (COMMA_SYMBOL rowValueExplicit)* +; + +explicitTable: + TABLE_SYMBOL tableRef +; + +rowValueExplicit: + ROW_SYMBOL OPEN_PAR_SYMBOL values? CLOSE_PAR_SYMBOL +; + +selectOption: + querySpecOption + | SQL_NO_CACHE_SYMBOL // Deprecated and ignored in 8.0. + | {serverVersion < 80000}? SQL_CACHE_SYMBOL + | {serverVersion >= 50704 && serverVersion < 50708}? MAX_STATEMENT_TIME_SYMBOL EQUAL_OPERATOR real_ulong_number +; + +lockingClauseList: + lockingClause+ +; + +lockingClause: + FOR_SYMBOL lockStrengh ({serverVersion >= 80000}? OF_SYMBOL tableAliasRefList)? ( + {serverVersion >= 80000}? lockedRowAction + )? + | LOCK_SYMBOL IN_SYMBOL SHARE_SYMBOL MODE_SYMBOL +; + +lockStrengh: + UPDATE_SYMBOL + | {serverVersion >= 80000}? SHARE_SYMBOL +; + +lockedRowAction: + SKIP_SYMBOL LOCKED_SYMBOL + | NOWAIT_SYMBOL +; + +selectItemList: (selectItem | MULT_OPERATOR) (COMMA_SYMBOL selectItem)* +; + +selectItem: + tableWild + | expr selectAlias? +; + +selectAlias: + AS_SYMBOL? (identifier | textStringLiteral) +; + +whereClause: + WHERE_SYMBOL expr +; + +tableReference: ( // Note: we have also a tableRef rule for identifiers that reference a table anywhere. + tableFactor + | OPEN_CURLY_SYMBOL ({serverVersion < 80017}? identifier | OJ_SYMBOL) escapedTableReference CLOSE_CURLY_SYMBOL // ODBC syntax + ) joinedTable* +; + +escapedTableReference: + tableFactor joinedTable* +; + +joinedTable: // Same as joined_table in sql_yacc.yy, but with removed left recursion. + innerJoinType tableReference ( + ON_SYMBOL expr + | USING_SYMBOL identifierListWithParentheses + )? + | outerJoinType tableReference ( + ON_SYMBOL expr + | USING_SYMBOL identifierListWithParentheses + ) + | naturalJoinType tableFactor +; + +naturalJoinType: + NATURAL_SYMBOL INNER_SYMBOL? JOIN_SYMBOL + | NATURAL_SYMBOL (LEFT_SYMBOL | RIGHT_SYMBOL) OUTER_SYMBOL? JOIN_SYMBOL +; + +innerJoinType: + type = (INNER_SYMBOL | CROSS_SYMBOL)? JOIN_SYMBOL + | type = STRAIGHT_JOIN_SYMBOL +; + +outerJoinType: + type = (LEFT_SYMBOL | RIGHT_SYMBOL) OUTER_SYMBOL? JOIN_SYMBOL +; + +/** + MySQL has a syntax extension where a comma-separated list of table + references is allowed as a table reference in itself, for instance + + SELECT * FROM (t1, t2) JOIN t3 ON 1 + + which is not allowed in standard SQL. The syntax is equivalent to + + SELECT * FROM (t1 CROSS JOIN t2) JOIN t3 ON 1 + + We call this rule tableReferenceListParens. +*/ +tableFactor: + singleTable + | singleTableParens + | derivedTable + | tableReferenceListParens + | {serverVersion >= 80004}? tableFunction +; + +singleTable: + tableRef usePartition? tableAlias? indexHintList? +; + +singleTableParens: + OPEN_PAR_SYMBOL (singleTable | singleTableParens) CLOSE_PAR_SYMBOL +; + +derivedTable: + subquery tableAlias? ({serverVersion >= 80000}? columnInternalRefList)? + | {serverVersion >= 80014}? LATERAL_SYMBOL subquery tableAlias? columnInternalRefList? +; + +// This rule covers both: joined_table_parens and table_reference_list_parens from sql_yacc.yy. +// We can simplify that because we have unrolled the indirect left recursion in joined_table <-> table_reference. +tableReferenceListParens: + OPEN_PAR_SYMBOL (tableReferenceList | tableReferenceListParens) CLOSE_PAR_SYMBOL +; + +tableFunction: + JSON_TABLE_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL textStringLiteral columnsClause CLOSE_PAR_SYMBOL tableAlias? +; + +columnsClause: + COLUMNS_SYMBOL OPEN_PAR_SYMBOL jtColumn (COMMA_SYMBOL jtColumn)* CLOSE_PAR_SYMBOL +; + +jtColumn: + identifier FOR_SYMBOL ORDINALITY_SYMBOL + | identifier dataType ({serverVersion >= 80014}? collate)? EXISTS_SYMBOL? PATH_SYMBOL textStringLiteral onEmptyOrError? + | NESTED_SYMBOL PATH_SYMBOL textStringLiteral columnsClause +; + +onEmptyOrError: + onEmpty onError? + | onError onEmpty? +; + +onEmpty: + jtOnResponse ON_SYMBOL EMPTY_SYMBOL +; + +onError: + jtOnResponse ON_SYMBOL ERROR_SYMBOL +; + +jtOnResponse: + ERROR_SYMBOL + | NULL_SYMBOL + | DEFAULT_SYMBOL textStringLiteral +; + +unionOption: + DISTINCT_SYMBOL + | ALL_SYMBOL +; + +tableAlias: + (AS_SYMBOL | {serverVersion < 80017}? EQUAL_OPERATOR)? identifier +; + +indexHintList: + indexHint (COMMA_SYMBOL indexHint)* +; + +indexHint: + indexHintType keyOrIndex indexHintClause? OPEN_PAR_SYMBOL indexList CLOSE_PAR_SYMBOL + | USE_SYMBOL keyOrIndex indexHintClause? OPEN_PAR_SYMBOL indexList? CLOSE_PAR_SYMBOL +; + +indexHintType: + FORCE_SYMBOL + | IGNORE_SYMBOL +; + +keyOrIndex: + KEY_SYMBOL + | INDEX_SYMBOL +; + +constraintKeyType: + PRIMARY_SYMBOL KEY_SYMBOL + | UNIQUE_SYMBOL keyOrIndex? +; + +indexHintClause: + FOR_SYMBOL (JOIN_SYMBOL | ORDER_SYMBOL BY_SYMBOL | GROUP_SYMBOL BY_SYMBOL) +; + +indexList: + indexListElement (COMMA_SYMBOL indexListElement)* +; + +indexListElement: + identifier + | PRIMARY_SYMBOL +; + +//---------------------------------------------------------------------------------------------------------------------- + +updateStatement: + ({serverVersion >= 80000}? withClause)? UPDATE_SYMBOL LOW_PRIORITY_SYMBOL? IGNORE_SYMBOL? tableReferenceList SET_SYMBOL + updateList whereClause? orderClause? simpleLimitClause? +; + +//---------------------------------------------------------------------------------------------------------------------- + +transactionOrLockingStatement: + transactionStatement + | savepointStatement + | lockStatement + | xaStatement +; + +transactionStatement: + START_SYMBOL TRANSACTION_SYMBOL transactionCharacteristic* + | COMMIT_SYMBOL WORK_SYMBOL? (AND_SYMBOL NO_SYMBOL? CHAIN_SYMBOL)? ( + NO_SYMBOL? RELEASE_SYMBOL + )? + // SET TRANSACTION is part of setStatement. +; + +// BEGIN WORK is separated from transactional statements as it must not appear as part of a stored program. +beginWork: + BEGIN_SYMBOL WORK_SYMBOL? +; + +transactionCharacteristic: + WITH_SYMBOL CONSISTENT_SYMBOL SNAPSHOT_SYMBOL + | {serverVersion >= 50605}? READ_SYMBOL (WRITE_SYMBOL | ONLY_SYMBOL) +; + +savepointStatement: + SAVEPOINT_SYMBOL identifier + | ROLLBACK_SYMBOL WORK_SYMBOL? ( + TO_SYMBOL SAVEPOINT_SYMBOL? identifier + | (AND_SYMBOL NO_SYMBOL? CHAIN_SYMBOL)? (NO_SYMBOL? RELEASE_SYMBOL)? + ) + | RELEASE_SYMBOL SAVEPOINT_SYMBOL identifier +; + +lockStatement: + LOCK_SYMBOL (TABLES_SYMBOL | TABLE_SYMBOL) lockItem (COMMA_SYMBOL lockItem)* + | {serverVersion >= 80000}? LOCK_SYMBOL INSTANCE_SYMBOL FOR_SYMBOL BACKUP_SYMBOL + | UNLOCK_SYMBOL ( + TABLES_SYMBOL + | TABLE_SYMBOL + | {serverVersion >= 80000}? INSTANCE_SYMBOL + ) +; + +lockItem: + tableRef tableAlias? lockOption +; + +lockOption: + READ_SYMBOL LOCAL_SYMBOL? + | LOW_PRIORITY_SYMBOL? WRITE_SYMBOL // low priority deprecated since 5.7 +; + +xaStatement: + XA_SYMBOL ( + (START_SYMBOL | BEGIN_SYMBOL) xid (JOIN_SYMBOL | RESUME_SYMBOL)? + | END_SYMBOL xid (SUSPEND_SYMBOL (FOR_SYMBOL MIGRATE_SYMBOL)?)? + | PREPARE_SYMBOL xid + | COMMIT_SYMBOL xid (ONE_SYMBOL PHASE_SYMBOL)? + | ROLLBACK_SYMBOL xid + | RECOVER_SYMBOL xaConvert + ) +; + +xaConvert: + {serverVersion >= 50704}? (CONVERT_SYMBOL XID_SYMBOL)? + | /* empty */ +; + +xid: + textString (COMMA_SYMBOL textString (COMMA_SYMBOL ulong_number)?)? +; + +//---------------------------------------------------------------------------------------------------------------------- + +replicationStatement: + PURGE_SYMBOL (BINARY_SYMBOL | MASTER_SYMBOL) LOGS_SYMBOL ( + TO_SYMBOL textLiteral + | BEFORE_SYMBOL expr + ) + | changeMaster + | RESET_SYMBOL resetOption (COMMA_SYMBOL resetOption)* + | {serverVersion > 80000}? RESET_SYMBOL PERSIST_SYMBOL (ifExists identifier)? + | slave + | {serverVersion >= 50700}? changeReplication + | replicationLoad + | {serverVersion > 50706}? groupReplication +; + +resetOption: + option = MASTER_SYMBOL masterResetOptions? + | {serverVersion < 80000}? option = QUERY_SYMBOL CACHE_SYMBOL + | option = SLAVE_SYMBOL ALL_SYMBOL? channel? +; + +masterResetOptions: + {serverVersion >= 80000}? TO_SYMBOL ( + {serverVersion < 80017}? real_ulong_number + | {serverVersion >= 80017}? real_ulonglong_number + ) +; + +replicationLoad: + LOAD_SYMBOL (DATA_SYMBOL | TABLE_SYMBOL tableRef) FROM_SYMBOL MASTER_SYMBOL +; + +changeMaster: + CHANGE_SYMBOL MASTER_SYMBOL TO_SYMBOL changeMasterOptions channel? +; + +changeMasterOptions: + masterOption (COMMA_SYMBOL masterOption)* +; + +masterOption: + MASTER_HOST_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | NETWORK_NAMESPACE_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_BIND_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_USER_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_PASSWORD_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_PORT_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_CONNECT_RETRY_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_RETRY_COUNT_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_DELAY_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_SSL_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_SSL_CA_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_SSL_CAPATH_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_TLS_VERSION_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_SSL_CERT_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_TLS_CIPHERSUITES_SYMBOL EQUAL_OPERATOR masterTlsCiphersuitesDef + | MASTER_SSL_CIPHER_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_SSL_KEY_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_SSL_CRL_SYMBOL EQUAL_OPERATOR textLiteral + | MASTER_SSL_CRLPATH_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_PUBLIC_KEY_PATH_SYMBOL EQUAL_OPERATOR textStringNoLinebreak // Conditionally set in the lexer. + | GET_MASTER_PUBLIC_KEY_SYMBOL EQUAL_OPERATOR ulong_number // Conditionally set in the lexer. + | MASTER_HEARTBEAT_PERIOD_SYMBOL EQUAL_OPERATOR ulong_number + | IGNORE_SERVER_IDS_SYMBOL EQUAL_OPERATOR serverIdList + | MASTER_COMPRESSION_ALGORITHM_SYMBOL EQUAL_OPERATOR textStringLiteral + | MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL EQUAL_OPERATOR ulong_number + | MASTER_AUTO_POSITION_SYMBOL EQUAL_OPERATOR ulong_number + | PRIVILEGE_CHECKS_USER_SYMBOL EQUAL_OPERATOR privilegeCheckDef + | REQUIRE_ROW_FORMAT_SYMBOL EQUAL_OPERATOR ulong_number + | REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL EQUAL_OPERATOR tablePrimaryKeyCheckDef + | masterFileDef +; + +privilegeCheckDef: + userIdentifierOrText + | NULL_SYMBOL +; + +tablePrimaryKeyCheckDef: + STREAM_SYMBOL + | ON_SYMBOL + | OFF_SYMBOL +; + +masterTlsCiphersuitesDef: + textStringNoLinebreak + | NULL_SYMBOL +; + +masterFileDef: + MASTER_LOG_FILE_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | MASTER_LOG_POS_SYMBOL EQUAL_OPERATOR ulonglong_number + | RELAY_LOG_FILE_SYMBOL EQUAL_OPERATOR textStringNoLinebreak + | RELAY_LOG_POS_SYMBOL EQUAL_OPERATOR ulong_number +; + +serverIdList: + OPEN_PAR_SYMBOL (ulong_number (COMMA_SYMBOL ulong_number)*)? CLOSE_PAR_SYMBOL +; + +changeReplication: + CHANGE_SYMBOL REPLICATION_SYMBOL FILTER_SYMBOL filterDefinition ( + COMMA_SYMBOL filterDefinition + )* ({serverVersion >= 80000}? channel)? +; + +filterDefinition: + REPLICATE_DO_DB_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterDbList? CLOSE_PAR_SYMBOL + | REPLICATE_IGNORE_DB_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterDbList? CLOSE_PAR_SYMBOL + | REPLICATE_DO_TABLE_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterTableList? CLOSE_PAR_SYMBOL + | REPLICATE_IGNORE_TABLE_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterTableList? CLOSE_PAR_SYMBOL + | REPLICATE_WILD_DO_TABLE_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterStringList? CLOSE_PAR_SYMBOL + | REPLICATE_WILD_IGNORE_TABLE_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterStringList? CLOSE_PAR_SYMBOL + | REPLICATE_REWRITE_DB_SYMBOL EQUAL_OPERATOR OPEN_PAR_SYMBOL filterDbPairList? CLOSE_PAR_SYMBOL +; + +filterDbList: + schemaRef (COMMA_SYMBOL schemaRef)* +; + +filterTableList: + filterTableRef (COMMA_SYMBOL filterTableRef)* +; + +filterStringList: + filterWildDbTableString (COMMA_SYMBOL filterWildDbTableString)* +; + +filterWildDbTableString: + textStringNoLinebreak // sql_yacc.yy checks for the existance of at least one dot char in the string. +; + +filterDbPairList: + schemaIdentifierPair (COMMA_SYMBOL schemaIdentifierPair)* +; + +slave: + START_SYMBOL SLAVE_SYMBOL slaveThreadOptions? (UNTIL_SYMBOL slaveUntilOptions)? slaveConnectionOptions channel? + | STOP_SYMBOL SLAVE_SYMBOL slaveThreadOptions? channel? +; + +slaveUntilOptions: + ( + masterFileDef + | {serverVersion >= 50606}? ( + SQL_BEFORE_GTIDS_SYMBOL + | SQL_AFTER_GTIDS_SYMBOL + ) EQUAL_OPERATOR textString + | {serverVersion >= 50606}? SQL_AFTER_MTS_GAPS_SYMBOL + ) (COMMA_SYMBOL masterFileDef)* +; + +slaveConnectionOptions: + {serverVersion >= 50604}? (USER_SYMBOL EQUAL_OPERATOR textString)? ( + PASSWORD_SYMBOL EQUAL_OPERATOR textString + )? (DEFAULT_AUTH_SYMBOL EQUAL_OPERATOR textString)? ( + PLUGIN_DIR_SYMBOL EQUAL_OPERATOR textString + )? + | /* empty */ +; + +slaveThreadOptions: + slaveThreadOption (COMMA_SYMBOL slaveThreadOption)* +; + +slaveThreadOption: + RELAY_THREAD_SYMBOL + | SQL_THREAD_SYMBOL +; + +groupReplication: + (START_SYMBOL | STOP_SYMBOL) GROUP_REPLICATION_SYMBOL +; + +//---------------------------------------------------------------------------------------------------------------------- + +preparedStatement: + type = PREPARE_SYMBOL identifier FROM_SYMBOL (textLiteral | userVariable) + | executeStatement + | type = (DEALLOCATE_SYMBOL | DROP_SYMBOL) PREPARE_SYMBOL identifier +; + +executeStatement: + EXECUTE_SYMBOL identifier (USING_SYMBOL executeVarList)? +; + +executeVarList: + userVariable (COMMA_SYMBOL userVariable)* +; + +//---------------------------------------------------------------------------------------------------------------------- + +cloneStatement: + CLONE_SYMBOL ( + LOCAL_SYMBOL DATA_SYMBOL DIRECTORY_SYMBOL equal? textStringLiteral + // Clone remote has been removed in 8.0.14. This alt is taken out by the conditional REMOTE_SYMBOL. + | REMOTE_SYMBOL (FOR_SYMBOL REPLICATION_SYMBOL)? + | {serverVersion >= 80014}? INSTANCE_SYMBOL FROM_SYMBOL user COLON_SYMBOL ulong_number IDENTIFIED_SYMBOL BY_SYMBOL + textStringLiteral dataDirSSL? + ) +; + +dataDirSSL: + ssl + | DATA_SYMBOL DIRECTORY_SYMBOL equal? textStringLiteral ssl? +; + +ssl: + REQUIRE_SYMBOL NO_SYMBOL? SSL_SYMBOL +; + +//---------------------------------------------------------------------------------------------------------------------- + +// Note: SET PASSWORD is part of the SET statement. +accountManagementStatement: + {serverVersion >= 50606}? alterUser + | createUser + | dropUser + | grant + | renameUser + | revoke + | {serverVersion >= 80000}? setRole +; + +alterUser: + ALTER_SYMBOL USER_SYMBOL ({serverVersion >= 50706}? ifExists)? alterUserTail +; + +alterUserTail: + ({serverVersion < 80014}? createUserList | {serverVersion >= 80014}? alterUserList) createUserTail + | {serverVersion >= 50706}? user IDENTIFIED_SYMBOL BY_SYMBOL textString ( + {serverVersion >= 80014}? replacePassword + )? ({serverVersion >= 80014}? retainCurrentPassword)? + | {serverVersion >= 80014}? user discardOldPassword + | {serverVersion >= 80000}? user DEFAULT_SYMBOL ROLE_SYMBOL ( + ALL_SYMBOL + | NONE_SYMBOL + | roleList + ) + | {serverVersion >= 80018}? user IDENTIFIED_SYMBOL (WITH_SYMBOL textOrIdentifier)? BY_SYMBOL RANDOM_SYMBOL + PASSWORD_SYMBOL retainCurrentPassword? + | FAILED_LOGIN_ATTEMPTS_SYMBOL real_ulong_number + | PASSWORD_LOCK_TIME_SYMBOL (real_ulong_number | UNBOUNDED_SYMBOL) +; + +userFunction: + USER_SYMBOL parentheses +; + +createUser: + CREATE_SYMBOL USER_SYMBOL ({serverVersion >= 50706}? ifNotExists | /* empty */) createUserList defaultRoleClause + createUserTail +; + +createUserTail: + {serverVersion >= 50706}? requireClause? connectOptions? accountLockPasswordExpireOptions* + | /* empty */ +; + +defaultRoleClause: + {serverVersion >= 80000}? (DEFAULT_SYMBOL ROLE_SYMBOL roleList)? + | /* empty */ +; + +requireClause: + REQUIRE_SYMBOL (requireList | option = (SSL_SYMBOL | X509_SYMBOL | NONE_SYMBOL)) +; + +connectOptions: + WITH_SYMBOL ( + MAX_QUERIES_PER_HOUR_SYMBOL ulong_number + | MAX_UPDATES_PER_HOUR_SYMBOL ulong_number + | MAX_CONNECTIONS_PER_HOUR_SYMBOL ulong_number + | MAX_USER_CONNECTIONS_SYMBOL ulong_number + )+ +; + +accountLockPasswordExpireOptions: + ACCOUNT_SYMBOL (LOCK_SYMBOL | UNLOCK_SYMBOL) + | PASSWORD_SYMBOL ( + EXPIRE_SYMBOL ( + INTERVAL_SYMBOL real_ulong_number DAY_SYMBOL + | NEVER_SYMBOL + | DEFAULT_SYMBOL + )? + | HISTORY_SYMBOL (real_ulong_number | DEFAULT_SYMBOL) + | REUSE_SYMBOL INTERVAL_SYMBOL ( + real_ulong_number DAY_SYMBOL + | DEFAULT_SYMBOL + ) + | {serverVersion >= 80014}? REQUIRE_SYMBOL CURRENT_SYMBOL ( + DEFAULT_SYMBOL + | OPTIONAL_SYMBOL + )? + ) +; + +dropUser: + DROP_SYMBOL USER_SYMBOL ({serverVersion >= 50706}? ifExists)? userList +; + +grant: + GRANT_SYMBOL ( + {serverVersion >= 80000}? roleOrPrivilegesList TO_SYMBOL userList ( + WITH_SYMBOL ADMIN_SYMBOL OPTION_SYMBOL + )? + | (roleOrPrivilegesList | ALL_SYMBOL PRIVILEGES_SYMBOL?) ON_SYMBOL aclType? grantIdentifier TO_SYMBOL grantTargetList + versionedRequireClause? grantOptions? grantAs? + | PROXY_SYMBOL ON_SYMBOL user TO_SYMBOL grantTargetList ( + WITH_SYMBOL GRANT_SYMBOL OPTION_SYMBOL + )? + ) +; + +grantTargetList: + {serverVersion < 80011}? createUserList + | {serverVersion >= 80011}? userList +; + +grantOptions: + {serverVersion < 80011}? WITH_SYMBOL grantOption+ + | {serverVersion >= 80011}? WITH_SYMBOL GRANT_SYMBOL OPTION_SYMBOL +; + +exceptRoleList: + EXCEPT_SYMBOL roleList +; + +withRoles: + WITH_SYMBOL ROLE_SYMBOL ( + roleList + | ALL_SYMBOL exceptRoleList? + | NONE_SYMBOL + | DEFAULT_SYMBOL + ) +; + +grantAs: + AS_SYMBOL USER_SYMBOL withRoles? +; + +versionedRequireClause: + {serverVersion < 80011}? requireClause +; + +renameUser: + RENAME_SYMBOL USER_SYMBOL user TO_SYMBOL user (COMMA_SYMBOL user TO_SYMBOL user)* +; + +revoke: + REVOKE_SYMBOL ( + {serverVersion >= 80000}? roleOrPrivilegesList FROM_SYMBOL userList + | roleOrPrivilegesList onTypeTo FROM_SYMBOL userList + | ALL_SYMBOL PRIVILEGES_SYMBOL? ( + {serverVersion >= 80000}? ON_SYMBOL aclType? grantIdentifier + | COMMA_SYMBOL GRANT_SYMBOL OPTION_SYMBOL FROM_SYMBOL userList + ) + | PROXY_SYMBOL ON_SYMBOL user FROM_SYMBOL userList + ) +; + +onTypeTo: // Optional, starting with 8.0.1. + {serverVersion < 80000}? ON_SYMBOL aclType? grantIdentifier + | {serverVersion >= 80000}? (ON_SYMBOL aclType? grantIdentifier)? +; + +aclType: + TABLE_SYMBOL + | FUNCTION_SYMBOL + | PROCEDURE_SYMBOL +; + +roleOrPrivilegesList: + roleOrPrivilege (COMMA_SYMBOL roleOrPrivilege)* +; + +roleOrPrivilege: + {serverVersion > 80000}? ( + roleIdentifierOrText columnInternalRefList? + | roleIdentifierOrText (AT_TEXT_SUFFIX | AT_SIGN_SYMBOL textOrIdentifier) + ) + | (SELECT_SYMBOL | INSERT_SYMBOL | UPDATE_SYMBOL | REFERENCES_SYMBOL) columnInternalRefList? + | ( + DELETE_SYMBOL + | USAGE_SYMBOL + | INDEX_SYMBOL + | DROP_SYMBOL + | EXECUTE_SYMBOL + | RELOAD_SYMBOL + | SHUTDOWN_SYMBOL + | PROCESS_SYMBOL + | FILE_SYMBOL + | PROXY_SYMBOL + | SUPER_SYMBOL + | EVENT_SYMBOL + | TRIGGER_SYMBOL + ) + | GRANT_SYMBOL OPTION_SYMBOL + | SHOW_SYMBOL DATABASES_SYMBOL + | CREATE_SYMBOL ( + TEMPORARY_SYMBOL object = TABLES_SYMBOL + | object = (ROUTINE_SYMBOL | TABLESPACE_SYMBOL | USER_SYMBOL | VIEW_SYMBOL) + )? + | LOCK_SYMBOL TABLES_SYMBOL + | REPLICATION_SYMBOL object = (CLIENT_SYMBOL | SLAVE_SYMBOL) + | SHOW_SYMBOL VIEW_SYMBOL + | ALTER_SYMBOL ROUTINE_SYMBOL? + | {serverVersion > 80000}? (CREATE_SYMBOL | DROP_SYMBOL) ROLE_SYMBOL +; + +grantIdentifier: + MULT_OPERATOR (DOT_SYMBOL MULT_OPERATOR)? + | schemaRef (DOT_SYMBOL MULT_OPERATOR)? + | tableRef + | {serverVersion >= 80017}? schemaRef DOT_SYMBOL tableRef +; + +requireList: + requireListElement (AND_SYMBOL? requireListElement)* +; + +requireListElement: + element = CIPHER_SYMBOL textString + | element = ISSUER_SYMBOL textString + | element = SUBJECT_SYMBOL textString +; + +grantOption: + option = GRANT_SYMBOL OPTION_SYMBOL + | option = MAX_QUERIES_PER_HOUR_SYMBOL ulong_number + | option = MAX_UPDATES_PER_HOUR_SYMBOL ulong_number + | option = MAX_CONNECTIONS_PER_HOUR_SYMBOL ulong_number + | option = MAX_USER_CONNECTIONS_SYMBOL ulong_number +; + +setRole: + SET_SYMBOL ROLE_SYMBOL roleList + | SET_SYMBOL ROLE_SYMBOL (NONE_SYMBOL | DEFAULT_SYMBOL) + | SET_SYMBOL DEFAULT_SYMBOL ROLE_SYMBOL (roleList | NONE_SYMBOL | ALL_SYMBOL) TO_SYMBOL roleList + | SET_SYMBOL ROLE_SYMBOL ALL_SYMBOL (EXCEPT_SYMBOL roleList)? +; + +roleList: + role (COMMA_SYMBOL role)* +; + +role: + roleIdentifierOrText (AT_SIGN_SYMBOL textOrIdentifier | AT_TEXT_SUFFIX)? +; + +//---------------------------------------------------------------------------------------------------------------------- + +tableAdministrationStatement: + type = ANALYZE_SYMBOL noWriteToBinLog? TABLE_SYMBOL tableRefList ( + {serverVersion >= 80000}? histogram + )? + | type = CHECK_SYMBOL TABLE_SYMBOL tableRefList checkOption* + | type = CHECKSUM_SYMBOL TABLE_SYMBOL tableRefList ( + QUICK_SYMBOL + | EXTENDED_SYMBOL + )? + | type = OPTIMIZE_SYMBOL noWriteToBinLog? TABLE_SYMBOL tableRefList + | type = REPAIR_SYMBOL noWriteToBinLog? TABLE_SYMBOL tableRefList repairType* +; + +histogram: + UPDATE_SYMBOL HISTOGRAM_SYMBOL ON_SYMBOL identifierList ( + WITH_SYMBOL INT_NUMBER BUCKETS_SYMBOL + )? + | DROP_SYMBOL HISTOGRAM_SYMBOL ON_SYMBOL identifierList +; + +checkOption: + FOR_SYMBOL UPGRADE_SYMBOL + | (QUICK_SYMBOL | FAST_SYMBOL | MEDIUM_SYMBOL | EXTENDED_SYMBOL | CHANGED_SYMBOL) +; + +repairType: + QUICK_SYMBOL + | EXTENDED_SYMBOL + | USE_FRM_SYMBOL +; + +//---------------------------------------------------------------------------------------------------------------------- + +installUninstallStatment: + // COMPONENT_SYMBOL is conditionally set in the lexer. + action = INSTALL_SYMBOL type = PLUGIN_SYMBOL identifier SONAME_SYMBOL textStringLiteral + | action = INSTALL_SYMBOL type = COMPONENT_SYMBOL textStringLiteralList + | action = UNINSTALL_SYMBOL type = PLUGIN_SYMBOL pluginRef + | action = UNINSTALL_SYMBOL type = COMPONENT_SYMBOL componentRef ( + COMMA_SYMBOL componentRef + )* +; + +//---------------------------------------------------------------------------------------------------------------------- + +setStatement: + SET_SYMBOL startOptionValueList +; + +startOptionValueList: + optionValueNoOptionType optionValueListContinued + | TRANSACTION_SYMBOL transactionCharacteristics + | optionType startOptionValueListFollowingOptionType + | PASSWORD_SYMBOL (FOR_SYMBOL user)? equal ( + textString replacePassword? retainCurrentPassword? + | textString replacePassword? retainCurrentPassword? + | {serverVersion < 50706}? OLD_PASSWORD_SYMBOL OPEN_PAR_SYMBOL textString CLOSE_PAR_SYMBOL + | {serverVersion < 80014}? PASSWORD_SYMBOL OPEN_PAR_SYMBOL textString CLOSE_PAR_SYMBOL + ) + | {serverVersion >= 80018}? PASSWORD_SYMBOL (FOR_SYMBOL user)? TO_SYMBOL RANDOM_SYMBOL replacePassword? retainCurrentPassword? +; + +transactionCharacteristics: + transactionAccessMode isolationLevel? + | isolationLevel (COMMA_SYMBOL transactionAccessMode)? +; + +transactionAccessMode: + READ_SYMBOL (WRITE_SYMBOL | ONLY_SYMBOL) +; + +isolationLevel: + ISOLATION_SYMBOL LEVEL_SYMBOL ( + REPEATABLE_SYMBOL READ_SYMBOL + | READ_SYMBOL (COMMITTED_SYMBOL | UNCOMMITTED_SYMBOL) + | SERIALIZABLE_SYMBOL + ) +; + +optionValueListContinued: + (COMMA_SYMBOL optionValue)* +; + +optionValueNoOptionType: + internalVariableName equal setExprOrDefault + | charsetClause + | userVariable equal expr + | setSystemVariable equal setExprOrDefault + | NAMES_SYMBOL ( + equal expr + | charsetName collate? + | {serverVersion >= 80011}? DEFAULT_SYMBOL + ) +; + +optionValue: + optionType internalVariableName equal setExprOrDefault + | optionValueNoOptionType +; + +setSystemVariable: + AT_AT_SIGN_SYMBOL setVarIdentType? internalVariableName +; + +startOptionValueListFollowingOptionType: + optionValueFollowingOptionType optionValueListContinued + | TRANSACTION_SYMBOL transactionCharacteristics +; + +optionValueFollowingOptionType: + internalVariableName equal setExprOrDefault +; + +setExprOrDefault: + expr + | (DEFAULT_SYMBOL | ON_SYMBOL | ALL_SYMBOL | BINARY_SYMBOL) + | {serverVersion >= 80000}? (ROW_SYMBOL | SYSTEM_SYMBOL) +; + +//---------------------------------------------------------------------------------------------------------------------- + +showStatement: + SHOW_SYMBOL ( + {serverVersion < 50700}? value = AUTHORS_SYMBOL + | value = DATABASES_SYMBOL likeOrWhere? + | showCommandType? value = TABLES_SYMBOL inDb? likeOrWhere? + | FULL_SYMBOL? value = TRIGGERS_SYMBOL inDb? likeOrWhere? + | value = EVENTS_SYMBOL inDb? likeOrWhere? + | value = TABLE_SYMBOL STATUS_SYMBOL inDb? likeOrWhere? + | value = OPEN_SYMBOL TABLES_SYMBOL inDb? likeOrWhere? + | value = PLUGINS_SYMBOL + | value = ENGINE_SYMBOL (engineRef | ALL_SYMBOL) ( + STATUS_SYMBOL + | MUTEX_SYMBOL + | LOGS_SYMBOL + ) + | showCommandType? value = COLUMNS_SYMBOL (FROM_SYMBOL | IN_SYMBOL) tableRef inDb? likeOrWhere? + | (BINARY_SYMBOL | MASTER_SYMBOL) value = LOGS_SYMBOL + | value = SLAVE_SYMBOL (HOSTS_SYMBOL | STATUS_SYMBOL nonBlocking channel?) + | value = (BINLOG_SYMBOL | RELAYLOG_SYMBOL) EVENTS_SYMBOL ( + IN_SYMBOL textString + )? (FROM_SYMBOL ulonglong_number)? limitClause? channel? + | ({serverVersion >= 80000}? EXTENDED_SYMBOL)? value = ( + INDEX_SYMBOL + | INDEXES_SYMBOL + | KEYS_SYMBOL + ) fromOrIn tableRef inDb? whereClause? + | STORAGE_SYMBOL? value = ENGINES_SYMBOL + | COUNT_SYMBOL OPEN_PAR_SYMBOL MULT_OPERATOR CLOSE_PAR_SYMBOL value = ( + WARNINGS_SYMBOL + | ERRORS_SYMBOL + ) + | value = WARNINGS_SYMBOL limitClause? + | value = ERRORS_SYMBOL limitClause? + | value = PROFILES_SYMBOL + | value = PROFILE_SYMBOL (profileType (COMMA_SYMBOL profileType)*)? ( + FOR_SYMBOL QUERY_SYMBOL INT_NUMBER + )? limitClause? + | optionType? value = (STATUS_SYMBOL | VARIABLES_SYMBOL) likeOrWhere? + | FULL_SYMBOL? value = PROCESSLIST_SYMBOL + | charset likeOrWhere? + | value = COLLATION_SYMBOL likeOrWhere? + | {serverVersion < 50700}? value = CONTRIBUTORS_SYMBOL + | value = PRIVILEGES_SYMBOL + | value = GRANTS_SYMBOL (FOR_SYMBOL user)? + | value = GRANTS_SYMBOL FOR_SYMBOL user USING_SYMBOL userList + | value = MASTER_SYMBOL STATUS_SYMBOL + | value = CREATE_SYMBOL ( + object = DATABASE_SYMBOL ifNotExists? schemaRef + | object = EVENT_SYMBOL eventRef + | object = FUNCTION_SYMBOL functionRef + | object = PROCEDURE_SYMBOL procedureRef + | object = TABLE_SYMBOL tableRef + | object = TRIGGER_SYMBOL triggerRef + | object = VIEW_SYMBOL viewRef + | {serverVersion >= 50704}? object = USER_SYMBOL user + ) + | value = PROCEDURE_SYMBOL STATUS_SYMBOL likeOrWhere? + | value = FUNCTION_SYMBOL STATUS_SYMBOL likeOrWhere? + | value = PROCEDURE_SYMBOL CODE_SYMBOL procedureRef + | value = FUNCTION_SYMBOL CODE_SYMBOL functionRef + ) +; + +showCommandType: + FULL_SYMBOL + | {serverVersion >= 80000}? EXTENDED_SYMBOL FULL_SYMBOL? +; + +nonBlocking: + {serverVersion >= 50700 && serverVersion < 50706}? NONBLOCKING_SYMBOL? + | /* empty */ +; + +fromOrIn: + FROM_SYMBOL + | IN_SYMBOL +; + +inDb: + fromOrIn identifier +; + +profileType: + BLOCK_SYMBOL IO_SYMBOL + | CONTEXT_SYMBOL SWITCHES_SYMBOL + | PAGE_SYMBOL FAULTS_SYMBOL + | ( + ALL_SYMBOL + | CPU_SYMBOL + | IPC_SYMBOL + | MEMORY_SYMBOL + | SOURCE_SYMBOL + | SWAPS_SYMBOL + ) +; + +//---------------------------------------------------------------------------------------------------------------------- + +otherAdministrativeStatement: + type = BINLOG_SYMBOL textLiteral + | type = CACHE_SYMBOL INDEX_SYMBOL keyCacheListOrParts IN_SYMBOL ( + identifier + | DEFAULT_SYMBOL + ) + | type = FLUSH_SYMBOL noWriteToBinLog? ( + flushTables + | flushOption (COMMA_SYMBOL flushOption)* + ) + | type = KILL_SYMBOL (CONNECTION_SYMBOL | QUERY_SYMBOL)? expr + | type = LOAD_SYMBOL INDEX_SYMBOL INTO_SYMBOL CACHE_SYMBOL preloadTail + | {serverVersion >= 50709}? type = SHUTDOWN_SYMBOL +; + +keyCacheListOrParts: + keyCacheList + | assignToKeycachePartition +; + +keyCacheList: + assignToKeycache (COMMA_SYMBOL assignToKeycache)* +; + +assignToKeycache: + tableRef cacheKeyList? +; + +assignToKeycachePartition: + tableRef PARTITION_SYMBOL OPEN_PAR_SYMBOL allOrPartitionNameList CLOSE_PAR_SYMBOL cacheKeyList? +; + +cacheKeyList: + keyOrIndex OPEN_PAR_SYMBOL keyUsageList? CLOSE_PAR_SYMBOL +; + +keyUsageElement: + identifier + | PRIMARY_SYMBOL +; + +keyUsageList: + keyUsageElement (COMMA_SYMBOL keyUsageElement)* +; + +flushOption: + option = ( + DES_KEY_FILE_SYMBOL // No longer used from 8.0 onwards. Taken out by lexer. + | HOSTS_SYMBOL + | PRIVILEGES_SYMBOL + | STATUS_SYMBOL + | USER_RESOURCES_SYMBOL + ) + | logType? option = LOGS_SYMBOL + | option = RELAY_SYMBOL LOGS_SYMBOL channel? + | {serverVersion < 80000}? option = QUERY_SYMBOL CACHE_SYMBOL + | {serverVersion >= 50706}? option = OPTIMIZER_COSTS_SYMBOL +; + +logType: + BINARY_SYMBOL + | ENGINE_SYMBOL + | ERROR_SYMBOL + | GENERAL_SYMBOL + | SLOW_SYMBOL +; + +flushTables: + (TABLES_SYMBOL | TABLE_SYMBOL) ( + WITH_SYMBOL READ_SYMBOL LOCK_SYMBOL + | identifierList flushTablesOptions? + )? +; + +flushTablesOptions: + {serverVersion >= 50606}? FOR_SYMBOL EXPORT_SYMBOL + | WITH_SYMBOL READ_SYMBOL LOCK_SYMBOL +; + +preloadTail: + tableRef adminPartition cacheKeyList? (IGNORE_SYMBOL LEAVES_SYMBOL)? + | preloadList +; + +preloadList: + preloadKeys (COMMA_SYMBOL preloadKeys)* +; + +preloadKeys: + tableRef cacheKeyList? (IGNORE_SYMBOL LEAVES_SYMBOL)? +; + +adminPartition: + PARTITION_SYMBOL OPEN_PAR_SYMBOL allOrPartitionNameList CLOSE_PAR_SYMBOL +; + +//---------------------------------------------------------------------------------------------------------------------- + +resourceGroupManagement: + createResourceGroup + | alterResourceGroup + | setResourceGroup + | dropResourceGroup +; + +createResourceGroup: + CREATE_SYMBOL RESOURCE_SYMBOL GROUP_SYMBOL identifier TYPE_SYMBOL equal? ( + USER_SYMBOL + | SYSTEM_SYMBOL + ) resourceGroupVcpuList? resourceGroupPriority? resourceGroupEnableDisable? +; + +resourceGroupVcpuList: + VCPU_SYMBOL equal? vcpuNumOrRange (COMMA_SYMBOL? vcpuNumOrRange)* +; + +vcpuNumOrRange: + INT_NUMBER (MINUS_OPERATOR INT_NUMBER)? +; + +resourceGroupPriority: + THREAD_PRIORITY_SYMBOL equal? INT_NUMBER +; + +resourceGroupEnableDisable: + ENABLE_SYMBOL + | DISABLE_SYMBOL +; + +alterResourceGroup: + ALTER_SYMBOL RESOURCE_SYMBOL GROUP_SYMBOL resourceGroupRef resourceGroupVcpuList? resourceGroupPriority? + resourceGroupEnableDisable? FORCE_SYMBOL? +; + +setResourceGroup: + SET_SYMBOL RESOURCE_SYMBOL GROUP_SYMBOL identifier (FOR_SYMBOL threadIdList)? +; + +threadIdList: + real_ulong_number (COMMA_SYMBOL? real_ulong_number)* +; + +dropResourceGroup: + DROP_SYMBOL RESOURCE_SYMBOL GROUP_SYMBOL resourceGroupRef FORCE_SYMBOL? +; + +//---------------------------------------------------------------------------------------------------------------------- + +utilityStatement: + describeStatement + | explainStatement + | helpCommand + | useCommand + | {serverVersion >= 80011}? restartServer +; + +describeStatement: + (EXPLAIN_SYMBOL | DESCRIBE_SYMBOL | DESC_SYMBOL) tableRef ( + textString + | columnRef + )? +; + +explainStatement: + (EXPLAIN_SYMBOL | DESCRIBE_SYMBOL | DESC_SYMBOL) ( + {serverVersion < 80000}? EXTENDED_SYMBOL + | {serverVersion < 80000}? PARTITIONS_SYMBOL + | {serverVersion >= 50605}? FORMAT_SYMBOL EQUAL_OPERATOR textOrIdentifier + | {serverVersion >= 80018}? ANALYZE_SYMBOL + | {serverVersion >= 80019}? ANALYZE_SYMBOL FORMAT_SYMBOL EQUAL_OPERATOR textOrIdentifier + )? explainableStatement +; + +// Before server version 5.6 only select statements were explainable. +explainableStatement: + selectStatement + | {serverVersion >= 50603}? ( + deleteStatement + | insertStatement + | replaceStatement + | updateStatement + ) + | {serverVersion >= 50700}? FOR_SYMBOL CONNECTION_SYMBOL real_ulong_number +; + +helpCommand: + HELP_SYMBOL textOrIdentifier +; + +useCommand: + USE_SYMBOL identifier +; + +restartServer: + RESTART_SYMBOL +; + +//----------------- Expression support --------------------------------------------------------------------------------- + +expr: + boolPri (IS_SYMBOL notRule? type = (TRUE_SYMBOL | FALSE_SYMBOL | UNKNOWN_SYMBOL))? # exprIs + | NOT_SYMBOL expr # exprNot + | expr op = (AND_SYMBOL | LOGICAL_AND_OPERATOR) expr # exprAnd + | expr XOR_SYMBOL expr # exprXor + | expr op = (OR_SYMBOL | LOGICAL_OR_OPERATOR) expr # exprOr +; + +boolPri: + predicate # primaryExprPredicate + | boolPri IS_SYMBOL notRule? NULL_SYMBOL # primaryExprIsNull + | boolPri compOp predicate # primaryExprCompare + | boolPri compOp (ALL_SYMBOL | ANY_SYMBOL) subquery # primaryExprAllAny +; + +compOp: + EQUAL_OPERATOR + | NULL_SAFE_EQUAL_OPERATOR + | GREATER_OR_EQUAL_OPERATOR + | GREATER_THAN_OPERATOR + | LESS_OR_EQUAL_OPERATOR + | LESS_THAN_OPERATOR + | NOT_EQUAL_OPERATOR +; + +predicate: + bitExpr ( + notRule? predicateOperations + | {serverVersion >= 80017}? MEMBER_SYMBOL OF_SYMBOL? simpleExprWithParentheses + | SOUNDS_SYMBOL LIKE_SYMBOL bitExpr + )? +; + +predicateOperations: + IN_SYMBOL (subquery | OPEN_PAR_SYMBOL exprList CLOSE_PAR_SYMBOL) # predicateExprIn + | BETWEEN_SYMBOL bitExpr AND_SYMBOL predicate # predicateExprBetween + | LIKE_SYMBOL simpleExpr (ESCAPE_SYMBOL simpleExpr)? # predicateExprLike + | REGEXP_SYMBOL bitExpr # predicateExprRegex +; + +bitExpr: + simpleExpr + | bitExpr op = BITWISE_XOR_OPERATOR bitExpr + | bitExpr op = ( + MULT_OPERATOR + | DIV_OPERATOR + | MOD_OPERATOR + | DIV_SYMBOL + | MOD_SYMBOL + ) bitExpr + | bitExpr op = (PLUS_OPERATOR | MINUS_OPERATOR) bitExpr + | bitExpr op = (PLUS_OPERATOR | MINUS_OPERATOR) INTERVAL_SYMBOL expr interval + | bitExpr op = (SHIFT_LEFT_OPERATOR | SHIFT_RIGHT_OPERATOR) bitExpr + | bitExpr op = BITWISE_AND_OPERATOR bitExpr + | bitExpr op = BITWISE_OR_OPERATOR bitExpr +; + +simpleExpr: + variable (equal expr)? # simpleExprVariable + | columnRef jsonOperator? # simpleExprColumnRef + | runtimeFunctionCall # simpleExprRuntimeFunction + | functionCall # simpleExprFunction + | simpleExpr COLLATE_SYMBOL textOrIdentifier # simpleExprCollate + | literal # simpleExprLiteral + | PARAM_MARKER # simpleExprParamMarker + | sumExpr # simpleExprSum + | {serverVersion >= 80000}? groupingOperation # simpleExprGroupingOperation + | {serverVersion >= 80000}? windowFunctionCall # simpleExprWindowingFunction + | simpleExpr CONCAT_PIPES_SYMBOL simpleExpr # simpleExprConcat + | op = (PLUS_OPERATOR | MINUS_OPERATOR | BITWISE_NOT_OPERATOR) simpleExpr # simpleExprUnary + | not2Rule simpleExpr # simpleExprNot + | ROW_SYMBOL? OPEN_PAR_SYMBOL exprList CLOSE_PAR_SYMBOL # simpleExprList + | EXISTS_SYMBOL? subquery # simpleExprSubQuery + | OPEN_CURLY_SYMBOL identifier expr CLOSE_CURLY_SYMBOL # simpleExprOdbc + | MATCH_SYMBOL identListArg AGAINST_SYMBOL OPEN_PAR_SYMBOL bitExpr fulltextOptions? CLOSE_PAR_SYMBOL # simpleExprMatch + | BINARY_SYMBOL simpleExpr # simpleExprBinary + | CAST_SYMBOL OPEN_PAR_SYMBOL expr AS_SYMBOL castType arrayCast? CLOSE_PAR_SYMBOL # simpleExprCast + | CASE_SYMBOL expr? (whenExpression thenExpression)+ elseExpression? END_SYMBOL # simpleExprCase + | CONVERT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL castType CLOSE_PAR_SYMBOL # simpleExprConvert + | CONVERT_SYMBOL OPEN_PAR_SYMBOL expr USING_SYMBOL charsetName CLOSE_PAR_SYMBOL # simpleExprConvertUsing + | DEFAULT_SYMBOL OPEN_PAR_SYMBOL simpleIdentifier CLOSE_PAR_SYMBOL # simpleExprDefault + | VALUES_SYMBOL OPEN_PAR_SYMBOL simpleIdentifier CLOSE_PAR_SYMBOL # simpleExprValues + | INTERVAL_SYMBOL expr interval PLUS_OPERATOR expr # simpleExprInterval +; + +arrayCast: + {serverVersion >= 80017}? ARRAY_SYMBOL +; + +jsonOperator: + {serverVersion >= 50708}? JSON_SEPARATOR_SYMBOL textStringLiteral + | {serverVersion >= 50713}? JSON_UNQUOTED_SEPARATOR_SYMBOL textStringLiteral +; + +sumExpr: + name = AVG_SYMBOL OPEN_PAR_SYMBOL DISTINCT_SYMBOL? inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = (BIT_AND_SYMBOL | BIT_OR_SYMBOL | BIT_XOR_SYMBOL) OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | {serverVersion >= 80000}? jsonFunction + | name = COUNT_SYMBOL OPEN_PAR_SYMBOL ALL_SYMBOL? MULT_OPERATOR CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = COUNT_SYMBOL OPEN_PAR_SYMBOL ( + ALL_SYMBOL? MULT_OPERATOR + | inSumExpr + | DISTINCT_SYMBOL exprList + ) CLOSE_PAR_SYMBOL ({serverVersion >= 80000}? windowingClause)? + | name = MIN_SYMBOL OPEN_PAR_SYMBOL DISTINCT_SYMBOL? inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = MAX_SYMBOL OPEN_PAR_SYMBOL DISTINCT_SYMBOL? inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = STD_SYMBOL OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = VARIANCE_SYMBOL OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = STDDEV_SAMP_SYMBOL OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = VAR_SAMP_SYMBOL OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = SUM_SYMBOL OPEN_PAR_SYMBOL DISTINCT_SYMBOL? inSumExpr CLOSE_PAR_SYMBOL ( + {serverVersion >= 80000}? windowingClause + )? + | name = GROUP_CONCAT_SYMBOL OPEN_PAR_SYMBOL DISTINCT_SYMBOL? exprList orderClause? ( + SEPARATOR_SYMBOL textString + )? CLOSE_PAR_SYMBOL ({serverVersion >= 80000}? windowingClause)? +; + +groupingOperation: + GROUPING_SYMBOL OPEN_PAR_SYMBOL exprList CLOSE_PAR_SYMBOL +; + +windowFunctionCall: + ( + ROW_NUMBER_SYMBOL + | RANK_SYMBOL + | DENSE_RANK_SYMBOL + | CUME_DIST_SYMBOL + | PERCENT_RANK_SYMBOL + ) parentheses windowingClause + | NTILE_SYMBOL simpleExprWithParentheses windowingClause + | (LEAD_SYMBOL | LAG_SYMBOL) OPEN_PAR_SYMBOL expr leadLagInfo? CLOSE_PAR_SYMBOL nullTreatment? windowingClause + | (FIRST_VALUE_SYMBOL | LAST_VALUE_SYMBOL) exprWithParentheses nullTreatment? windowingClause + | NTH_VALUE_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL simpleExpr CLOSE_PAR_SYMBOL ( + FROM_SYMBOL (FIRST_SYMBOL | LAST_SYMBOL) + )? nullTreatment? windowingClause +; + +windowingClause: + OVER_SYMBOL (windowName | windowSpec) +; + +leadLagInfo: + COMMA_SYMBOL (ulonglong_number | PARAM_MARKER) (COMMA_SYMBOL expr)? +; + +nullTreatment: + (RESPECT_SYMBOL | IGNORE_SYMBOL) NULLS_SYMBOL +; + +jsonFunction: + JSON_ARRAYAGG_SYMBOL OPEN_PAR_SYMBOL inSumExpr CLOSE_PAR_SYMBOL windowingClause? + | JSON_OBJECTAGG_SYMBOL OPEN_PAR_SYMBOL inSumExpr COMMA_SYMBOL inSumExpr CLOSE_PAR_SYMBOL windowingClause? +; + +inSumExpr: + ALL_SYMBOL? expr +; + +identListArg: + identList + | OPEN_PAR_SYMBOL identList CLOSE_PAR_SYMBOL +; + +identList: + simpleIdentifier (COMMA_SYMBOL simpleIdentifier)* +; + +fulltextOptions: + IN_SYMBOL BOOLEAN_SYMBOL MODE_SYMBOL + | IN_SYMBOL NATURAL_SYMBOL LANGUAGE_SYMBOL MODE_SYMBOL ( + WITH_SYMBOL QUERY_SYMBOL EXPANSION_SYMBOL + )? + | WITH_SYMBOL QUERY_SYMBOL EXPANSION_SYMBOL +; + +runtimeFunctionCall: + // Function names that are keywords. + name = CHAR_SYMBOL OPEN_PAR_SYMBOL exprList (USING_SYMBOL charsetName)? CLOSE_PAR_SYMBOL + | name = CURRENT_USER_SYMBOL parentheses? + | name = DATE_SYMBOL exprWithParentheses + | name = DAY_SYMBOL exprWithParentheses + | name = HOUR_SYMBOL exprWithParentheses + | name = INSERT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr COMMA_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = INTERVAL_SYMBOL OPEN_PAR_SYMBOL expr (COMMA_SYMBOL expr)+ CLOSE_PAR_SYMBOL + | name = LEFT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = MINUTE_SYMBOL exprWithParentheses + | name = MONTH_SYMBOL exprWithParentheses + | name = RIGHT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = SECOND_SYMBOL exprWithParentheses + | name = TIME_SYMBOL exprWithParentheses + | name = TIMESTAMP_SYMBOL OPEN_PAR_SYMBOL expr (COMMA_SYMBOL expr)? CLOSE_PAR_SYMBOL + | trimFunction + | name = USER_SYMBOL parentheses + | name = VALUES_SYMBOL exprWithParentheses + | name = YEAR_SYMBOL exprWithParentheses + + // Function names that are not keywords. + | name = (ADDDATE_SYMBOL | SUBDATE_SYMBOL) OPEN_PAR_SYMBOL expr COMMA_SYMBOL ( + expr + | INTERVAL_SYMBOL expr interval + ) CLOSE_PAR_SYMBOL + | name = CURDATE_SYMBOL parentheses? + | name = CURTIME_SYMBOL timeFunctionParameters? + | name = (DATE_ADD_SYMBOL | DATE_SUB_SYMBOL) OPEN_PAR_SYMBOL expr COMMA_SYMBOL INTERVAL_SYMBOL expr interval CLOSE_PAR_SYMBOL + | name = EXTRACT_SYMBOL OPEN_PAR_SYMBOL interval FROM_SYMBOL expr CLOSE_PAR_SYMBOL + | name = GET_FORMAT_SYMBOL OPEN_PAR_SYMBOL dateTimeTtype COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = NOW_SYMBOL timeFunctionParameters? + | name = POSITION_SYMBOL OPEN_PAR_SYMBOL bitExpr IN_SYMBOL expr CLOSE_PAR_SYMBOL + | substringFunction + | name = SYSDATE_SYMBOL timeFunctionParameters? + | name = (TIMESTAMP_ADD_SYMBOL | TIMESTAMP_DIFF_SYMBOL) OPEN_PAR_SYMBOL intervalTimeStamp COMMA_SYMBOL expr COMMA_SYMBOL expr + CLOSE_PAR_SYMBOL + | name = UTC_DATE_SYMBOL parentheses? + | name = UTC_TIME_SYMBOL timeFunctionParameters? + | name = UTC_TIMESTAMP_SYMBOL timeFunctionParameters? + + // Function calls with other conflicts. + | name = ASCII_SYMBOL exprWithParentheses + | name = CHARSET_SYMBOL exprWithParentheses + | name = COALESCE_SYMBOL exprListWithParentheses + | name = COLLATION_SYMBOL exprWithParentheses + | name = DATABASE_SYMBOL parentheses + | name = IF_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = FORMAT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr (COMMA_SYMBOL expr)? CLOSE_PAR_SYMBOL + | name = MICROSECOND_SYMBOL exprWithParentheses + | name = MOD_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | {serverVersion < 50607}? name = OLD_PASSWORD_SYMBOL OPEN_PAR_SYMBOL textLiteral CLOSE_PAR_SYMBOL + | {serverVersion < 80011}? name = PASSWORD_SYMBOL exprWithParentheses + | name = QUARTER_SYMBOL exprWithParentheses + | name = REPEAT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = REPLACE_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = REVERSE_SYMBOL exprWithParentheses + | name = ROW_COUNT_SYMBOL parentheses + | name = TRUNCATE_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = WEEK_SYMBOL OPEN_PAR_SYMBOL expr (COMMA_SYMBOL expr)? CLOSE_PAR_SYMBOL + | name = WEIGHT_STRING_SYMBOL OPEN_PAR_SYMBOL expr ( + (AS_SYMBOL CHAR_SYMBOL wsNumCodepoints)? ( + {serverVersion < 80000}? weightStringLevels + )? + | AS_SYMBOL BINARY_SYMBOL wsNumCodepoints + | COMMA_SYMBOL ulong_number COMMA_SYMBOL ulong_number COMMA_SYMBOL ulong_number + ) CLOSE_PAR_SYMBOL + | geometryFunction +; + +geometryFunction: + {serverVersion < 50706}? name = CONTAINS_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = GEOMETRYCOLLECTION_SYMBOL OPEN_PAR_SYMBOL exprList? CLOSE_PAR_SYMBOL + | name = LINESTRING_SYMBOL exprListWithParentheses + | name = MULTILINESTRING_SYMBOL exprListWithParentheses + | name = MULTIPOINT_SYMBOL exprListWithParentheses + | name = MULTIPOLYGON_SYMBOL exprListWithParentheses + | name = POINT_SYMBOL OPEN_PAR_SYMBOL expr COMMA_SYMBOL expr CLOSE_PAR_SYMBOL + | name = POLYGON_SYMBOL exprListWithParentheses +; + +timeFunctionParameters: + OPEN_PAR_SYMBOL fractionalPrecision? CLOSE_PAR_SYMBOL +; + +fractionalPrecision: + {serverVersion >= 50604}? INT_NUMBER +; + +weightStringLevels: + LEVEL_SYMBOL ( + real_ulong_number MINUS_OPERATOR real_ulong_number + | weightStringLevelListItem (COMMA_SYMBOL weightStringLevelListItem)* + ) +; + +weightStringLevelListItem: + real_ulong_number ((ASC_SYMBOL | DESC_SYMBOL) REVERSE_SYMBOL? | REVERSE_SYMBOL)? +; + +dateTimeTtype: + DATE_SYMBOL + | TIME_SYMBOL + | DATETIME_SYMBOL + | TIMESTAMP_SYMBOL +; + +trimFunction: + TRIM_SYMBOL OPEN_PAR_SYMBOL ( + expr (FROM_SYMBOL expr)? + | LEADING_SYMBOL expr? FROM_SYMBOL expr + | TRAILING_SYMBOL expr? FROM_SYMBOL expr + | BOTH_SYMBOL expr? FROM_SYMBOL expr + ) CLOSE_PAR_SYMBOL +; + +substringFunction: + SUBSTRING_SYMBOL OPEN_PAR_SYMBOL expr ( + COMMA_SYMBOL expr (COMMA_SYMBOL expr)? + | FROM_SYMBOL expr (FOR_SYMBOL expr)? + ) CLOSE_PAR_SYMBOL +; + +functionCall: + pureIdentifier OPEN_PAR_SYMBOL udfExprList? CLOSE_PAR_SYMBOL // For both UDF + other functions. + | qualifiedIdentifier OPEN_PAR_SYMBOL exprList? CLOSE_PAR_SYMBOL // Other functions only. +; + +udfExprList: + udfExpr (COMMA_SYMBOL udfExpr)* +; + +udfExpr: + expr selectAlias? +; + +variable: + userVariable + | systemVariable +; + +userVariable: + AT_SIGN_SYMBOL textOrIdentifier + | AT_TEXT_SUFFIX +; + +systemVariable: + AT_AT_SIGN_SYMBOL varIdentType? textOrIdentifier dotIdentifier? +; + +internalVariableName: ( + // Check in semantic phase that the first id is not global/local/session/default. + {serverVersion < 80017}? identifier dotIdentifier? + | {serverVersion >= 80017}? lValueIdentifier dotIdentifier? + ) + | DEFAULT_SYMBOL dotIdentifier +; + +whenExpression: + WHEN_SYMBOL expr +; + +thenExpression: + THEN_SYMBOL expr +; + +elseExpression: + ELSE_SYMBOL expr +; + +castType: + BINARY_SYMBOL fieldLength? + | CHAR_SYMBOL fieldLength? charsetWithOptBinary? + | nchar fieldLength? + | SIGNED_SYMBOL INT_SYMBOL? + | UNSIGNED_SYMBOL INT_SYMBOL? + | DATE_SYMBOL + | TIME_SYMBOL typeDatetimePrecision? + | DATETIME_SYMBOL typeDatetimePrecision? + | DECIMAL_SYMBOL floatOptions? + | {serverVersion >= 50708}? JSON_SYMBOL + | {serverVersion >= 80017}? realType + | {serverVersion >= 80017}? FLOAT_SYMBOL standardFloatOptions? +; + +exprList: + expr (COMMA_SYMBOL expr)* +; + +charset: + CHAR_SYMBOL SET_SYMBOL + | CHARSET_SYMBOL +; + +notRule: + NOT_SYMBOL + | NOT2_SYMBOL // A NOT with a different (higher) operator precedence. +; + +not2Rule: + LOGICAL_NOT_OPERATOR + | NOT2_SYMBOL +; + +// None of the microsecond variants can be used in schedules (e.g. events). +interval: + intervalTimeStamp + | ( + SECOND_MICROSECOND_SYMBOL + | MINUTE_MICROSECOND_SYMBOL + | MINUTE_SECOND_SYMBOL + | HOUR_MICROSECOND_SYMBOL + | HOUR_SECOND_SYMBOL + | HOUR_MINUTE_SYMBOL + | DAY_MICROSECOND_SYMBOL + | DAY_SECOND_SYMBOL + | DAY_MINUTE_SYMBOL + | DAY_HOUR_SYMBOL + | YEAR_MONTH_SYMBOL + ) +; + +// Support for SQL_TSI_* units is added by mapping those to tokens without SQL_TSI_ prefix. +intervalTimeStamp: + MICROSECOND_SYMBOL + | SECOND_SYMBOL + | MINUTE_SYMBOL + | HOUR_SYMBOL + | DAY_SYMBOL + | WEEK_SYMBOL + | MONTH_SYMBOL + | QUARTER_SYMBOL + | YEAR_SYMBOL +; + +exprListWithParentheses: + OPEN_PAR_SYMBOL exprList CLOSE_PAR_SYMBOL +; + +exprWithParentheses: + OPEN_PAR_SYMBOL expr CLOSE_PAR_SYMBOL +; + +simpleExprWithParentheses: + OPEN_PAR_SYMBOL simpleExpr CLOSE_PAR_SYMBOL +; + +orderList: + orderExpression (COMMA_SYMBOL orderExpression)* +; + +orderExpression: + expr direction? +; + +groupList: + groupingExpression (COMMA_SYMBOL groupingExpression)* +; + +groupingExpression: + expr +; + +channel: + {serverVersion >= 50706}? FOR_SYMBOL CHANNEL_SYMBOL textStringNoLinebreak +; + +//----------------- Stored routines rules ------------------------------------------------------------------------------ + +// Compound syntax for stored procedures, stored functions, triggers and events. +// Implements both, sp_proc_stmt and ev_sql_stmt_inner from the server grammar. +compoundStatement: + simpleStatement + | returnStatement + | ifStatement + | caseStatement + | labeledBlock + | unlabeledBlock + | labeledControl + | unlabeledControl + | leaveStatement + | iterateStatement + | cursorOpen + | cursorFetch + | cursorClose +; + +returnStatement: + RETURN_SYMBOL expr +; + +ifStatement: + IF_SYMBOL ifBody END_SYMBOL IF_SYMBOL +; + +ifBody: + expr thenStatement (ELSEIF_SYMBOL ifBody | ELSE_SYMBOL compoundStatementList)? +; + +thenStatement: + THEN_SYMBOL compoundStatementList +; + +compoundStatementList: (compoundStatement SEMICOLON_SYMBOL)+ +; + +caseStatement: + CASE_SYMBOL expr? (whenExpression thenStatement)+ elseStatement? END_SYMBOL CASE_SYMBOL +; + +elseStatement: + ELSE_SYMBOL compoundStatementList +; + +labeledBlock: + label beginEndBlock labelRef? +; + +unlabeledBlock: + beginEndBlock +; + +label: + // Block labels can only be up to 16 characters long. + labelIdentifier COLON_SYMBOL +; + +beginEndBlock: + BEGIN_SYMBOL spDeclarations? compoundStatementList? END_SYMBOL +; + +labeledControl: + label unlabeledControl labelRef? +; + +unlabeledControl: + loopBlock + | whileDoBlock + | repeatUntilBlock +; + +loopBlock: + LOOP_SYMBOL compoundStatementList END_SYMBOL LOOP_SYMBOL +; + +whileDoBlock: + WHILE_SYMBOL expr DO_SYMBOL compoundStatementList END_SYMBOL WHILE_SYMBOL +; + +repeatUntilBlock: + REPEAT_SYMBOL compoundStatementList UNTIL_SYMBOL expr END_SYMBOL REPEAT_SYMBOL +; + +spDeclarations: (spDeclaration SEMICOLON_SYMBOL)+ +; + +spDeclaration: + variableDeclaration + | conditionDeclaration + | handlerDeclaration + | cursorDeclaration +; + +variableDeclaration: + DECLARE_SYMBOL identifierList dataType collate? (DEFAULT_SYMBOL expr)? +; + +conditionDeclaration: + DECLARE_SYMBOL identifier CONDITION_SYMBOL FOR_SYMBOL spCondition +; + +spCondition: + ulong_number + | sqlstate +; + +sqlstate: + SQLSTATE_SYMBOL VALUE_SYMBOL? textLiteral +; + +handlerDeclaration: + DECLARE_SYMBOL (CONTINUE_SYMBOL | EXIT_SYMBOL | UNDO_SYMBOL) HANDLER_SYMBOL FOR_SYMBOL handlerCondition ( + COMMA_SYMBOL handlerCondition + )* compoundStatement +; + +handlerCondition: + spCondition + | identifier + | SQLWARNING_SYMBOL + | notRule FOUND_SYMBOL + | SQLEXCEPTION_SYMBOL +; + +cursorDeclaration: + DECLARE_SYMBOL identifier CURSOR_SYMBOL FOR_SYMBOL selectStatement +; + +iterateStatement: + ITERATE_SYMBOL labelRef +; + +leaveStatement: + LEAVE_SYMBOL labelRef +; + +getDiagnostics: + GET_SYMBOL (CURRENT_SYMBOL | {serverVersion >= 50700}? STACKED_SYMBOL)? DIAGNOSTICS_SYMBOL ( + statementInformationItem (COMMA_SYMBOL statementInformationItem)* + | CONDITION_SYMBOL signalAllowedExpr conditionInformationItem ( + COMMA_SYMBOL conditionInformationItem + )* + ) +; + +// Only a limited subset of expr is allowed in SIGNAL/RESIGNAL/CONDITIONS. +signalAllowedExpr: + literal + | variable + | qualifiedIdentifier +; + +statementInformationItem: + (variable | identifier) EQUAL_OPERATOR (NUMBER_SYMBOL | ROW_COUNT_SYMBOL) +; + +conditionInformationItem: + (variable | identifier) EQUAL_OPERATOR ( + signalInformationItemName + | RETURNED_SQLSTATE_SYMBOL + ) +; + +signalInformationItemName: + CLASS_ORIGIN_SYMBOL + | SUBCLASS_ORIGIN_SYMBOL + | CONSTRAINT_CATALOG_SYMBOL + | CONSTRAINT_SCHEMA_SYMBOL + | CONSTRAINT_NAME_SYMBOL + | CATALOG_NAME_SYMBOL + | SCHEMA_NAME_SYMBOL + | TABLE_NAME_SYMBOL + | COLUMN_NAME_SYMBOL + | CURSOR_NAME_SYMBOL + | MESSAGE_TEXT_SYMBOL + | MYSQL_ERRNO_SYMBOL +; + +signalStatement: + SIGNAL_SYMBOL (identifier | sqlstate) ( + SET_SYMBOL signalInformationItem (COMMA_SYMBOL signalInformationItem)* + )? +; + +resignalStatement: + RESIGNAL_SYMBOL (identifier | sqlstate)? ( + SET_SYMBOL signalInformationItem (COMMA_SYMBOL signalInformationItem)* + )? +; + +signalInformationItem: + signalInformationItemName EQUAL_OPERATOR signalAllowedExpr +; + +cursorOpen: + OPEN_SYMBOL identifier +; + +cursorClose: + CLOSE_SYMBOL identifier +; + +cursorFetch: + FETCH_SYMBOL (NEXT_SYMBOL? FROM_SYMBOL)? identifier INTO_SYMBOL identifierList +; + +//----------------- Supplemental rules --------------------------------------------------------------------------------- + +// Schedules in CREATE/ALTER EVENT. +schedule: + AT_SYMBOL expr + | EVERY_SYMBOL expr interval (STARTS_SYMBOL expr)? (ENDS_SYMBOL expr)? +; + +columnDefinition: + columnName fieldDefinition checkOrReferences? +; + +checkOrReferences: + {serverVersion < 80016}? checkConstraint + | references +; + +checkConstraint: + CHECK_SYMBOL exprWithParentheses +; + +constraintEnforcement: + NOT_SYMBOL? ENFORCED_SYMBOL +; + +tableConstraintDef: + type = (KEY_SYMBOL | INDEX_SYMBOL) indexNameAndType? keyListVariants indexOption* + | type = FULLTEXT_SYMBOL keyOrIndex? indexName? keyListVariants fulltextIndexOption* + | type = SPATIAL_SYMBOL keyOrIndex? indexName? keyListVariants spatialIndexOption* + | constraintName? ( + (type = PRIMARY_SYMBOL KEY_SYMBOL | type = UNIQUE_SYMBOL keyOrIndex?) indexNameAndType? keyListVariants indexOption* + | type = FOREIGN_SYMBOL KEY_SYMBOL indexName? keyList references + | checkConstraint ({serverVersion >= 80017}? constraintEnforcement)? + ) +; + +constraintName: + CONSTRAINT_SYMBOL identifier? +; + +fieldDefinition: + dataType ( + columnAttribute* + | {serverVersion >= 50707}? collate? (GENERATED_SYMBOL ALWAYS_SYMBOL)? AS_SYMBOL exprWithParentheses ( + VIRTUAL_SYMBOL + | STORED_SYMBOL + )? ( + {serverVersion < 80000}? gcolAttribute* + | {serverVersion >= 80000}? columnAttribute* // Beginning with 8.0 the full attribute set is supported. + ) + ) +; + +columnAttribute: + NOT_SYMBOL? nullLiteral + | {serverVersion >= 80014}? NOT_SYMBOL SECONDARY_SYMBOL + | value = DEFAULT_SYMBOL ( + signedLiteral + | NOW_SYMBOL timeFunctionParameters? + | {serverVersion >= 80013}? exprWithParentheses + ) + | value = ON_SYMBOL UPDATE_SYMBOL NOW_SYMBOL timeFunctionParameters? + | value = AUTO_INCREMENT_SYMBOL + | value = SERIAL_SYMBOL DEFAULT_SYMBOL VALUE_SYMBOL + | PRIMARY_SYMBOL? value = KEY_SYMBOL + | value = UNIQUE_SYMBOL KEY_SYMBOL? + | value = COMMENT_SYMBOL textLiteral + | collate + | value = COLUMN_FORMAT_SYMBOL columnFormat + | value = STORAGE_SYMBOL storageMedia + | {serverVersion >= 80000}? value = SRID_SYMBOL real_ulonglong_number + | {serverVersion >= 80017}? constraintName? checkConstraint + | {serverVersion >= 80017}? constraintEnforcement +; + +columnFormat: + FIXED_SYMBOL + | DYNAMIC_SYMBOL + | DEFAULT_SYMBOL +; + +storageMedia: + DISK_SYMBOL + | MEMORY_SYMBOL + | DEFAULT_SYMBOL +; + +gcolAttribute: + UNIQUE_SYMBOL KEY_SYMBOL? + | COMMENT_SYMBOL textString + | notRule? NULL_SYMBOL + | PRIMARY_SYMBOL? KEY_SYMBOL +; + +references: + REFERENCES_SYMBOL tableRef identifierListWithParentheses? ( + MATCH_SYMBOL match = (FULL_SYMBOL | PARTIAL_SYMBOL | SIMPLE_SYMBOL) + )? ( + ON_SYMBOL option = UPDATE_SYMBOL deleteOption ( + ON_SYMBOL DELETE_SYMBOL deleteOption + )? + | ON_SYMBOL option = DELETE_SYMBOL deleteOption ( + ON_SYMBOL UPDATE_SYMBOL deleteOption + )? + )? +; + +deleteOption: + (RESTRICT_SYMBOL | CASCADE_SYMBOL) + | SET_SYMBOL nullLiteral + | NO_SYMBOL ACTION_SYMBOL +; + +keyList: + OPEN_PAR_SYMBOL keyPart (COMMA_SYMBOL keyPart)* CLOSE_PAR_SYMBOL +; + +keyPart: + identifier fieldLength? direction? +; + +keyListWithExpression: + OPEN_PAR_SYMBOL keyPartOrExpression (COMMA_SYMBOL keyPartOrExpression)* CLOSE_PAR_SYMBOL +; + +keyPartOrExpression: // key_part_with_expression in sql_yacc.yy. + keyPart + | exprWithParentheses direction? +; + +keyListVariants: + {serverVersion >= 80013}? keyListWithExpression + | {serverVersion < 80013}? keyList +; + +indexType: + algorithm = (BTREE_SYMBOL | RTREE_SYMBOL | HASH_SYMBOL) +; + +indexOption: + commonIndexOption + | indexTypeClause +; + +// These options are common for all index types. +commonIndexOption: + KEY_BLOCK_SIZE_SYMBOL EQUAL_OPERATOR? ulong_number + | COMMENT_SYMBOL textLiteral + | {serverVersion >= 80000}? visibility +; + +visibility: + VISIBLE_SYMBOL + | INVISIBLE_SYMBOL +; + +indexTypeClause: + (USING_SYMBOL | TYPE_SYMBOL) indexType +; + +fulltextIndexOption: + commonIndexOption + | WITH_SYMBOL PARSER_SYMBOL identifier +; + +spatialIndexOption: + commonIndexOption +; + +dataTypeDefinition: // For external use only. Don't reference this in the normal grammar. + dataType EOF +; + +dataType: // type in sql_yacc.yy + type = ( + INT_SYMBOL + | TINYINT_SYMBOL + | SMALLINT_SYMBOL + | MEDIUMINT_SYMBOL + | BIGINT_SYMBOL + ) fieldLength? fieldOptions? + | (type = REAL_SYMBOL | type = DOUBLE_SYMBOL PRECISION_SYMBOL?) precision? fieldOptions? + | type = (FLOAT_SYMBOL | DECIMAL_SYMBOL | NUMERIC_SYMBOL | FIXED_SYMBOL) floatOptions? fieldOptions? + | type = BIT_SYMBOL fieldLength? + | type = (BOOL_SYMBOL | BOOLEAN_SYMBOL) + | type = CHAR_SYMBOL fieldLength? charsetWithOptBinary? + | nchar fieldLength? BINARY_SYMBOL? + | type = BINARY_SYMBOL fieldLength? + | (type = CHAR_SYMBOL VARYING_SYMBOL | type = VARCHAR_SYMBOL) fieldLength charsetWithOptBinary? + | ( + type = NATIONAL_SYMBOL VARCHAR_SYMBOL + | type = NVARCHAR_SYMBOL + | type = NCHAR_SYMBOL VARCHAR_SYMBOL + | type = NATIONAL_SYMBOL CHAR_SYMBOL VARYING_SYMBOL + | type = NCHAR_SYMBOL VARYING_SYMBOL + ) fieldLength BINARY_SYMBOL? + | type = VARBINARY_SYMBOL fieldLength + | type = YEAR_SYMBOL fieldLength? fieldOptions? + | type = DATE_SYMBOL + | type = TIME_SYMBOL typeDatetimePrecision? + | type = TIMESTAMP_SYMBOL typeDatetimePrecision? + | type = DATETIME_SYMBOL typeDatetimePrecision? + | type = TINYBLOB_SYMBOL + | type = BLOB_SYMBOL fieldLength? + | type = (MEDIUMBLOB_SYMBOL | LONGBLOB_SYMBOL) + | type = LONG_SYMBOL VARBINARY_SYMBOL + | type = LONG_SYMBOL (CHAR_SYMBOL VARYING_SYMBOL | VARCHAR_SYMBOL)? charsetWithOptBinary? + | type = TINYTEXT_SYMBOL charsetWithOptBinary? + | type = TEXT_SYMBOL fieldLength? charsetWithOptBinary? + | type = MEDIUMTEXT_SYMBOL charsetWithOptBinary? + | type = LONGTEXT_SYMBOL charsetWithOptBinary? + | type = ENUM_SYMBOL stringList charsetWithOptBinary? + | type = SET_SYMBOL stringList charsetWithOptBinary? + | type = SERIAL_SYMBOL + | {serverVersion >= 50708}? type = JSON_SYMBOL + | type = ( + GEOMETRY_SYMBOL + | GEOMETRYCOLLECTION_SYMBOL + | POINT_SYMBOL + | MULTIPOINT_SYMBOL + | LINESTRING_SYMBOL + | MULTILINESTRING_SYMBOL + | POLYGON_SYMBOL + | MULTIPOLYGON_SYMBOL + ) +; + +nchar: + type = NCHAR_SYMBOL + | type = NATIONAL_SYMBOL CHAR_SYMBOL +; + +realType: + type = REAL_SYMBOL + | type = DOUBLE_SYMBOL PRECISION_SYMBOL? +; + +fieldLength: + OPEN_PAR_SYMBOL (real_ulonglong_number | DECIMAL_NUMBER) CLOSE_PAR_SYMBOL +; + +fieldOptions: (SIGNED_SYMBOL | UNSIGNED_SYMBOL | ZEROFILL_SYMBOL)+ +; + +charsetWithOptBinary: + ascii + | unicode + | BYTE_SYMBOL + | charset charsetName BINARY_SYMBOL? + | BINARY_SYMBOL (charset charsetName)? +; + +ascii: + ASCII_SYMBOL BINARY_SYMBOL? + | BINARY_SYMBOL ASCII_SYMBOL +; + +unicode: + UNICODE_SYMBOL BINARY_SYMBOL? + | BINARY_SYMBOL UNICODE_SYMBOL +; + +wsNumCodepoints: + OPEN_PAR_SYMBOL real_ulong_number CLOSE_PAR_SYMBOL +; + +typeDatetimePrecision: + OPEN_PAR_SYMBOL INT_NUMBER CLOSE_PAR_SYMBOL +; + +charsetName: + textOrIdentifier + | BINARY_SYMBOL + | {serverVersion < 80011}? DEFAULT_SYMBOL +; + +collationName: + textOrIdentifier + | {serverVersion < 80011}? DEFAULT_SYMBOL + | {serverVersion >= 80018}? BINARY_SYMBOL +; + +createTableOptions: + createTableOption (COMMA_SYMBOL? createTableOption)* +; + +createTableOptionsSpaceSeparated: + createTableOption+ +; + +createTableOption: // In the order as they appear in the server grammar. + option = ENGINE_SYMBOL EQUAL_OPERATOR? engineRef + | {serverVersion >= 80014}? option = SECONDARY_ENGINE_SYMBOL equal? ( + NULL_SYMBOL + | textOrIdentifier + ) + | option = MAX_ROWS_SYMBOL EQUAL_OPERATOR? ulonglong_number + | option = MIN_ROWS_SYMBOL EQUAL_OPERATOR? ulonglong_number + | option = AVG_ROW_LENGTH_SYMBOL EQUAL_OPERATOR? ulong_number + | option = PASSWORD_SYMBOL EQUAL_OPERATOR? textStringLiteral + | option = COMMENT_SYMBOL EQUAL_OPERATOR? textStringLiteral + | {serverVersion >= 50708}? option = COMPRESSION_SYMBOL EQUAL_OPERATOR? textString + | {serverVersion >= 50711}? option = ENCRYPTION_SYMBOL EQUAL_OPERATOR? textString + | option = AUTO_INCREMENT_SYMBOL EQUAL_OPERATOR? ulonglong_number + | option = PACK_KEYS_SYMBOL EQUAL_OPERATOR? ternaryOption + | option = ( + STATS_AUTO_RECALC_SYMBOL + | STATS_PERSISTENT_SYMBOL + | STATS_SAMPLE_PAGES_SYMBOL + ) EQUAL_OPERATOR? ternaryOption + | option = (CHECKSUM_SYMBOL | TABLE_CHECKSUM_SYMBOL) EQUAL_OPERATOR? ulong_number + | option = DELAY_KEY_WRITE_SYMBOL EQUAL_OPERATOR? ulong_number + | option = ROW_FORMAT_SYMBOL EQUAL_OPERATOR? format = ( + DEFAULT_SYMBOL + | DYNAMIC_SYMBOL + | FIXED_SYMBOL + | COMPRESSED_SYMBOL + | REDUNDANT_SYMBOL + | COMPACT_SYMBOL + ) + | option = UNION_SYMBOL EQUAL_OPERATOR? OPEN_PAR_SYMBOL tableRefList CLOSE_PAR_SYMBOL + | defaultCharset + | defaultCollation + | option = INSERT_METHOD_SYMBOL EQUAL_OPERATOR? method = ( + NO_SYMBOL + | FIRST_SYMBOL + | LAST_SYMBOL + ) + | option = DATA_SYMBOL DIRECTORY_SYMBOL EQUAL_OPERATOR? textString + | option = INDEX_SYMBOL DIRECTORY_SYMBOL EQUAL_OPERATOR? textString + | option = TABLESPACE_SYMBOL ( + {serverVersion >= 50707}? EQUAL_OPERATOR? + | /* empty */ + ) identifier + | option = STORAGE_SYMBOL (DISK_SYMBOL | MEMORY_SYMBOL) + | option = CONNECTION_SYMBOL EQUAL_OPERATOR? textString + | option = KEY_BLOCK_SIZE_SYMBOL EQUAL_OPERATOR? ulong_number +; + +ternaryOption: + ulong_number + | DEFAULT_SYMBOL +; + +defaultCollation: + DEFAULT_SYMBOL? COLLATE_SYMBOL EQUAL_OPERATOR? collationName +; + +defaultEncryption: + DEFAULT_SYMBOL? ENCRYPTION_SYMBOL EQUAL_OPERATOR? textStringLiteral +; + +defaultCharset: + DEFAULT_SYMBOL? charset EQUAL_OPERATOR? charsetName +; + +// Partition rules for CREATE/ALTER TABLE. +partitionClause: + PARTITION_SYMBOL BY_SYMBOL partitionTypeDef (PARTITIONS_SYMBOL real_ulong_number)? subPartitions? partitionDefinitions? +; + +partitionTypeDef: + LINEAR_SYMBOL? KEY_SYMBOL partitionKeyAlgorithm? OPEN_PAR_SYMBOL identifierList? CLOSE_PAR_SYMBOL # partitionDefKey + | LINEAR_SYMBOL? HASH_SYMBOL OPEN_PAR_SYMBOL bitExpr CLOSE_PAR_SYMBOL # partitionDefHash + | (RANGE_SYMBOL | LIST_SYMBOL) ( + OPEN_PAR_SYMBOL bitExpr CLOSE_PAR_SYMBOL + | COLUMNS_SYMBOL OPEN_PAR_SYMBOL identifierList? CLOSE_PAR_SYMBOL + ) # partitionDefRangeList +; + +subPartitions: + SUBPARTITION_SYMBOL BY_SYMBOL LINEAR_SYMBOL? ( + HASH_SYMBOL OPEN_PAR_SYMBOL bitExpr CLOSE_PAR_SYMBOL + | KEY_SYMBOL partitionKeyAlgorithm? identifierListWithParentheses + ) (SUBPARTITIONS_SYMBOL real_ulong_number)? +; + +partitionKeyAlgorithm: // Actually only 1 and 2 are allowed. Needs a semantic check. + {serverVersion >= 50700}? ALGORITHM_SYMBOL EQUAL_OPERATOR real_ulong_number +; + +partitionDefinitions: + OPEN_PAR_SYMBOL partitionDefinition (COMMA_SYMBOL partitionDefinition)* CLOSE_PAR_SYMBOL +; + +partitionDefinition: + PARTITION_SYMBOL identifier ( + VALUES_SYMBOL LESS_SYMBOL THAN_SYMBOL ( + partitionValueItemListParen + | MAXVALUE_SYMBOL + ) + | VALUES_SYMBOL IN_SYMBOL partitionValuesIn + )? partitionOption* ( + OPEN_PAR_SYMBOL subpartitionDefinition (COMMA_SYMBOL subpartitionDefinition)* CLOSE_PAR_SYMBOL + )? +; + +partitionValuesIn: + partitionValueItemListParen + | OPEN_PAR_SYMBOL partitionValueItemListParen ( + COMMA_SYMBOL partitionValueItemListParen + )* CLOSE_PAR_SYMBOL +; + +partitionOption: + option = TABLESPACE_SYMBOL EQUAL_OPERATOR? identifier + | STORAGE_SYMBOL? option = ENGINE_SYMBOL EQUAL_OPERATOR? engineRef + | option = NODEGROUP_SYMBOL EQUAL_OPERATOR? real_ulong_number + | option = (MAX_ROWS_SYMBOL | MIN_ROWS_SYMBOL) EQUAL_OPERATOR? real_ulong_number + | option = (DATA_SYMBOL | INDEX_SYMBOL) DIRECTORY_SYMBOL EQUAL_OPERATOR? textLiteral + | option = COMMENT_SYMBOL EQUAL_OPERATOR? textLiteral +; + +subpartitionDefinition: + SUBPARTITION_SYMBOL textOrIdentifier partitionOption* +; + +partitionValueItemListParen: + OPEN_PAR_SYMBOL partitionValueItem (COMMA_SYMBOL partitionValueItem)* CLOSE_PAR_SYMBOL +; + +partitionValueItem: + bitExpr + | MAXVALUE_SYMBOL +; + +definerClause: + DEFINER_SYMBOL EQUAL_OPERATOR user +; + +ifExists: + IF_SYMBOL EXISTS_SYMBOL +; + +ifNotExists: + IF_SYMBOL notRule EXISTS_SYMBOL +; + +procedureParameter: + type = (IN_SYMBOL | OUT_SYMBOL | INOUT_SYMBOL)? functionParameter +; + +functionParameter: + parameterName typeWithOptCollate +; + +collate: + COLLATE_SYMBOL collationName +; + +typeWithOptCollate: + dataType collate? +; + +schemaIdentifierPair: + OPEN_PAR_SYMBOL schemaRef COMMA_SYMBOL schemaRef CLOSE_PAR_SYMBOL +; + +viewRefList: + viewRef (COMMA_SYMBOL viewRef)* +; + +updateList: + updateElement (COMMA_SYMBOL updateElement)* +; + +updateElement: + columnRef EQUAL_OPERATOR (expr | DEFAULT_SYMBOL) +; + +charsetClause: + charset charsetName +; + +fieldsClause: + COLUMNS_SYMBOL fieldTerm+ +; + +fieldTerm: + TERMINATED_SYMBOL BY_SYMBOL textString + | OPTIONALLY_SYMBOL? ENCLOSED_SYMBOL BY_SYMBOL textString + | ESCAPED_SYMBOL BY_SYMBOL textString +; + +linesClause: + LINES_SYMBOL lineTerm+ +; + +lineTerm: (TERMINATED_SYMBOL | STARTING_SYMBOL) BY_SYMBOL textString +; + +userList: + user (COMMA_SYMBOL user)* +; + +createUserList: + createUserEntry (COMMA_SYMBOL createUserEntry)* +; + +alterUserList: + alterUserEntry (COMMA_SYMBOL alterUserEntry)* +; + +createUserEntry: // create_user in sql_yacc.yy + user ( + IDENTIFIED_SYMBOL ( + BY_SYMBOL ({serverVersion < 80011}? PASSWORD_SYMBOL)? textString + | WITH_SYMBOL textOrIdentifier ( + AS_SYMBOL textStringHash + | {serverVersion >= 50706}? BY_SYMBOL textString + )? + | {serverVersion >= 80018}? (WITH_SYMBOL textOrIdentifier)? BY_SYMBOL RANDOM_SYMBOL PASSWORD_SYMBOL + ) + )? +; + +alterUserEntry: // alter_user in sql_yacc.yy + user ( + IDENTIFIED_SYMBOL ( + (WITH_SYMBOL textOrIdentifier)? BY_SYMBOL textString ( + REPLACE_SYMBOL textString + )? retainCurrentPassword? + | WITH_SYMBOL textOrIdentifier ( + AS_SYMBOL textStringHash retainCurrentPassword? + )? + )? + | discardOldPassword? + ) +; + +retainCurrentPassword: + RETAIN_SYMBOL CURRENT_SYMBOL PASSWORD_SYMBOL +; + +discardOldPassword: + DISCARD_SYMBOL OLD_SYMBOL PASSWORD_SYMBOL +; + +replacePassword: + REPLACE_SYMBOL textString +; + +userIdentifierOrText: + textOrIdentifier (AT_SIGN_SYMBOL textOrIdentifier | AT_TEXT_SUFFIX)? +; + +user: + userIdentifierOrText + | CURRENT_USER_SYMBOL parentheses? +; + +likeClause: + LIKE_SYMBOL textStringLiteral +; + +likeOrWhere: // opt_wild_or_where in sql_yacc.yy + likeClause + | whereClause +; + +onlineOption: + ONLINE_SYMBOL + | OFFLINE_SYMBOL +; + +noWriteToBinLog: + LOCAL_SYMBOL + | NO_WRITE_TO_BINLOG_SYMBOL +; + +usePartition: + {serverVersion >= 50602}? PARTITION_SYMBOL identifierListWithParentheses +; + +//----------------- Object names and references ------------------------------------------------------------------------ + +// For each object we have at least 2 rules here: +// 1) The name when creating that object. +// 2) The name when used to reference it from other rules. +// +// Sometimes we need additional reference rules with different form, depending on the place such a reference is used. + +// A name for a field (column/index). Can be qualified with the current schema + table (although it's not a reference). +fieldIdentifier: + dotIdentifier + | qualifiedIdentifier dotIdentifier? +; + +columnName: + // With server 8.0 this became a simple identifier. + {serverVersion >= 80000}? identifier + | {serverVersion < 80000}? fieldIdentifier +; + +// A reference to a column of the object we are working on. +columnInternalRef: + identifier +; + +columnInternalRefList: // column_list (+ parentheses) + opt_derived_column_list in sql_yacc.yy + OPEN_PAR_SYMBOL columnInternalRef (COMMA_SYMBOL columnInternalRef)* CLOSE_PAR_SYMBOL +; + +columnRef: // A field identifier that can reference any schema/table. + fieldIdentifier +; + +insertIdentifier: + columnRef + | tableWild +; + +indexName: + identifier +; + +indexRef: // Always internal reference. Still all qualification variations are accepted. + fieldIdentifier +; + +tableWild: + identifier DOT_SYMBOL (identifier DOT_SYMBOL)? MULT_OPERATOR +; + +schemaName: + identifier +; + +schemaRef: + identifier +; + +procedureName: + qualifiedIdentifier +; + +procedureRef: + qualifiedIdentifier +; + +functionName: + qualifiedIdentifier +; + +functionRef: + qualifiedIdentifier +; + +triggerName: + qualifiedIdentifier +; + +triggerRef: + qualifiedIdentifier +; + +viewName: + qualifiedIdentifier + | dotIdentifier +; + +viewRef: + qualifiedIdentifier + | dotIdentifier +; + +tablespaceName: + identifier +; + +tablespaceRef: + identifier +; + +logfileGroupName: + identifier +; + +logfileGroupRef: + identifier +; + +eventName: + qualifiedIdentifier +; + +eventRef: + qualifiedIdentifier +; + +udfName: // UDFs are referenced at the same places as any other function. So, no dedicated *_ref here. + identifier +; + +serverName: + textOrIdentifier +; + +serverRef: + textOrIdentifier +; + +engineRef: + textOrIdentifier +; + +tableName: + qualifiedIdentifier + | dotIdentifier +; + +filterTableRef: // Always qualified. + schemaRef dotIdentifier +; + +tableRefWithWildcard: + identifier (DOT_SYMBOL MULT_OPERATOR | dotIdentifier (DOT_SYMBOL MULT_OPERATOR)?)? +; + +tableRef: + qualifiedIdentifier + | dotIdentifier +; + +tableRefList: + tableRef (COMMA_SYMBOL tableRef)* +; + +tableAliasRefList: + tableRefWithWildcard (COMMA_SYMBOL tableRefWithWildcard)* +; + +parameterName: + identifier +; + +labelIdentifier: + pureIdentifier + | labelKeyword +; + +labelRef: + labelIdentifier +; + +roleIdentifier: + pureIdentifier + | roleKeyword +; + +roleRef: + roleIdentifier +; + +pluginRef: + identifier +; + +componentRef: + textStringLiteral +; + +resourceGroupRef: + identifier +; + +windowName: + identifier +; + +//----------------- Common basic rules --------------------------------------------------------------------------------- + +// Identifiers excluding keywords (except if they are quoted). IDENT_sys in sql_yacc.yy. +pureIdentifier: + (IDENTIFIER | BACK_TICK_QUOTED_ID) + | {isSqlModeActive(AnsiQuotes)}? DOUBLE_QUOTED_TEXT +; + +// Identifiers including a certain set of keywords, which are allowed also if not quoted. +// ident in sql_yacc.yy +identifier: + pureIdentifier + | identifierKeyword +; + +identifierList: // ident_string_list in sql_yacc.yy. + identifier (COMMA_SYMBOL identifier)* +; + +identifierListWithParentheses: + OPEN_PAR_SYMBOL identifierList CLOSE_PAR_SYMBOL +; + +qualifiedIdentifier: + identifier dotIdentifier? +; + +simpleIdentifier: // simple_ident + simple_ident_q + identifier (dotIdentifier dotIdentifier?)? + | {serverVersion < 80000}? dotIdentifier dotIdentifier +; + +// This rule encapsulates the frequently used dot + identifier sequence, which also requires a special +// treatment in the lexer. See there in the DOT_IDENTIFIER rule. +dotIdentifier: + DOT_SYMBOL identifier +; + +ulong_number: + INT_NUMBER + | HEX_NUMBER + | LONG_NUMBER + | ULONGLONG_NUMBER + | DECIMAL_NUMBER + | FLOAT_NUMBER +; + +real_ulong_number: + INT_NUMBER + | HEX_NUMBER + | LONG_NUMBER + | ULONGLONG_NUMBER +; + +ulonglong_number: + INT_NUMBER + | LONG_NUMBER + | ULONGLONG_NUMBER + | DECIMAL_NUMBER + | FLOAT_NUMBER +; + +real_ulonglong_number: + INT_NUMBER + | {serverVersion >= 80017}? HEX_NUMBER + | ULONGLONG_NUMBER + | LONG_NUMBER +; + +literal: + textLiteral + | numLiteral + | temporalLiteral + | nullLiteral + | boolLiteral + | UNDERSCORE_CHARSET? (HEX_NUMBER | BIN_NUMBER) +; + +signedLiteral: + literal + | PLUS_OPERATOR ulong_number + | MINUS_OPERATOR ulong_number +; + +stringList: + OPEN_PAR_SYMBOL textString (COMMA_SYMBOL textString)* CLOSE_PAR_SYMBOL +; + +// TEXT_STRING_sys + TEXT_STRING_literal + TEXT_STRING_filesystem + TEXT_STRING + TEXT_STRING_password + +// TEXT_STRING_validated in sql_yacc.yy. +textStringLiteral: + value = SINGLE_QUOTED_TEXT + | {!isSqlModeActive(AnsiQuotes)}? value = DOUBLE_QUOTED_TEXT +; + +textString: + textStringLiteral + | HEX_NUMBER + | BIN_NUMBER +; + +textStringHash: + textStringLiteral + | {serverVersion >= 80017}? HEX_NUMBER +; + +textLiteral: + (UNDERSCORE_CHARSET? textStringLiteral | NCHAR_TEXT) textStringLiteral* +; + +// A special variant of a text string that must not contain a linebreak (TEXT_STRING_sys_nonewline in sql_yacc.yy). +// Check validity in semantic phase. +textStringNoLinebreak: + textStringLiteral +; + +textStringLiteralList: + textStringLiteral (COMMA_SYMBOL textStringLiteral)* +; + +numLiteral: + INT_NUMBER + | LONG_NUMBER + | ULONGLONG_NUMBER + | DECIMAL_NUMBER + | FLOAT_NUMBER +; + +boolLiteral: + TRUE_SYMBOL + | FALSE_SYMBOL +; + +nullLiteral: // In sql_yacc.cc both 'NULL' and '\N' are mapped to NULL_SYM (which is our nullLiteral). + NULL_SYMBOL + | NULL2_SYMBOL +; + +temporalLiteral: + DATE_SYMBOL SINGLE_QUOTED_TEXT + | TIME_SYMBOL SINGLE_QUOTED_TEXT + | TIMESTAMP_SYMBOL SINGLE_QUOTED_TEXT +; + +floatOptions: + fieldLength + | precision +; + +standardFloatOptions: + precision +; + +precision: + OPEN_PAR_SYMBOL INT_NUMBER COMMA_SYMBOL INT_NUMBER CLOSE_PAR_SYMBOL +; + +textOrIdentifier: + identifier + | textStringLiteral +; + +lValueIdentifier: + pureIdentifier + | lValueKeyword +; + +roleIdentifierOrText: + roleIdentifier + | textStringLiteral +; + +sizeNumber: + real_ulonglong_number + | pureIdentifier // Something like 10G. Semantic check needed for validity. +; + +parentheses: + OPEN_PAR_SYMBOL CLOSE_PAR_SYMBOL +; + +equal: + EQUAL_OPERATOR + | ASSIGN_OPERATOR +; + +// PERSIST and PERSIST_ONLY are conditionally handled in the lexer. Hence no predicate required here. +optionType: + PERSIST_SYMBOL + | PERSIST_ONLY_SYMBOL + | GLOBAL_SYMBOL + | LOCAL_SYMBOL + | SESSION_SYMBOL +; + +varIdentType: + GLOBAL_SYMBOL DOT_SYMBOL + | LOCAL_SYMBOL DOT_SYMBOL + | SESSION_SYMBOL DOT_SYMBOL +; + +setVarIdentType: + PERSIST_SYMBOL DOT_SYMBOL + | PERSIST_ONLY_SYMBOL DOT_SYMBOL + | GLOBAL_SYMBOL DOT_SYMBOL + | LOCAL_SYMBOL DOT_SYMBOL + | SESSION_SYMBOL DOT_SYMBOL +; + +// Note: rules for non-reserved keywords have changed significantly with MySQL 8.0.17, which make their +// version dependent handling complicated. +// Comments for keyword rules are taken over directly from the server grammar, but usually don't apply here +// since we don't have something like shift/reduce conflicts in ANTLR4 (which those ugly rules try to overcome). + +// Non-reserved keywords are allowed as unquoted identifiers in general. +// +// OTOH, in a few particular cases statement-specific rules are used +// instead of `ident_keyword` to avoid grammar ambiguities: +// +// * `label_keyword` for SP label names +// * `role_keyword` for role names +// * `lvalue_keyword` for variable prefixes and names in left sides of +// assignments in SET statements +// +// Normally, new non-reserved words should be added to the +// the rule `ident_keywords_unambiguous`. If they cause grammar conflicts, try +// one of `ident_keywords_ambiguous_...` rules instead. +identifierKeyword: + {serverVersion < 80017}? ( + labelKeyword + | roleOrIdentifierKeyword + | EXECUTE_SYMBOL + | {serverVersion >= 50709}? SHUTDOWN_SYMBOL // Previously allowed as SP label as well. + | {serverVersion >= 80011}? RESTART_SYMBOL + ) + | ( + identifierKeywordsUnambiguous + | identifierKeywordsAmbiguous1RolesAndLabels + | identifierKeywordsAmbiguous2Labels + | identifierKeywordsAmbiguous3Roles + | identifierKeywordsAmbiguous4SystemVariables + ) +; + +// These non-reserved words cannot be used as role names and SP label names: +identifierKeywordsAmbiguous1RolesAndLabels: + EXECUTE_SYMBOL + | RESTART_SYMBOL + | SHUTDOWN_SYMBOL +; + +// These non-reserved keywords cannot be used as unquoted SP label names: +identifierKeywordsAmbiguous2Labels: + ASCII_SYMBOL + | BEGIN_SYMBOL + | BYTE_SYMBOL + | CACHE_SYMBOL + | CHARSET_SYMBOL + | CHECKSUM_SYMBOL + | CLONE_SYMBOL + | COMMENT_SYMBOL + | COMMIT_SYMBOL + | CONTAINS_SYMBOL + | DEALLOCATE_SYMBOL + | DO_SYMBOL + | END_SYMBOL + | FLUSH_SYMBOL + | FOLLOWS_SYMBOL + | HANDLER_SYMBOL + | HELP_SYMBOL + | IMPORT_SYMBOL + | INSTALL_SYMBOL + | LANGUAGE_SYMBOL + | NO_SYMBOL + | PRECEDES_SYMBOL + | PREPARE_SYMBOL + | REPAIR_SYMBOL + | RESET_SYMBOL + | ROLLBACK_SYMBOL + | SAVEPOINT_SYMBOL + | SIGNED_SYMBOL + | SLAVE_SYMBOL + | START_SYMBOL + | STOP_SYMBOL + | TRUNCATE_SYMBOL + | UNICODE_SYMBOL + | UNINSTALL_SYMBOL + | XA_SYMBOL +; + +// Keywords that we allow for labels in SPs in the unquoted form. +// Any keyword that is allowed to begin a statement or routine characteristics +// must be in `ident_keywords_ambiguous_2_labels` above, otherwise +// we get (harmful) shift/reduce conflicts. +// +// Not allowed: +// +// ident_keywords_ambiguous_1_roles_and_labels +// ident_keywords_ambiguous_2_labels +labelKeyword: + {serverVersion < 80017}? ( + roleOrLabelKeyword + | EVENT_SYMBOL + | FILE_SYMBOL + | NONE_SYMBOL + | PROCESS_SYMBOL + | PROXY_SYMBOL + | RELOAD_SYMBOL + | REPLICATION_SYMBOL + | RESOURCE_SYMBOL // Conditionally set in the lexer. + | SUPER_SYMBOL + ) + | ( + identifierKeywordsUnambiguous + | identifierKeywordsAmbiguous3Roles + | identifierKeywordsAmbiguous4SystemVariables + ) +; + +// These non-reserved keywords cannot be used as unquoted role names: +identifierKeywordsAmbiguous3Roles: + EVENT_SYMBOL + | FILE_SYMBOL + | NONE_SYMBOL + | PROCESS_SYMBOL + | PROXY_SYMBOL + | RELOAD_SYMBOL + | REPLICATION_SYMBOL + | RESOURCE_SYMBOL + | SUPER_SYMBOL +; + +// These are the non-reserved keywords which may be used for unquoted +// identifiers everywhere without introducing grammar conflicts: +identifierKeywordsUnambiguous: + ( + ACTION_SYMBOL + | ACCOUNT_SYMBOL + | ACTIVE_SYMBOL + | ADDDATE_SYMBOL + | ADMIN_SYMBOL + | AFTER_SYMBOL + | AGAINST_SYMBOL + | AGGREGATE_SYMBOL + | ALGORITHM_SYMBOL + | ALWAYS_SYMBOL + | ANY_SYMBOL + | AT_SYMBOL + | AUTOEXTEND_SIZE_SYMBOL + | AUTO_INCREMENT_SYMBOL + | AVG_ROW_LENGTH_SYMBOL + | AVG_SYMBOL + | BACKUP_SYMBOL + | BINLOG_SYMBOL + | BIT_SYMBOL + | BLOCK_SYMBOL + | BOOLEAN_SYMBOL + | BOOL_SYMBOL + | BTREE_SYMBOL + | BUCKETS_SYMBOL + | CASCADED_SYMBOL + | CATALOG_NAME_SYMBOL + | CHAIN_SYMBOL + | CHANGED_SYMBOL + | CHANNEL_SYMBOL + | CIPHER_SYMBOL + | CLASS_ORIGIN_SYMBOL + | CLIENT_SYMBOL + | CLOSE_SYMBOL + | COALESCE_SYMBOL + | CODE_SYMBOL + | COLLATION_SYMBOL + | COLUMNS_SYMBOL + | COLUMN_FORMAT_SYMBOL + | COLUMN_NAME_SYMBOL + | COMMITTED_SYMBOL + | COMPACT_SYMBOL + | COMPLETION_SYMBOL + | COMPONENT_SYMBOL + | COMPRESSED_SYMBOL + | COMPRESSION_SYMBOL + | CONCURRENT_SYMBOL + | CONNECTION_SYMBOL + | CONSISTENT_SYMBOL + | CONSTRAINT_CATALOG_SYMBOL + | CONSTRAINT_NAME_SYMBOL + | CONSTRAINT_SCHEMA_SYMBOL + | CONTEXT_SYMBOL + | CPU_SYMBOL + | CURRENT_SYMBOL // not reserved in MySQL per WL#2111 specification + | CURSOR_NAME_SYMBOL + | DATAFILE_SYMBOL + | DATA_SYMBOL + | DATETIME_SYMBOL + | DATE_SYMBOL + | DAY_SYMBOL + | DEFAULT_AUTH_SYMBOL + | DEFINER_SYMBOL + | DEFINITION_SYMBOL + | DELAY_KEY_WRITE_SYMBOL + | DESCRIPTION_SYMBOL + | DIAGNOSTICS_SYMBOL + | DIRECTORY_SYMBOL + | DISABLE_SYMBOL + | DISCARD_SYMBOL + | DISK_SYMBOL + | DUMPFILE_SYMBOL + | DUPLICATE_SYMBOL + | DYNAMIC_SYMBOL + | ENABLE_SYMBOL + | ENCRYPTION_SYMBOL + | ENDS_SYMBOL + | ENFORCED_SYMBOL + | ENGINES_SYMBOL + | ENGINE_SYMBOL + | ENUM_SYMBOL + | ERRORS_SYMBOL + | ERROR_SYMBOL + | ESCAPE_SYMBOL + | EVENTS_SYMBOL + | EVERY_SYMBOL + | EXCHANGE_SYMBOL + | EXCLUDE_SYMBOL + | EXPANSION_SYMBOL + | EXPIRE_SYMBOL + | EXPORT_SYMBOL + | EXTENDED_SYMBOL + | EXTENT_SIZE_SYMBOL + | FAST_SYMBOL + | FAULTS_SYMBOL + | FILE_BLOCK_SIZE_SYMBOL + | FILTER_SYMBOL + | FIRST_SYMBOL + | FIXED_SYMBOL + | FOLLOWING_SYMBOL + | FORMAT_SYMBOL + | FOUND_SYMBOL + | FULL_SYMBOL + | GENERAL_SYMBOL + | GEOMETRYCOLLECTION_SYMBOL + | GEOMETRY_SYMBOL + | GET_FORMAT_SYMBOL + | GET_MASTER_PUBLIC_KEY_SYMBOL + | GRANTS_SYMBOL + | GROUP_REPLICATION_SYMBOL + | HASH_SYMBOL + | HISTOGRAM_SYMBOL + | HISTORY_SYMBOL + | HOSTS_SYMBOL + | HOST_SYMBOL + | HOUR_SYMBOL + | IDENTIFIED_SYMBOL + | IGNORE_SERVER_IDS_SYMBOL + | INACTIVE_SYMBOL + | INDEXES_SYMBOL + | INITIAL_SIZE_SYMBOL + | INSERT_METHOD_SYMBOL + | INSTANCE_SYMBOL + | INVISIBLE_SYMBOL + | INVOKER_SYMBOL + | IO_SYMBOL + | IPC_SYMBOL + | ISOLATION_SYMBOL + | ISSUER_SYMBOL + | JSON_SYMBOL + | KEY_BLOCK_SIZE_SYMBOL + | LAST_SYMBOL + | LEAVES_SYMBOL + | LESS_SYMBOL + | LEVEL_SYMBOL + | LINESTRING_SYMBOL + | LIST_SYMBOL + | LOCKED_SYMBOL + | LOCKS_SYMBOL + | LOGFILE_SYMBOL + | LOGS_SYMBOL + | MASTER_AUTO_POSITION_SYMBOL + | MASTER_COMPRESSION_ALGORITHM_SYMBOL + | MASTER_CONNECT_RETRY_SYMBOL + | MASTER_DELAY_SYMBOL + | MASTER_HEARTBEAT_PERIOD_SYMBOL + | MASTER_HOST_SYMBOL + | NETWORK_NAMESPACE_SYMBOL + | MASTER_LOG_FILE_SYMBOL + | MASTER_LOG_POS_SYMBOL + | MASTER_PASSWORD_SYMBOL + | MASTER_PORT_SYMBOL + | MASTER_PUBLIC_KEY_PATH_SYMBOL + | MASTER_RETRY_COUNT_SYMBOL + | MASTER_SERVER_ID_SYMBOL + | MASTER_SSL_CAPATH_SYMBOL + | MASTER_SSL_CA_SYMBOL + | MASTER_SSL_CERT_SYMBOL + | MASTER_SSL_CIPHER_SYMBOL + | MASTER_SSL_CRLPATH_SYMBOL + | MASTER_SSL_CRL_SYMBOL + | MASTER_SSL_KEY_SYMBOL + | MASTER_SSL_SYMBOL + | MASTER_SYMBOL + | MASTER_TLS_CIPHERSUITES_SYMBOL + | MASTER_TLS_VERSION_SYMBOL + | MASTER_USER_SYMBOL + | MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL + | MAX_CONNECTIONS_PER_HOUR_SYMBOL + | MAX_QUERIES_PER_HOUR_SYMBOL + | MAX_ROWS_SYMBOL + | MAX_SIZE_SYMBOL + | MAX_UPDATES_PER_HOUR_SYMBOL + | MAX_USER_CONNECTIONS_SYMBOL + | MEDIUM_SYMBOL + | MEMORY_SYMBOL + | MERGE_SYMBOL + | MESSAGE_TEXT_SYMBOL + | MICROSECOND_SYMBOL + | MIGRATE_SYMBOL + | MINUTE_SYMBOL + | MIN_ROWS_SYMBOL + | MODE_SYMBOL + | MODIFY_SYMBOL + | MONTH_SYMBOL + | MULTILINESTRING_SYMBOL + | MULTIPOINT_SYMBOL + | MULTIPOLYGON_SYMBOL + | MUTEX_SYMBOL + | MYSQL_ERRNO_SYMBOL + | NAMES_SYMBOL + | NAME_SYMBOL + | NATIONAL_SYMBOL + | NCHAR_SYMBOL + | NDBCLUSTER_SYMBOL + | NESTED_SYMBOL + | NEVER_SYMBOL + | NEW_SYMBOL + | NEXT_SYMBOL + | NODEGROUP_SYMBOL + | NOWAIT_SYMBOL + | NO_WAIT_SYMBOL + | NULLS_SYMBOL + | NUMBER_SYMBOL + | NVARCHAR_SYMBOL + | OFFSET_SYMBOL + | OJ_SYMBOL + | OLD_SYMBOL + | ONE_SYMBOL + | ONLY_SYMBOL + | OPEN_SYMBOL + | OPTIONAL_SYMBOL + | OPTIONS_SYMBOL + | ORDINALITY_SYMBOL + | ORGANIZATION_SYMBOL + | OTHERS_SYMBOL + | OWNER_SYMBOL + | PACK_KEYS_SYMBOL + | PAGE_SYMBOL + | PARSER_SYMBOL + | PARTIAL_SYMBOL + | PARTITIONING_SYMBOL + | PARTITIONS_SYMBOL + | PASSWORD_SYMBOL + | PATH_SYMBOL + | PHASE_SYMBOL + | PLUGINS_SYMBOL + | PLUGIN_DIR_SYMBOL + | PLUGIN_SYMBOL + | POINT_SYMBOL + | POLYGON_SYMBOL + | PORT_SYMBOL + | PRECEDING_SYMBOL + | PRESERVE_SYMBOL + | PREV_SYMBOL + | PRIVILEGES_SYMBOL + | PRIVILEGE_CHECKS_USER_SYMBOL + | PROCESSLIST_SYMBOL + | PROFILES_SYMBOL + | PROFILE_SYMBOL + | QUARTER_SYMBOL + | QUERY_SYMBOL + | QUICK_SYMBOL + | READ_ONLY_SYMBOL + | REBUILD_SYMBOL + | RECOVER_SYMBOL + | REDO_BUFFER_SIZE_SYMBOL + | REDUNDANT_SYMBOL + | REFERENCE_SYMBOL + | RELAY_SYMBOL + | RELAYLOG_SYMBOL + | RELAY_LOG_FILE_SYMBOL + | RELAY_LOG_POS_SYMBOL + | RELAY_THREAD_SYMBOL + | REMOVE_SYMBOL + | REORGANIZE_SYMBOL + | REPEATABLE_SYMBOL + | REPLICATE_DO_DB_SYMBOL + | REPLICATE_DO_TABLE_SYMBOL + | REPLICATE_IGNORE_DB_SYMBOL + | REPLICATE_IGNORE_TABLE_SYMBOL + | REPLICATE_REWRITE_DB_SYMBOL + | REPLICATE_WILD_DO_TABLE_SYMBOL + | REPLICATE_WILD_IGNORE_TABLE_SYMBOL + | USER_RESOURCES_SYMBOL + | RESPECT_SYMBOL + | RESTORE_SYMBOL + | RESUME_SYMBOL + | RETAIN_SYMBOL + | RETURNED_SQLSTATE_SYMBOL + | RETURNS_SYMBOL + | REUSE_SYMBOL + | REVERSE_SYMBOL + | ROLE_SYMBOL + | ROLLUP_SYMBOL + | ROTATE_SYMBOL + | ROUTINE_SYMBOL + | ROW_COUNT_SYMBOL + | ROW_FORMAT_SYMBOL + | RTREE_SYMBOL + | SCHEDULE_SYMBOL + | SCHEMA_NAME_SYMBOL + | SECONDARY_ENGINE_SYMBOL + | SECONDARY_LOAD_SYMBOL + | SECONDARY_SYMBOL + | SECONDARY_UNLOAD_SYMBOL + | SECOND_SYMBOL + | SECURITY_SYMBOL + | SERIALIZABLE_SYMBOL + | SERIAL_SYMBOL + | SERVER_SYMBOL + | SHARE_SYMBOL + | SIMPLE_SYMBOL + | SKIP_SYMBOL + | SLOW_SYMBOL + | SNAPSHOT_SYMBOL + | SOCKET_SYMBOL + | SONAME_SYMBOL + | SOUNDS_SYMBOL + | SOURCE_SYMBOL + | SQL_AFTER_GTIDS_SYMBOL + | SQL_AFTER_MTS_GAPS_SYMBOL + | SQL_BEFORE_GTIDS_SYMBOL + | SQL_BUFFER_RESULT_SYMBOL + | SQL_NO_CACHE_SYMBOL + | SQL_THREAD_SYMBOL + | SRID_SYMBOL + | STACKED_SYMBOL + | STARTS_SYMBOL + | STATS_AUTO_RECALC_SYMBOL + | STATS_PERSISTENT_SYMBOL + | STATS_SAMPLE_PAGES_SYMBOL + | STATUS_SYMBOL + | STORAGE_SYMBOL + | STRING_SYMBOL + | SUBCLASS_ORIGIN_SYMBOL + | SUBDATE_SYMBOL + | SUBJECT_SYMBOL + | SUBPARTITIONS_SYMBOL + | SUBPARTITION_SYMBOL + | SUSPEND_SYMBOL + | SWAPS_SYMBOL + | SWITCHES_SYMBOL + | TABLES_SYMBOL + | TABLESPACE_SYMBOL + | TABLE_CHECKSUM_SYMBOL + | TABLE_NAME_SYMBOL + | TEMPORARY_SYMBOL + | TEMPTABLE_SYMBOL + | TEXT_SYMBOL + | THAN_SYMBOL + | THREAD_PRIORITY_SYMBOL + | TIES_SYMBOL + | TIMESTAMP_ADD_SYMBOL + | TIMESTAMP_DIFF_SYMBOL + | TIMESTAMP_SYMBOL + | TIME_SYMBOL + | TRANSACTION_SYMBOL + | TRIGGERS_SYMBOL + | TYPES_SYMBOL + | TYPE_SYMBOL + | UNBOUNDED_SYMBOL + | UNCOMMITTED_SYMBOL + | UNDEFINED_SYMBOL + | UNDOFILE_SYMBOL + | UNDO_BUFFER_SIZE_SYMBOL + | UNKNOWN_SYMBOL + | UNTIL_SYMBOL + | UPGRADE_SYMBOL + | USER_SYMBOL + | USE_FRM_SYMBOL + | VALIDATION_SYMBOL + | VALUE_SYMBOL + | VARIABLES_SYMBOL + | VCPU_SYMBOL + | VIEW_SYMBOL + | VISIBLE_SYMBOL + | WAIT_SYMBOL + | WARNINGS_SYMBOL + | WEEK_SYMBOL + | WEIGHT_STRING_SYMBOL + | WITHOUT_SYMBOL + | WORK_SYMBOL + | WRAPPER_SYMBOL + | X509_SYMBOL + | XID_SYMBOL + | XML_SYMBOL + | YEAR_SYMBOL + ) + | {serverVersion >= 80019}? ( + ARRAY_SYMBOL + | FAILED_LOGIN_ATTEMPTS_SYMBOL + | MASTER_COMPRESSION_ALGORITHM_SYMBOL + | MASTER_TLS_CIPHERSUITES_SYMBOL + | MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL + | MEMBER_SYMBOL + | OFF_SYMBOL + | PASSWORD_LOCK_TIME_SYMBOL + | PRIVILEGE_CHECKS_USER_SYMBOL + | RANDOM_SYMBOL + | REQUIRE_ROW_FORMAT_SYMBOL + | REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL + | STREAM_SYMBOL + | TIMESTAMP_SYMBOL + | TIME_SYMBOL + ) +; + +// Non-reserved keywords that we allow for unquoted role names: +// +// Not allowed: +// +// ident_keywords_ambiguous_1_roles_and_labels +// ident_keywords_ambiguous_3_roles +roleKeyword: + {serverVersion < 80017}? (roleOrLabelKeyword | roleOrIdentifierKeyword) + | ( + identifierKeywordsUnambiguous + | identifierKeywordsAmbiguous2Labels + | identifierKeywordsAmbiguous4SystemVariables + ) +; + +// Non-reserved words allowed for unquoted unprefixed variable names and +// unquoted variable prefixes in the left side of assignments in SET statements: +// +// Not allowed: +// +// ident_keywords_ambiguous_4_system_variables +lValueKeyword: + identifierKeywordsUnambiguous + | identifierKeywordsAmbiguous1RolesAndLabels + | identifierKeywordsAmbiguous2Labels + | identifierKeywordsAmbiguous3Roles +; + +// These non-reserved keywords cannot be used as unquoted unprefixed +// variable names and unquoted variable prefixes in the left side of +// assignments in SET statements: +identifierKeywordsAmbiguous4SystemVariables: + GLOBAL_SYMBOL + | LOCAL_SYMBOL + | PERSIST_SYMBOL + | PERSIST_ONLY_SYMBOL + | SESSION_SYMBOL +; + +// $antlr-format groupedAlignments off + +// These are the non-reserved keywords which may be used for roles or idents. +// Keywords defined only for specific server versions are handled at lexer level and so cannot match this rule +// if the current server version doesn't allow them. Hence we don't need predicates here for them. +roleOrIdentifierKeyword: + ( + ACCOUNT_SYMBOL // Conditionally set in the lexer. + | ASCII_SYMBOL + | ALWAYS_SYMBOL // Conditionally set in the lexer. + | BACKUP_SYMBOL + | BEGIN_SYMBOL + | BYTE_SYMBOL + | CACHE_SYMBOL + | CHARSET_SYMBOL + | CHECKSUM_SYMBOL + | CLONE_SYMBOL // Conditionally set in the lexer. + | CLOSE_SYMBOL + | COMMENT_SYMBOL + | COMMIT_SYMBOL + | CONTAINS_SYMBOL + | DEALLOCATE_SYMBOL + | DO_SYMBOL + | END_SYMBOL + | FLUSH_SYMBOL + | FOLLOWS_SYMBOL + | FORMAT_SYMBOL + | GROUP_REPLICATION_SYMBOL // Conditionally set in the lexer. + | HANDLER_SYMBOL + | HELP_SYMBOL + | HOST_SYMBOL + | INSTALL_SYMBOL + | INVISIBLE_SYMBOL // Conditionally set in the lexer. + | LANGUAGE_SYMBOL + | NO_SYMBOL + | OPEN_SYMBOL + | OPTIONS_SYMBOL + | OWNER_SYMBOL + | PARSER_SYMBOL + | PARTITION_SYMBOL + | PORT_SYMBOL + | PRECEDES_SYMBOL + | PREPARE_SYMBOL + | REMOVE_SYMBOL + | REPAIR_SYMBOL + | RESET_SYMBOL + | RESTORE_SYMBOL + | ROLE_SYMBOL // Conditionally set in the lexer. + | ROLLBACK_SYMBOL + | SAVEPOINT_SYMBOL + | SECONDARY_SYMBOL // Conditionally set in the lexer. + | SECONDARY_ENGINE_SYMBOL // Conditionally set in the lexer. + | SECONDARY_LOAD_SYMBOL // Conditionally set in the lexer. + | SECONDARY_UNLOAD_SYMBOL // Conditionally set in the lexer. + | SECURITY_SYMBOL + | SERVER_SYMBOL + | SIGNED_SYMBOL + | SOCKET_SYMBOL + | SLAVE_SYMBOL + | SONAME_SYMBOL + | START_SYMBOL + | STOP_SYMBOL + | TRUNCATE_SYMBOL + | UNICODE_SYMBOL + | UNINSTALL_SYMBOL + | UPGRADE_SYMBOL + | VISIBLE_SYMBOL // Conditionally set in the lexer. + | WRAPPER_SYMBOL + | XA_SYMBOL + ) + // Rules that entered or left this rule in specific versions. + | {serverVersion >= 50709}? SHUTDOWN_SYMBOL + | {serverVersion >= 80000}? IMPORT_SYMBOL +; + +roleOrLabelKeyword: + ( + ACTION_SYMBOL + | ACTIVE_SYMBOL // Conditionally set in the lexer. + | ADDDATE_SYMBOL + | AFTER_SYMBOL + | AGAINST_SYMBOL + | AGGREGATE_SYMBOL + | ALGORITHM_SYMBOL + | ANALYSE_SYMBOL // Conditionally set in the lexer. + | ANY_SYMBOL + | AT_SYMBOL + | AUTHORS_SYMBOL // Conditionally set in the lexer. + | AUTO_INCREMENT_SYMBOL + | AUTOEXTEND_SIZE_SYMBOL + | AVG_ROW_LENGTH_SYMBOL + | AVG_SYMBOL + | BINLOG_SYMBOL + | BIT_SYMBOL + | BLOCK_SYMBOL + | BOOL_SYMBOL + | BOOLEAN_SYMBOL + | BTREE_SYMBOL + | BUCKETS_SYMBOL // Conditionally set in the lexer. + | CASCADED_SYMBOL + | CATALOG_NAME_SYMBOL + | CHAIN_SYMBOL + | CHANGED_SYMBOL + | CHANNEL_SYMBOL // Conditionally set in the lexer. + | CIPHER_SYMBOL + | CLIENT_SYMBOL + | CLASS_ORIGIN_SYMBOL + | COALESCE_SYMBOL + | CODE_SYMBOL + | COLLATION_SYMBOL + | COLUMN_NAME_SYMBOL + | COLUMN_FORMAT_SYMBOL + | COLUMNS_SYMBOL + | COMMITTED_SYMBOL + | COMPACT_SYMBOL + | COMPLETION_SYMBOL + | COMPONENT_SYMBOL + | COMPRESSED_SYMBOL // Conditionally set in the lexer. + | COMPRESSION_SYMBOL // Conditionally set in the lexer. + | CONCURRENT_SYMBOL + | CONNECTION_SYMBOL + | CONSISTENT_SYMBOL + | CONSTRAINT_CATALOG_SYMBOL + | CONSTRAINT_SCHEMA_SYMBOL + | CONSTRAINT_NAME_SYMBOL + | CONTEXT_SYMBOL + | CONTRIBUTORS_SYMBOL // Conditionally set in the lexer. + | CPU_SYMBOL + /* + Although a reserved keyword in SQL:2003 (and :2008), + not reserved in MySQL per WL#2111 specification. + */ + | CURRENT_SYMBOL + | CURSOR_NAME_SYMBOL + | DATA_SYMBOL + | DATAFILE_SYMBOL + | DATETIME_SYMBOL + | DATE_SYMBOL + | DAY_SYMBOL + | DEFAULT_AUTH_SYMBOL + | DEFINER_SYMBOL + | DELAY_KEY_WRITE_SYMBOL + | DES_KEY_FILE_SYMBOL // Conditionally set in the lexer. + | DESCRIPTION_SYMBOL // Conditionally set in the lexer. + | DIAGNOSTICS_SYMBOL + | DIRECTORY_SYMBOL + | DISABLE_SYMBOL + | DISCARD_SYMBOL + | DISK_SYMBOL + | DUMPFILE_SYMBOL + | DUPLICATE_SYMBOL + | DYNAMIC_SYMBOL + | ENCRYPTION_SYMBOL // Conditionally set in the lexer. + | ENDS_SYMBOL + | ENUM_SYMBOL + | ENGINE_SYMBOL + | ENGINES_SYMBOL + | ERROR_SYMBOL + | ERRORS_SYMBOL + | ESCAPE_SYMBOL + | EVENTS_SYMBOL + | EVERY_SYMBOL + | EXCLUDE_SYMBOL // Conditionally set in the lexer. + | EXPANSION_SYMBOL + | EXPORT_SYMBOL + | EXTENDED_SYMBOL + | EXTENT_SIZE_SYMBOL + | FAULTS_SYMBOL + | FAST_SYMBOL + | FOLLOWING_SYMBOL // Conditionally set in the lexer. + | FOUND_SYMBOL + | ENABLE_SYMBOL + | FULL_SYMBOL + | FILE_BLOCK_SIZE_SYMBOL // Conditionally set in the lexer. + | FILTER_SYMBOL + | FIRST_SYMBOL + | FIXED_SYMBOL + | GENERAL_SYMBOL + | GEOMETRY_SYMBOL + | GEOMETRYCOLLECTION_SYMBOL + | GET_FORMAT_SYMBOL + | GRANTS_SYMBOL + | GLOBAL_SYMBOL + | HASH_SYMBOL + | HISTOGRAM_SYMBOL // Conditionally set in the lexer. + | HISTORY_SYMBOL // Conditionally set in the lexer. + | HOSTS_SYMBOL + | HOUR_SYMBOL + | IDENTIFIED_SYMBOL + | IGNORE_SERVER_IDS_SYMBOL + | INVOKER_SYMBOL + | INDEXES_SYMBOL + | INITIAL_SIZE_SYMBOL + | INSTANCE_SYMBOL // Conditionally deprecated in the lexer. + | INACTIVE_SYMBOL // Conditionally set in the lexer. + | IO_SYMBOL + | IPC_SYMBOL + | ISOLATION_SYMBOL + | ISSUER_SYMBOL + | INSERT_METHOD_SYMBOL + | JSON_SYMBOL // Conditionally set in the lexer. + | KEY_BLOCK_SIZE_SYMBOL + | LAST_SYMBOL + | LEAVES_SYMBOL + | LESS_SYMBOL + | LEVEL_SYMBOL + | LINESTRING_SYMBOL + | LIST_SYMBOL + | LOCAL_SYMBOL + | LOCKED_SYMBOL // Conditionally set in the lexer. + | LOCKS_SYMBOL + | LOGFILE_SYMBOL + | LOGS_SYMBOL + | MAX_ROWS_SYMBOL + | MASTER_SYMBOL + | MASTER_HEARTBEAT_PERIOD_SYMBOL + | MASTER_HOST_SYMBOL + | MASTER_PORT_SYMBOL + | MASTER_LOG_FILE_SYMBOL + | MASTER_LOG_POS_SYMBOL + | MASTER_USER_SYMBOL + | MASTER_PASSWORD_SYMBOL + | MASTER_PUBLIC_KEY_PATH_SYMBOL // Conditionally set in the lexer. + | MASTER_SERVER_ID_SYMBOL + | MASTER_CONNECT_RETRY_SYMBOL + | MASTER_RETRY_COUNT_SYMBOL + | MASTER_DELAY_SYMBOL + | MASTER_SSL_SYMBOL + | MASTER_SSL_CA_SYMBOL + | MASTER_SSL_CAPATH_SYMBOL + | MASTER_TLS_VERSION_SYMBOL // Conditionally deprecated in the lexer. + | MASTER_SSL_CERT_SYMBOL + | MASTER_SSL_CIPHER_SYMBOL + | MASTER_SSL_CRL_SYMBOL + | MASTER_SSL_CRLPATH_SYMBOL + | MASTER_SSL_KEY_SYMBOL + | MASTER_AUTO_POSITION_SYMBOL + | MAX_CONNECTIONS_PER_HOUR_SYMBOL + | MAX_QUERIES_PER_HOUR_SYMBOL + | MAX_STATEMENT_TIME_SYMBOL // Conditionally deprecated in the lexer. + | MAX_SIZE_SYMBOL + | MAX_UPDATES_PER_HOUR_SYMBOL + | MAX_USER_CONNECTIONS_SYMBOL + | MEDIUM_SYMBOL + | MEMORY_SYMBOL + | MERGE_SYMBOL + | MESSAGE_TEXT_SYMBOL + | MICROSECOND_SYMBOL + | MIGRATE_SYMBOL + | MINUTE_SYMBOL + | MIN_ROWS_SYMBOL + | MODIFY_SYMBOL + | MODE_SYMBOL + | MONTH_SYMBOL + | MULTILINESTRING_SYMBOL + | MULTIPOINT_SYMBOL + | MULTIPOLYGON_SYMBOL + | MUTEX_SYMBOL + | MYSQL_ERRNO_SYMBOL + | NAME_SYMBOL + | NAMES_SYMBOL + | NATIONAL_SYMBOL + | NCHAR_SYMBOL + | NDBCLUSTER_SYMBOL + | NESTED_SYMBOL // Conditionally set in the lexer. + | NEVER_SYMBOL + | NEXT_SYMBOL + | NEW_SYMBOL + | NO_WAIT_SYMBOL + | NODEGROUP_SYMBOL + | NULLS_SYMBOL // Conditionally set in the lexer. + | NOWAIT_SYMBOL // Conditionally set in the lexer. + | NUMBER_SYMBOL + | NVARCHAR_SYMBOL + | OFFSET_SYMBOL + | OLD_SYMBOL // Conditionally set in the lexer. + | OLD_PASSWORD_SYMBOL // Conditionally set in the lexer. + | ONE_SYMBOL + | OPTIONAL_SYMBOL // Conditionally set in the lexer. + | ORDINALITY_SYMBOL // Conditionally set in the lexer. + | ORGANIZATION_SYMBOL // Conditionally set in the lexer. + | OTHERS_SYMBOL // Conditionally set in the lexer. + | PACK_KEYS_SYMBOL + | PAGE_SYMBOL + | PARTIAL_SYMBOL + | PARTITIONING_SYMBOL + | PARTITIONS_SYMBOL + | PASSWORD_SYMBOL + | PATH_SYMBOL // Conditionally set in the lexer. + | PHASE_SYMBOL + | PLUGIN_DIR_SYMBOL + | PLUGIN_SYMBOL + | PLUGINS_SYMBOL + | POINT_SYMBOL + | POLYGON_SYMBOL + | PRECEDING_SYMBOL // Conditionally set in the lexer. + | PRESERVE_SYMBOL + | PREV_SYMBOL + | THREAD_PRIORITY_SYMBOL // Conditionally set in the lexer. + | PRIVILEGES_SYMBOL + | PROCESSLIST_SYMBOL + | PROFILE_SYMBOL + | PROFILES_SYMBOL + | QUARTER_SYMBOL + | QUERY_SYMBOL + | QUICK_SYMBOL + | READ_ONLY_SYMBOL + | REBUILD_SYMBOL + | RECOVER_SYMBOL + | REDO_BUFFER_SIZE_SYMBOL + | REDOFILE_SYMBOL // Conditionally set in the lexer. + | REDUNDANT_SYMBOL + | RELAY_SYMBOL + | RELAYLOG_SYMBOL + | RELAY_LOG_FILE_SYMBOL + | RELAY_LOG_POS_SYMBOL + | RELAY_THREAD_SYMBOL + | REMOTE_SYMBOL // Conditionally set in the lexer. + | REORGANIZE_SYMBOL + | REPEATABLE_SYMBOL + | REPLICATE_DO_DB_SYMBOL + | REPLICATE_IGNORE_DB_SYMBOL + | REPLICATE_DO_TABLE_SYMBOL + | REPLICATE_IGNORE_TABLE_SYMBOL + | REPLICATE_WILD_DO_TABLE_SYMBOL + | REPLICATE_WILD_IGNORE_TABLE_SYMBOL + | REPLICATE_REWRITE_DB_SYMBOL + | USER_RESOURCES_SYMBOL // Placed like in the server grammar where it is named just RESOURCES. + | RESPECT_SYMBOL // Conditionally set in the lexer. + | RESUME_SYMBOL + | RETAIN_SYMBOL // Conditionally set in the lexer. + | RETURNED_SQLSTATE_SYMBOL + | RETURNS_SYMBOL + | REUSE_SYMBOL // Conditionally set in the lexer. + | REVERSE_SYMBOL + | ROLLUP_SYMBOL + | ROTATE_SYMBOL // Conditionally deprecated in the lexer. + | ROUTINE_SYMBOL + | ROW_COUNT_SYMBOL + | ROW_FORMAT_SYMBOL + | RTREE_SYMBOL + | SCHEDULE_SYMBOL + | SCHEMA_NAME_SYMBOL + | SECOND_SYMBOL + | SERIAL_SYMBOL + | SERIALIZABLE_SYMBOL + | SESSION_SYMBOL + | SHARE_SYMBOL + | SIMPLE_SYMBOL + | SKIP_SYMBOL // Conditionally set in the lexer. + | SLOW_SYMBOL + | SNAPSHOT_SYMBOL + | SOUNDS_SYMBOL + | SOURCE_SYMBOL + | SQL_AFTER_GTIDS_SYMBOL + | SQL_AFTER_MTS_GAPS_SYMBOL + | SQL_BEFORE_GTIDS_SYMBOL + | SQL_CACHE_SYMBOL // Conditionally deprecated in the lexer. + | SQL_BUFFER_RESULT_SYMBOL + | SQL_NO_CACHE_SYMBOL + | SQL_THREAD_SYMBOL + | SRID_SYMBOL // Conditionally set in the lexer. + | STACKED_SYMBOL + | STARTS_SYMBOL + | STATS_AUTO_RECALC_SYMBOL + | STATS_PERSISTENT_SYMBOL + | STATS_SAMPLE_PAGES_SYMBOL + | STATUS_SYMBOL + | STORAGE_SYMBOL + | STRING_SYMBOL + | SUBCLASS_ORIGIN_SYMBOL + | SUBDATE_SYMBOL + | SUBJECT_SYMBOL + | SUBPARTITION_SYMBOL + | SUBPARTITIONS_SYMBOL + | SUPER_SYMBOL + | SUSPEND_SYMBOL + | SWAPS_SYMBOL + | SWITCHES_SYMBOL + | TABLE_NAME_SYMBOL + | TABLES_SYMBOL + | TABLE_CHECKSUM_SYMBOL + | TABLESPACE_SYMBOL + | TEMPORARY_SYMBOL + | TEMPTABLE_SYMBOL + | TEXT_SYMBOL + | THAN_SYMBOL + | TIES_SYMBOL // Conditionally set in the lexer. + | TRANSACTION_SYMBOL + | TRIGGERS_SYMBOL + | TIMESTAMP_SYMBOL + | TIMESTAMP_ADD_SYMBOL + | TIMESTAMP_DIFF_SYMBOL + | TIME_SYMBOL + | TYPES_SYMBOL + | TYPE_SYMBOL + | UDF_RETURNS_SYMBOL + | UNBOUNDED_SYMBOL // Conditionally set in the lexer. + | UNCOMMITTED_SYMBOL + | UNDEFINED_SYMBOL + | UNDO_BUFFER_SIZE_SYMBOL + | UNDOFILE_SYMBOL + | UNKNOWN_SYMBOL + | UNTIL_SYMBOL + | USER_SYMBOL + | USE_FRM_SYMBOL + | VARIABLES_SYMBOL + | VCPU_SYMBOL // Conditionally set in the lexer. + | VIEW_SYMBOL + | VALUE_SYMBOL + | WARNINGS_SYMBOL + | WAIT_SYMBOL + | WEEK_SYMBOL + | WORK_SYMBOL + | WEIGHT_STRING_SYMBOL + | X509_SYMBOL + | XID_SYMBOL + | XML_SYMBOL + | YEAR_SYMBOL + ) + // Tokens that entered or left this rule in specific versions and are not automatically + // handled in the lexer. + | {serverVersion < 50709}? SHUTDOWN_SYMBOL + | {serverVersion < 80000}? ( + CUBE_SYMBOL + | IMPORT_SYMBOL + | FUNCTION_SYMBOL + | ROWS_SYMBOL + | ROW_SYMBOL + ) + | {serverVersion >= 80000}? ( + EXCHANGE_SYMBOL + | EXPIRE_SYMBOL + | ONLY_SYMBOL + | SUPER_SYMBOL + | VALIDATION_SYMBOL + | WITHOUT_SYMBOL + ) + | {serverVersion >= 80014}? ADMIN_SYMBOL +; \ No newline at end of file diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/run-tests.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/run-tests.php deleted file mode 100644 index cf0db1fe..00000000 --- a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/run-tests.php +++ /dev/null @@ -1,287 +0,0 @@ - 'SELECT 1', - 'complexSelect' => << << << << << << 5 -) c ON o.customer_id = c.customer_id -SET o.`status` = 'Shipped'; -ACID, - - 'updateSubQuery' => << << << << << << << << << << 'DROP TABLE products;', - 'dropIndex' => 'DROP INDEX idx_col_h_i_j ON products;', - 'dropColumn' => 'ALTER TABLE products DROP COLUMN product_name;', - 'dropConstraint' => 'ALTER TABLE products DROP FOREIGN KEY fk_product_id;', - 'dropDatabase' => 'DROP DATABASE mydatabase;', - 'createDatabase' => 'CREATE DATABASE mydatabase;', - 'showDatabases' => 'SHOW DATABASES;', - 'showTables' => 'SHOW TABLES;', - 'showColumns' => 'SHOW COLUMNS FROM products;', - 'showIndexes' => 'SHOW INDEXES FROM products;', - 'showExtendedIndexes' => 'SHOW EXTENDED INDEXES FROM products;', - 'showConstraints' => 'SHOW CONSTRAINTS FROM products;', - 'showCreateTable' => 'SHOW CREATE TABLE products;', - 'showStatus' => 'SHOW STATUS;', - 'showVariables' => 'SHOW VARIABLES;', - 'showProcesslist' => 'SHOW PROCESSLIST;', - 'showGrants' => 'SHOW GRANTS;', - 'showPrivileges' => 'SHOW PRIVILEGES;', - 'showEngines' => 'SHOW ENGINES;', - 'showStorageEngines' => 'SHOW STORAGE ENGINES;', - 'showPlugins' => 'SHOW PLUGINS;', - 'showWarnings' => 'SHOW WARNINGS;', - 'showErrors' => 'SHOW ERRORS;', - 'showEvents' => 'SHOW EVENTS;', - 'showTriggers' => 'SHOW TRIGGERS;', - 'showCreate' => 'SHOW CREATE EVENT myevent;', - 'showCreateTrigger' => 'SHOW CREATE TRIGGER mytrigger;', - 'showCreateFunction' => 'SHOW CREATE FUNCTION myfunction;', - 'showCreateProcedure' => 'SHOW CREATE PROCEDURE myprocedure;', - 'showCreateView' => 'SHOW CREATE VIEW myview;', - 'showCreateUser' => 'SHOW CREATE USER myuser;', - 'showCreateRole' => 'SHOW CREATE ROLE myrole;', - 'showCreateTablespace' => 'SHOW CREATE TABLESPACE mytablespace;', - 'showCreateDatabase' => 'SHOW CREATE DATABASE mydatabase;', - 'showCreateDatabaseIfNotExists' => 'SHOW CREATE DATABASE IF NOT EXISTS myevent;', - 'showExtended' => 'SHOW EXTENDED COLUMNS FROM products;', - 'showFull' => 'SHOW FULL COLUMNS FROM products;', - 'showExtendedFull' => 'SHOW EXTENDED FULL COLUMNS FROM products;', - - 'setVariable' => 'SET @myvar = 1;', - 'setGlobalVariable' => 'SET GLOBAL myvar = 1;', - 'setSessionVariable' => 'SET SESSION myvar = 1;', - 'setTransaction' => 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED;', - 'setAutocommit' => 'SET AUTOCOMMIT = 0;', - 'setNames' => 'SET NAMES utf8;', - 'setCharacter' => "SET CHARACTER SET utf8;", - 'setCharacterQuotes' => "SET CHARACTER SET 'utf8';", - 'setNamesCollate' => "SET NAMES 'utf8' COLLATE utf8_general_ci;", - 'setNamesCollateDefault' => "SET NAMES 'utf8' COLLATE DEFAULT;", - 'setSqlMode' => 'SET SQL_MODE = "ANSI_QUOTES";', - 'setTimeZone' => 'SET TIME_ZONE = "+00:00";', - 'setPassword' => "SET PASSWORD = 'newpassword';", - - 'begin' => 'BEGIN;', - 'commit' => 'COMMIT;', - 'rollback' => 'ROLLBACK;', - 'savepoint' => 'SAVEPOINT mysavepoint;', - 'releaseSavepoint' => 'RELEASE SAVEPOINT mysavepoint;', - 'rollbackToSavepoint' => 'ROLLBACK TO SAVEPOINT mysavepoint;', - 'lockTable' => 'LOCK TABLES products WRITE;', - 'unlockTable' => 'UNLOCK TABLES;', - 'flush' => 'FLUSH PRIVILEGES;', - 'flushTables' => 'FLUSH TABLES;', - 'flushLogs' => 'FLUSH LOGS;', - 'flushStatus' => 'FLUSH STATUS;', - 'flushTablesWithReadLock' => 'FLUSH TABLES WITH READ LOCK;', - - // 'flushQueryCache' => 'FLUSH QUERY CACHE;', // MySQL < 8.0 only - 'flushHosts' => 'FLUSH HOSTS;', - 'flushOptimizerCosts' => 'FLUSH OPTIMIZER_COSTS;', - -]; - -foreach ($queries as $key => $query) { - printAST(parse($query)); -} -// benchmarkParser($queries['acidTest']); - -die(); - -function benchmarkParser($query) { - $start = microtime(true); - - for ($i = 0; $i < 500; $i++) { - parse($query); - } - - $end = microtime(true); - $executionTime = ($end - $start); - - echo "Execution time: " . $executionTime . " seconds"; -} - -function parse($query) { - $lexer = new MySQLLexer($query, 80019); - $parser = new MySQLParser($lexer); - return $parser->query(); -} - -function printAST(ASTNode $ast, $indent = 0) { - echo str_repeat(' ', $indent) . $ast . PHP_EOL; - foreach($ast->children as $child) { - printAST($child, $indent + 2); - } -} - -function printParserTree($parser) { - $parser->query(); - $parser->printTree(); -} - -function printLexerTokens($lexer) { - while($lexer->getNextToken()) { - echo $lexer->getToken() . PHP_EOL; - // var_dump($lexer->getToken()->getType()); - if($lexer->getToken()->getType() === MySQLLexer::EOF) { - break; - } - } -} diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php new file mode 100644 index 00000000..b806167d --- /dev/null +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php @@ -0,0 +1,64 @@ + 'SELECT 1', +]; + +foreach ($queries as $key => $query) { + printAST(parse($query)); +} +// benchmarkParser($queries['acidTest']); + +die(); + +function benchmarkParser($query) { + $start = microtime(true); + + for ($i = 0; $i < 500; $i++) { + parse($query); + } + + $end = microtime(true); + $executionTime = ($end - $start); + + echo "Execution time: " . $executionTime . " seconds"; +} + +function parse($query) { + $lexer = new MySQLLexer($query, 80019); + $parser = new MySQLParser($lexer); + return $parser->query(); +} + +function printAST(ASTNode $ast, $indent = 0) { + echo str_repeat(' ', $indent) . $ast . PHP_EOL; + foreach($ast->children as $child) { + printAST($child, $indent + 2); + } +} + +function printParserTree($parser) { + $parser->query(); + $parser->printTree(); +} + +function printLexerTokens($lexer) { + while($lexer->getNextToken()) { + echo $lexer->getToken() . PHP_EOL; + // var_dump($lexer->getToken()->getType()); + if($lexer->getToken()->getType() === MySQLLexer::EOF) { + break; + } + } +} From 1fe180ca67052cb8bc0d39a9f31a273155a33510 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adam=20Zieli=C5=84ski?= Date: Mon, 12 Aug 2024 13:20:47 +0200 Subject: [PATCH 17/17] Support more GRANT query types --- tests/WP_MySQL_Parser_Tests.php | 103 +++++++++++++----- .../wp-includes/mysql-parser/MySQLLexer.php | 8 ++ .../wp-includes/mysql-parser/MySQLParser.php | 66 +++++------ .../mysql-parser/sql-playground.php | 7 +- 4 files changed, 122 insertions(+), 62 deletions(-) diff --git a/tests/WP_MySQL_Parser_Tests.php b/tests/WP_MySQL_Parser_Tests.php index 16ac7ec4..e0e12ec5 100644 --- a/tests/WP_MySQL_Parser_Tests.php +++ b/tests/WP_MySQL_Parser_Tests.php @@ -10,8 +10,8 @@ class WP_MySQL_Parser_Tests extends TestCase { /** * @dataProvider mysqlQueries */ - public function testParsesWithoutErrors( $query ) { - $lexer = new MySQLLexer($query, 80019); + public function testParsesWithoutErrors( $query, $mysql_version=80000 ) { + $lexer = new MySQLLexer($query, $mysql_version); $parser = new MySQLParser($lexer); $parser->query(); @@ -22,28 +22,8 @@ public function testParsesWithoutErrors( $query ) { public static function mysqlQueries() { return array( - 'simple' => ['SELECT 1'], - 'simple' => ['SELECT 1'], - 'complexSelect' => [<< ['CREATE DATABASE mydatabase;'], 'createTable' => [<< [<< [<< [<< [<< ['ALTER TABLE products MODIFY COLUMN product_name VARCHAR(200) NOT NULL;'], 'alterIndex' => ['ALTER TABLE products DROP INDEX idx_col_h_i, ADD INDEX idx_col_h_i_j (`col_h`, `col_i`, `col_j`);'], + + // SELECT + 'simple' => ['SELECT 1'], + 'complexSelect' => [<< ['DROP TABLE products;'], 'dropIndex' => ['DROP INDEX idx_col_h_i_j ON products;'], 'dropColumn' => ['ALTER TABLE products DROP COLUMN product_name;'], 'dropConstraint' => ['ALTER TABLE products DROP FOREIGN KEY fk_product_id;'], 'dropDatabase' => ['DROP DATABASE mydatabase;'], - 'createDatabase' => ['CREATE DATABASE mydatabase;'], + + // GRANT + 'grantAll' => ['GRANT ALL ON mydatabase TO myuser@localhost;'], + 'grantSelect' => ['GRANT SELECT ON mydatabase TO myuser@localhost;'], + 'grantInsert' => ['GRANT INSERT ON mydatabase TO myuser@localhost;'], + 'grantUpdate' => ['GRANT UPDATE ON mydatabase TO myuser@localhost;'], + 'grantDelete' => ['GRANT DELETE ON mydatabase TO myuser@localhost;'], + 'grantCreate' => ['GRANT CREATE ON mydatabase TO myuser@localhost;'], + 'grantDrop' => ['GRANT DROP ON mydatabase TO myuser@localhost;'], + 'grantAlter' => ['GRANT ALTER ON mydatabase TO myuser@localhost;'], + 'grantIndex' => ['GRANT INDEX ON mydatabase TO myuser@localhost;'], + 'grantCreateView' => ['GRANT CREATE VIEW ON mydatabase TO myuser@localhost;'], + 'grantShowView' => ['GRANT SHOW VIEW ON mydatabase TO myuser@localhost;'], + 'grantCreateRoutine' => ['GRANT CREATE ROUTINE ON mydatabase TO myuser@localhost;'], + 'grantAlterRoutine' => ['GRANT ALTER ROUTINE ON mydatabase TO myuser@localhost;'], + 'grantExecute' => ['GRANT EXECUTE ON mydatabase TO myuser@localhost;'], + 'grantEvent' => ['GRANT EVENT ON mydatabase TO myuser@localhost;'], + 'grantTrigger' => ['GRANT TRIGGER ON mydatabase TO myuser@localhost;'], + 'grantLockTables' => ['GRANT LOCK TABLES ON mydatabase TO myuser@localhost;'], + 'grantReferences' => ['GRANT REFERENCES ON mydatabase TO myuser@localhost;'], + 'grantCreateTemporaryTables' => ['GRANT CREATE TEMPORARY TABLES ON mydatabase TO myuser@localhost;'], + 'grantShowDatabases' => ['GRANT SHOW DATABASES ON mydatabase TO myuser@localhost;'], + 'grantSuper' => ['GRANT SUPER ON mydatabase TO myuser@localhost;'], + 'grantReload' => ['GRANT RELOAD ON mydatabase TO myuser@localhost;'], + 'grantShutdown' => ['GRANT SHUTDOWN ON mydatabase TO myuser@localhost;', 80017], + 'grantProcess' => ['GRANT PROCESS ON mydatabase TO myuser@localhost;'], + 'grantFile' => ['GRANT FILE ON mydatabase TO myuser@localhost;'], + 'grantSelectOnAllTables' => ['GRANT SELECT ON mydatabase.* TO myuser@localhost;', 80000], + 'grantSelectOnTable' => ['GRANT SELECT ON mydatabase.mytable TO myuser@localhost;', 80017], + + // SHOW 'showDatabases' => ['SHOW DATABASES;'], 'showTables' => ['SHOW TABLES;'], 'showColumns' => ['SHOW COLUMNS FROM products;'], @@ -193,12 +238,14 @@ public static function mysqlQueries() { 'showCreateView' => ['SHOW CREATE VIEW myview;'], 'showCreateUser' => ['SHOW CREATE USER myuser;'], 'showCreateRole' => ['SHOW CREATE ROLE myrole;'], - 'showCreateTablespace' => ['SHOW CREATE TABLESPACE mytablespace;'], + 'showCreateTablespace' => ['SHOW CREATE TABLESPACE mytablespace;', 80017], 'showCreateDatabase' => ['SHOW CREATE DATABASE mydatabase;'], 'showCreateDatabaseIfNotExists' => ['SHOW CREATE DATABASE IF NOT EXISTS myevent;'], 'showExtended' => ['SHOW EXTENDED COLUMNS FROM products;'], 'showFull' => ['SHOW FULL COLUMNS FROM products;'], 'showExtendedFull' => ['SHOW EXTENDED FULL COLUMNS FROM products;'], + + // SET 'setVariable' => ['SET @myvar = 1;'], 'setGlobalVariable' => ['SET GLOBAL myvar = 1;'], 'setSessionVariable' => ['SET SESSION myvar = 1;'], @@ -212,6 +259,8 @@ public static function mysqlQueries() { 'setSqlMode' => ['SET SQL_MODE = "ANSI_QUOTES";'], 'setTimeZone' => ['SET TIME_ZONE = "+00:00";'], 'setPassword' => ["SET PASSWORD = 'newpassword';"], + + // Transactions 'begin' => ['BEGIN;'], 'commit' => ['COMMIT;'], 'rollback' => ['ROLLBACK;'], diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php index f8de0d53..4126e1b8 100644 --- a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLLexer.php @@ -4017,6 +4017,9 @@ protected function IDENTIFIER_OR_KEYWORD() $this->IDENTIFIER(); } break; + case 'ROUTINE': + $this->ROUTINE_SYMBOL(); + break; case 'ROW': if ($this->serverVersion < 80000) { $this->ROW_SYMBOL(); @@ -8942,6 +8945,11 @@ protected function IDENTIFIER() { $this->setType(self::IDENTIFIER); } + + protected function ROUTINE_SYMBOL() + { + $this->setType(self::ROUTINE_SYMBOL); + } protected function MYSQL_COMMENT_START() { diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php index 23ded00b..e5288d49 100644 --- a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/MySQLParser.php @@ -7492,7 +7492,7 @@ public function grant() $children[] = $this->match(MySQLLexer::ADMIN_SYMBOL); $children[] = $this->match(MySQLLexer::OPTION_SYMBOL); } - } elseif (($token->getType() === MySQLLexer::SELECT_SYMBOL || + } elseif ($token->getType() === MySQLLexer::SELECT_SYMBOL || $token->getType() === MySQLLexer::INSERT_SYMBOL || $token->getType() === MySQLLexer::UPDATE_SYMBOL || $token->getType() === MySQLLexer::REFERENCES_SYMBOL || @@ -7520,11 +7520,12 @@ public function grant() $token->getType() === MySQLLexer::LOCK_SYMBOL || $token->getType() === MySQLLexer::REPLICATION_SYMBOL || $token->getType() === MySQLLexer::SHOW_SYMBOL || + $token->getType() === MySQLLexer::ALTER_SYMBOL || ($this->serverVersion > 80000 && ($token->getType() === MySQLLexer::CREATE_SYMBOL || $token->getType() === MySQLLexer::DROP_SYMBOL)) || $token->getType() === MySQLLexer::GRANT_SYMBOL || - $token->getType() === MySQLLexer::ALL_SYMBOL) && - $this->lexer->peekNextToken(2)->getType() === MySQLLexer::ON_SYMBOL) { + $token->getType() === MySQLLexer::ALL_SYMBOL + ) { if ($token->getType() === MySQLLexer::ALL_SYMBOL) { $children[] = $this->match(MySQLLexer::ALL_SYMBOL); if ($this->lexer->peekNextToken()->getType() === MySQLLexer::PRIVILEGES_SYMBOL) { @@ -7534,6 +7535,9 @@ public function grant() } else { $children[] = $this->roleOrPrivilegesList(); } + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ROUTINE_SYMBOL) { + $children[] = $this->match(MySQLLexer::ROUTINE_SYMBOL); + } $children[] = $this->match(MySQLLexer::ON_SYMBOL); if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TABLE_SYMBOL || $this->lexer->peekNextToken()->getType() === MySQLLexer::FUNCTION_SYMBOL || @@ -7837,32 +7841,10 @@ public function roleOrPrivilege() $token1 = $this->lexer->peekNextToken(); $token2 = $this->lexer->peekNextToken(2); $children = []; - - if ($this->serverVersion > 80000 && - ($token1->getType() === MySQLLexer::IDENTIFIER || - $token1->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || - $token1->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || - $this->isIdentifierKeyword($token1) || - $token1->getType() === MySQLLexer::SINGLE_QUOTED_TEXT)) { - $children[] = $this->roleIdentifierOrText(); - if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { - $children[] = $this->columnInternalRefList(); - } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::AT_TEXT_SUFFIX || - $this->lexer->peekNextToken()->getType() === MySQLLexer::AT_SIGN_SYMBOL) { - if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AT_TEXT_SUFFIX) { - $children[] = $this->match(MySQLLexer::AT_TEXT_SUFFIX); - } else { - $children[] = $this->match(MySQLLexer::AT_SIGN_SYMBOL); - $children[] = $this->textOrIdentifier(); - } - } - - return new ASTNode('roleOrPrivilege', $children); - } elseif (($token1->getType() === MySQLLexer::SELECT_SYMBOL || + if (($token1->getType() === MySQLLexer::SELECT_SYMBOL || $token1->getType() === MySQLLexer::INSERT_SYMBOL || $token1->getType() === MySQLLexer::UPDATE_SYMBOL || - $token1->getType() === MySQLLexer::REFERENCES_SYMBOL) && - $token2->getType() !== MySQLLexer::ON_SYMBOL) { + $token1->getType() === MySQLLexer::REFERENCES_SYMBOL)) { if ($token1->getType() === MySQLLexer::SELECT_SYMBOL) { $children[] = $this->match(MySQLLexer::SELECT_SYMBOL); } elseif ($token1->getType() === MySQLLexer::INSERT_SYMBOL) { @@ -7899,10 +7881,14 @@ public function roleOrPrivilege() $children[] = $this->match(MySQLLexer::GRANT_SYMBOL); $children[] = $this->match(MySQLLexer::OPTION_SYMBOL); return new ASTNode('roleOrPrivilege', $children); - } elseif ($token1->getType() === MySQLLexer::SHOW_SYMBOL) { + } elseif ($token1->getType() === MySQLLexer::SHOW_SYMBOL && $token2->getType() === MySQLLexer::DATABASES_SYMBOL) { $children[] = $this->match(MySQLLexer::SHOW_SYMBOL); $children[] = $this->match(MySQLLexer::DATABASES_SYMBOL); return new ASTNode('roleOrPrivilege', $children); + } elseif ($token1->getType() === MySQLLexer::SHOW_SYMBOL && $token2->getType() === MySQLLexer::VIEW_SYMBOL) { + $children[] = $this->match(MySQLLexer::SHOW_SYMBOL); + $children[] = $this->match(MySQLLexer::VIEW_SYMBOL); + return new ASTNode('roleOrPrivilege', $children); } elseif ($token1->getType() === MySQLLexer::CREATE_SYMBOL) { $children[] = $this->match(MySQLLexer::CREATE_SYMBOL); if ($this->lexer->peekNextToken()->getType() === MySQLLexer::TEMPORARY_SYMBOL) { @@ -7940,10 +7926,6 @@ public function roleOrPrivilege() throw new \Exception('Unexpected token in roleOrPrivilege: ' . $this->lexer->peekNextToken()->getText()); } return new ASTNode('roleOrPrivilege', $children); - } elseif ($token1->getType() === MySQLLexer::SHOW_SYMBOL) { - $children[] = $this->match(MySQLLexer::SHOW_SYMBOL); - $children[] = $this->match(MySQLLexer::VIEW_SYMBOL); - return new ASTNode('roleOrPrivilege', $children); } elseif ($token1->getType() === MySQLLexer::ALTER_SYMBOL) { $children[] = $this->match(MySQLLexer::ALTER_SYMBOL); if ($this->lexer->peekNextToken()->getType() === MySQLLexer::ROUTINE_SYMBOL) { @@ -7959,6 +7941,26 @@ public function roleOrPrivilege() $children[] = $this->match(MySQLLexer::DROP_SYMBOL); } $children[] = $this->match(MySQLLexer::ROLE_SYMBOL); + return new ASTNode('roleOrPrivilege', $children); + } elseif ($this->serverVersion > 80000 && + ($token1->getType() === MySQLLexer::IDENTIFIER || + $token1->getType() === MySQLLexer::BACK_TICK_QUOTED_ID || + $token1->getType() === MySQLLexer::DOUBLE_QUOTED_TEXT || + $this->isIdentifierKeyword($token1) || + $token1->getType() === MySQLLexer::SINGLE_QUOTED_TEXT)) { + $children[] = $this->roleIdentifierOrText(); + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::OPEN_PAR_SYMBOL) { + $children[] = $this->columnInternalRefList(); + } elseif ($this->lexer->peekNextToken()->getType() === MySQLLexer::AT_TEXT_SUFFIX || + $this->lexer->peekNextToken()->getType() === MySQLLexer::AT_SIGN_SYMBOL) { + if ($this->lexer->peekNextToken()->getType() === MySQLLexer::AT_TEXT_SUFFIX) { + $children[] = $this->match(MySQLLexer::AT_TEXT_SUFFIX); + } else { + $children[] = $this->match(MySQLLexer::AT_SIGN_SYMBOL); + $children[] = $this->textOrIdentifier(); + } + } + return new ASTNode('roleOrPrivilege', $children); } else { throw new \Exception('Unexpected token in roleOrPrivilege: ' . $token1->getText()); diff --git a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php index b806167d..47f4c7b0 100644 --- a/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php +++ b/wp-content/plugins/sqlite-database-integration/wp-includes/mysql-parser/sql-playground.php @@ -12,11 +12,12 @@ require __DIR__ . '/MySQLParser.php'; $queries = [ - 'simple' => 'SELECT 1', + 'simple' => ['SELECT 1'], + 'grantSelectOnAll' => ['GRANT SELECT ON mydatabase.* TO myuser@localhost;'], ]; foreach ($queries as $key => $query) { - printAST(parse($query)); + printAST(parse($query[0])); } // benchmarkParser($queries['acidTest']); @@ -36,7 +37,7 @@ function benchmarkParser($query) { } function parse($query) { - $lexer = new MySQLLexer($query, 80019); + $lexer = new MySQLLexer($query, 80000); $parser = new MySQLParser($lexer); return $parser->query(); }