#ifndef LEX_INCLUDED #define LEX_INCLUDED /* Copyright (c) 2000, 2024, Oracle and/or its affiliates. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License, version 2.0, as published by the Free Software Foundation. This program is designed to work with certain software (including but not limited to OpenSSL) that is licensed under separate terms, as designated in a particular file or component or in included license documentation. The authors of MySQL hereby grant you an additional permission to link the program and your derivative works with the separately licensed software that they have either included with the program or referenced in the documentation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ /* This file includes all reserved words and functions */ #include "sql/lex_symbol.h" #include "string_with_len.h" /* We don't want to include sql_yacc.h into gen_lex_hash */ #ifdef NO_YACC_SYMBOLS #define SYM_OR_NULL(A) 0 #else #include "sql/sql_hints.yy.h" #include "sql/sql_yacc.h" #define SYM_OR_NULL(A) A #endif #define HINT_COMMENT_STARTER "/*+" #define HINT_COMMENT_TERMINATOR "*/" #define SYM(T, A) STRING_WITH_LEN(T), SYM_OR_NULL(A), SG_KEYWORDS #define SYM_FN(T, A) STRING_WITH_LEN(T), SYM_OR_NULL(A), SG_FUNCTIONS #define SYM_HK(T, A) STRING_WITH_LEN(T), SYM_OR_NULL(A), SG_HINTABLE_KEYWORDS #define SYM_H(T, A) STRING_WITH_LEN(T), SYM_OR_NULL(A), SG_HINTS /* Symbols are broken into separated arrays to allow field names with same name as functions. These are kept sorted for human lookup (the symbols are hashed). NOTE! The symbol tables should be the same regardless of what features are compiled into the server. Don't add ifdef'ed symbols to the lists */ static const SYMBOL symbols[] = { /* Insert new SQL keywords after that commentary (by alphabetical order): */ {SYM("&&", AND_AND_SYM)}, {SYM("<", LT)}, {SYM("<=", LE)}, {SYM("<>", NE)}, {SYM("!=", NE)}, {SYM("=", EQ)}, {SYM(">", GT_SYM)}, {SYM(">=", GE)}, {SYM("<<", SHIFT_LEFT)}, {SYM(">>", SHIFT_RIGHT)}, {SYM("<=>", EQUAL_SYM)}, {SYM("ACCESSIBLE", ACCESSIBLE_SYM)}, {SYM("ACCOUNT", ACCOUNT_SYM)}, {SYM("ACTION", ACTION)}, {SYM("ACTIVE", ACTIVE_SYM)}, {SYM("ADD", ADD)}, {SYM("ADMIN", ADMIN_SYM)}, {SYM("AFTER", AFTER_SYM)}, {SYM("AGAINST", AGAINST)}, {SYM("AGGREGATE", AGGREGATE_SYM)}, {SYM("ALL", ALL)}, {SYM("ALGORITHM", ALGORITHM_SYM)}, {SYM("ALTER", ALTER)}, {SYM("ALWAYS", ALWAYS_SYM)}, {SYM("ANALYZE", ANALYZE_SYM)}, {SYM("AND", AND_SYM)}, {SYM("ANY", ANY_SYM)}, {SYM("ARRAY", ARRAY_SYM)}, {SYM("AS", AS)}, {SYM("ASC", ASC)}, {SYM("ASCII", ASCII_SYM)}, {SYM("ASENSITIVE", ASENSITIVE_SYM)}, {SYM("AT", AT_SYM)}, {SYM("ATTRIBUTE", ATTRIBUTE_SYM)}, {SYM("AUTHENTICATION", AUTHENTICATION_SYM)}, {SYM("AUTO", AUTO_SYM)}, {SYM("AUTO_INCREMENT", AUTO_INC)}, {SYM("AUTOEXTEND_SIZE", AUTOEXTEND_SIZE_SYM)}, {SYM("AVG", AVG_SYM)}, {SYM("AVG_ROW_LENGTH", AVG_ROW_LENGTH)}, {SYM("BACKUP", BACKUP_SYM)}, {SYM("BEFORE", BEFORE_SYM)}, {SYM("BEGIN", BEGIN_SYM)}, {SYM("BERNOULLI", BERNOULLI_SYM)}, {SYM("BETWEEN", BETWEEN_SYM)}, {SYM("BIGINT", BIGINT_SYM)}, {SYM("BINARY", BINARY_SYM)}, {SYM("BINLOG", BINLOG_SYM)}, {SYM("BIT", BIT_SYM)}, {SYM("BLOB", BLOB_SYM)}, {SYM("BLOCK", BLOCK_SYM)}, {SYM("BOOL", BOOL_SYM)}, {SYM("BOOLEAN", BOOLEAN_SYM)}, {SYM("BOTH", BOTH)}, {SYM("BTREE", BTREE_SYM)}, {SYM("BUCKETS", BUCKETS_SYM)}, {SYM("BULK", BULK_SYM)}, {SYM("BY", BY)}, {SYM("BYTE", BYTE_SYM)}, {SYM("CACHE", CACHE_SYM)}, {SYM("CALL", CALL_SYM)}, {SYM("CASCADE", CASCADE)}, {SYM("CASCADED", CASCADED)}, {SYM("CASE", CASE_SYM)}, {SYM("CATALOG_NAME", CATALOG_NAME_SYM)}, {SYM("CHAIN", CHAIN_SYM)}, {SYM("CHALLENGE_RESPONSE", CHALLENGE_RESPONSE_SYM)}, {SYM("CHANGE", CHANGE)}, {SYM("CHANGED", CHANGED)}, {SYM("CHANNEL", CHANNEL_SYM)}, {SYM("CHAR", CHAR_SYM)}, {SYM("CHARACTER", CHAR_SYM)}, {SYM("CHARSET", CHARSET)}, {SYM("CHECK", CHECK_SYM)}, {SYM("CHECKSUM", CHECKSUM_SYM)}, {SYM("CIPHER", CIPHER_SYM)}, {SYM("CLASS_ORIGIN", CLASS_ORIGIN_SYM)}, {SYM("CLIENT", CLIENT_SYM)}, {SYM("CLONE", CLONE_SYM)}, {SYM("CLOSE", CLOSE_SYM)}, {SYM("COALESCE", COALESCE)}, {SYM("CODE", CODE_SYM)}, {SYM("COLLATE", COLLATE_SYM)}, {SYM("COLLATION", COLLATION_SYM)}, {SYM("COLUMN", COLUMN_SYM)}, {SYM("COLUMN_FORMAT", COLUMN_FORMAT_SYM)}, {SYM("COLUMN_NAME", COLUMN_NAME_SYM)}, {SYM("COLUMNS", COLUMNS)}, {SYM("COMMENT", COMMENT_SYM)}, {SYM("COMMIT", COMMIT_SYM)}, {SYM("COMMITTED", COMMITTED_SYM)}, {SYM("COMPACT", COMPACT_SYM)}, {SYM("COMPLETION", COMPLETION_SYM)}, {SYM("COMPONENT", COMPONENT_SYM)}, {SYM("COMPRESSION", COMPRESSION_SYM)}, {SYM("COMPRESSED", COMPRESSED_SYM)}, {SYM("ENCRYPTION", ENCRYPTION_SYM)}, {SYM("CONCURRENT", CONCURRENT)}, {SYM("CONDITION", CONDITION_SYM)}, {SYM("CONNECTION", CONNECTION_SYM)}, {SYM("CONSISTENT", CONSISTENT_SYM)}, {SYM("CONSTRAINT", CONSTRAINT)}, {SYM("CONSTRAINT_CATALOG", CONSTRAINT_CATALOG_SYM)}, {SYM("CONSTRAINT_NAME", CONSTRAINT_NAME_SYM)}, {SYM("CONSTRAINT_SCHEMA", CONSTRAINT_SCHEMA_SYM)}, {SYM("CONTAINS", CONTAINS_SYM)}, {SYM("CONTEXT", CONTEXT_SYM)}, {SYM("CONTINUE", CONTINUE_SYM)}, {SYM("CONVERT", CONVERT_SYM)}, {SYM("CPU", CPU_SYM)}, {SYM("CREATE", CREATE)}, {SYM("CROSS", CROSS)}, {SYM("CUBE", CUBE_SYM)}, {SYM("CUME_DIST", CUME_DIST_SYM)}, {SYM("CURRENT", CURRENT_SYM)}, {SYM("CURRENT_DATE", CURDATE)}, {SYM("CURRENT_TIME", CURTIME)}, {SYM("CURRENT_TIMESTAMP", NOW_SYM)}, {SYM("CURRENT_USER", CURRENT_USER)}, {SYM("CURSOR", CURSOR_SYM)}, {SYM("CURSOR_NAME", CURSOR_NAME_SYM)}, {SYM("DATA", DATA_SYM)}, {SYM("DATABASE", DATABASE)}, {SYM("DATABASES", DATABASES)}, {SYM("DATAFILE", DATAFILE_SYM)}, {SYM("DATE", DATE_SYM)}, {SYM("DATETIME", DATETIME_SYM)}, {SYM("DAY", DAY_SYM)}, {SYM("DAY_HOUR", DAY_HOUR_SYM)}, {SYM("DAY_MICROSECOND", DAY_MICROSECOND_SYM)}, {SYM("DAY_MINUTE", DAY_MINUTE_SYM)}, {SYM("DAY_SECOND", DAY_SECOND_SYM)}, {SYM("DEALLOCATE", DEALLOCATE_SYM)}, {SYM("DEC", DECIMAL_SYM)}, {SYM("DECIMAL", DECIMAL_SYM)}, {SYM("DECLARE", DECLARE_SYM)}, {SYM("DEFAULT", DEFAULT_SYM)}, {SYM("DEFAULT_AUTH", DEFAULT_AUTH_SYM)}, {SYM("DEFINER", DEFINER_SYM)}, {SYM("DEFINITION", DEFINITION_SYM)}, {SYM("DELAYED", DELAYED_SYM)}, {SYM("DELAY_KEY_WRITE", DELAY_KEY_WRITE_SYM)}, {SYM("DENSE_RANK", DENSE_RANK_SYM)}, {SYM("DESC", DESC)}, {SYM("DESCRIBE", DESCRIBE)}, {SYM("DESCRIPTION", DESCRIPTION_SYM)}, {SYM("DETERMINISTIC", DETERMINISTIC_SYM)}, {SYM("DIAGNOSTICS", DIAGNOSTICS_SYM)}, {SYM("DIRECTORY", DIRECTORY_SYM)}, {SYM("DISABLE", DISABLE_SYM)}, {SYM("DISCARD", DISCARD_SYM)}, {SYM("DISK", DISK_SYM)}, {SYM("DISTINCT", DISTINCT)}, {SYM("DISTINCTROW", DISTINCT)}, /* Access likes this */ {SYM("DIV", DIV_SYM)}, {SYM("DO", DO_SYM)}, {SYM("DOUBLE", DOUBLE_SYM)}, {SYM("DROP", DROP)}, {SYM("DUAL", DUAL_SYM)}, {SYM("DUMPFILE", DUMPFILE)}, {SYM("DUPLICATE", DUPLICATE_SYM)}, {SYM("DYNAMIC", DYNAMIC_SYM)}, {SYM("EACH", EACH_SYM)}, {SYM("ELSE", ELSE)}, {SYM("ELSEIF", ELSEIF_SYM)}, {SYM("EMPTY", EMPTY_SYM)}, {SYM("ENABLE", ENABLE_SYM)}, {SYM("ENCLOSED", ENCLOSED)}, {SYM("END", END)}, {SYM("ENDS", ENDS_SYM)}, {SYM("ENFORCED", ENFORCED_SYM)}, {SYM("ENGINE", ENGINE_SYM)}, {SYM("ENGINE_ATTRIBUTE", ENGINE_ATTRIBUTE_SYM)}, {SYM("ENGINES", ENGINES_SYM)}, {SYM("ENUM", ENUM_SYM)}, {SYM("ERROR", ERROR_SYM)}, {SYM("ERRORS", ERRORS)}, {SYM("ESCAPE", ESCAPE_SYM)}, {SYM("ESCAPED", ESCAPED)}, {SYM("EVENT", EVENT_SYM)}, {SYM("EVENTS", EVENTS_SYM)}, {SYM("EVERY", EVERY_SYM)}, {SYM("EXCEPT", EXCEPT_SYM)}, {SYM("EXCHANGE", EXCHANGE_SYM)}, {SYM("EXCLUDE", EXCLUDE_SYM)}, {SYM("EXECUTE", EXECUTE_SYM)}, {SYM("EXISTS", EXISTS)}, {SYM("EXIT", EXIT_SYM)}, {SYM("EXPANSION", EXPANSION_SYM)}, {SYM("EXPORT", EXPORT_SYM)}, {SYM("EXPIRE", EXPIRE_SYM)}, {SYM("EXPLAIN", DESCRIBE)}, {SYM("EXTENDED", EXTENDED_SYM)}, {SYM("EXTENT_SIZE", EXTENT_SIZE_SYM)}, {SYM("FACTOR", FACTOR_SYM)}, {SYM("FAILED_LOGIN_ATTEMPTS", FAILED_LOGIN_ATTEMPTS_SYM)}, {SYM("FALSE", FALSE_SYM)}, {SYM("FAST", FAST_SYM)}, {SYM("FAULTS", FAULTS_SYM)}, {SYM("FETCH", FETCH_SYM)}, {SYM("FIELDS", COLUMNS)}, {SYM("FILE", FILE_SYM)}, {SYM("FILE_BLOCK_SIZE", FILE_BLOCK_SIZE_SYM)}, {SYM("FILTER", FILTER_SYM)}, {SYM("FINISH", FINISH_SYM)}, {SYM("FIRST", FIRST_SYM)}, {SYM("FIRST_VALUE", FIRST_VALUE_SYM)}, {SYM("FIXED", FIXED_SYM)}, {SYM("FLOAT", FLOAT_SYM)}, {SYM("FLOAT4", FLOAT_SYM)}, {SYM("FLOAT8", DOUBLE_SYM)}, {SYM("FLUSH", FLUSH_SYM)}, {SYM("FOLLOWS", FOLLOWS_SYM)}, {SYM("FOLLOWING", FOLLOWING_SYM)}, {SYM("FOR", FOR_SYM)}, {SYM("FORCE", FORCE_SYM)}, {SYM("FOREIGN", FOREIGN)}, {SYM("FORMAT", FORMAT_SYM)}, {SYM("FOUND", FOUND_SYM)}, {SYM("FROM", FROM)}, {SYM("FULL", FULL)}, {SYM("FULLTEXT", FULLTEXT_SYM)}, {SYM("FUNCTION", FUNCTION_SYM)}, {SYM("GENERAL", GENERAL)}, {SYM("GROUP_REPLICATION", GROUP_REPLICATION)}, {SYM("GEOMCOLLECTION", GEOMETRYCOLLECTION_SYM)}, {SYM("GEOMETRY", GEOMETRY_SYM)}, {SYM("GEOMETRYCOLLECTION", GEOMETRYCOLLECTION_SYM)}, {SYM("GET_FORMAT", GET_FORMAT)}, {SYM("GET_SOURCE_PUBLIC_KEY", GET_SOURCE_PUBLIC_KEY_SYM)}, {SYM("GET", GET_SYM)}, {SYM("GENERATE", GENERATE_SYM)}, {SYM("GENERATED", GENERATED)}, {SYM("GLOBAL", GLOBAL_SYM)}, {SYM("GRANT", GRANT)}, {SYM("GRANTS", GRANTS)}, {SYM("GROUP", GROUP_SYM)}, {SYM("GROUPING", GROUPING_SYM)}, {SYM("GROUPS", GROUPS_SYM)}, {SYM("GTIDS", GTIDS_SYM)}, {SYM("GTID_ONLY", GTID_ONLY_SYM)}, {SYM("HANDLER", HANDLER_SYM)}, {SYM("HASH", HASH_SYM)}, {SYM("HAVING", HAVING)}, {SYM("HELP", HELP_SYM)}, {SYM("HIGH_PRIORITY", HIGH_PRIORITY)}, {SYM("HISTOGRAM", HISTOGRAM_SYM)}, {SYM("HISTORY", HISTORY_SYM)}, {SYM("HOST", HOST_SYM)}, {SYM("HOSTS", HOSTS_SYM)}, {SYM("HOUR", HOUR_SYM)}, {SYM("HOUR_MICROSECOND", HOUR_MICROSECOND_SYM)}, {SYM("HOUR_MINUTE", HOUR_MINUTE_SYM)}, {SYM("HOUR_SECOND", HOUR_SECOND_SYM)}, {SYM("IDENTIFIED", IDENTIFIED_SYM)}, {SYM("IF", IF)}, {SYM("IGNORE", IGNORE_SYM)}, {SYM("IGNORE_SERVER_IDS", IGNORE_SERVER_IDS_SYM)}, {SYM("IMPORT", IMPORT)}, {SYM("IN", IN_SYM)}, {SYM("INACTIVE", INACTIVE_SYM)}, {SYM("INDEX", INDEX_SYM)}, {SYM("INDEXES", INDEXES)}, {SYM("INFILE", INFILE_SYM)}, {SYM("INITIAL", INITIAL_SYM)}, {SYM("INITIAL_SIZE", INITIAL_SIZE_SYM)}, {SYM("INITIATE", INITIATE_SYM)}, {SYM("INNER", INNER_SYM)}, {SYM("INOUT", INOUT_SYM)}, {SYM("INSENSITIVE", INSENSITIVE_SYM)}, {SYM("INSERT_METHOD", INSERT_METHOD)}, {SYM("INSTALL", INSTALL_SYM)}, {SYM("INSTANCE", INSTANCE_SYM)}, {SYM("INT", INT_SYM)}, {SYM("INT1", TINYINT_SYM)}, {SYM("INT2", SMALLINT_SYM)}, {SYM("INT3", MEDIUMINT_SYM)}, {SYM("INT4", INT_SYM)}, {SYM("INT8", BIGINT_SYM)}, {SYM("INTEGER", INT_SYM)}, {SYM("INTERSECT", INTERSECT_SYM)}, {SYM("INTERVAL", INTERVAL_SYM)}, {SYM("INTO", INTO)}, {SYM("IO", IO_SYM)}, {SYM("IO_AFTER_GTIDS", IO_AFTER_GTIDS)}, {SYM("IO_BEFORE_GTIDS", IO_BEFORE_GTIDS)}, {SYM("IO_THREAD", RELAY_THREAD)}, {SYM("IPC", IPC_SYM)}, {SYM("IS", IS)}, {SYM("ISOLATION", ISOLATION)}, {SYM("ISSUER", ISSUER_SYM)}, {SYM("ITERATE", ITERATE_SYM)}, {SYM("INVISIBLE", INVISIBLE_SYM)}, {SYM("INVOKER", INVOKER_SYM)}, {SYM("JOIN", JOIN_SYM)}, {SYM("JSON", JSON_SYM)}, {SYM("JSON_TABLE", JSON_TABLE_SYM)}, {SYM("JSON_VALUE", JSON_VALUE_SYM)}, {SYM("KEY", KEY_SYM)}, {SYM("KEYRING", KEYRING_SYM)}, {SYM("KEYS", KEYS)}, {SYM("KEY_BLOCK_SIZE", KEY_BLOCK_SIZE)}, {SYM("KILL", KILL_SYM)}, {SYM("LAG", LAG_SYM)}, {SYM("LANGUAGE", LANGUAGE_SYM)}, {SYM("LAST", LAST_SYM)}, {SYM("LAST_VALUE", LAST_VALUE_SYM)}, {SYM("LATERAL", LATERAL_SYM)}, {SYM("LEAD", LEAD_SYM)}, {SYM("LEADING", LEADING)}, {SYM("LEAVE", LEAVE_SYM)}, {SYM("LEAVES", LEAVES)}, {SYM("LEFT", LEFT)}, {SYM("LESS", LESS_SYM)}, {SYM("LEVEL", LEVEL_SYM)}, {SYM("LIKE", LIKE)}, {SYM("LIMIT", LIMIT)}, {SYM("LINEAR", LINEAR_SYM)}, {SYM("LINES", LINES)}, {SYM("LINESTRING", LINESTRING_SYM)}, {SYM("LIST", LIST_SYM)}, {SYM("LOAD", LOAD)}, {SYM("LOCAL", LOCAL_SYM)}, {SYM("LOCALTIME", NOW_SYM)}, {SYM("LOCALTIMESTAMP", NOW_SYM)}, {SYM("LOCK", LOCK_SYM)}, {SYM("LOCKED", LOCKED_SYM)}, {SYM("LOCKS", LOCKS_SYM)}, {SYM("LOGFILE", LOGFILE_SYM)}, {SYM("LOGS", LOGS_SYM)}, {SYM("LOG", LOG_SYM)}, {SYM("LONG", LONG_SYM)}, {SYM("LONGBLOB", LONGBLOB_SYM)}, {SYM("LONGTEXT", LONGTEXT_SYM)}, {SYM("LOOP", LOOP_SYM)}, {SYM("LOW_PRIORITY", LOW_PRIORITY)}, {SYM("MANUAL", MANUAL_SYM)}, {SYM("MASTER", MASTER_SYM)}, {SYM("MATCH", MATCH)}, {SYM("MAX_CONNECTIONS_PER_HOUR", MAX_CONNECTIONS_PER_HOUR)}, {SYM("MAX_QUERIES_PER_HOUR", MAX_QUERIES_PER_HOUR)}, {SYM("MAX_ROWS", MAX_ROWS)}, {SYM("MAX_SIZE", MAX_SIZE_SYM)}, {SYM("MAX_UPDATES_PER_HOUR", MAX_UPDATES_PER_HOUR)}, {SYM("MAX_USER_CONNECTIONS", MAX_USER_CONNECTIONS_SYM)}, {SYM("MAXVALUE", MAX_VALUE_SYM)}, {SYM("MEDIUM", MEDIUM_SYM)}, {SYM("MEDIUMBLOB", MEDIUMBLOB_SYM)}, {SYM("MEDIUMINT", MEDIUMINT_SYM)}, {SYM("MEDIUMTEXT", MEDIUMTEXT_SYM)}, {SYM("MEMBER", MEMBER_SYM)}, {SYM("MEMORY", MEMORY_SYM)}, {SYM("MERGE", MERGE_SYM)}, {SYM("MESSAGE_TEXT", MESSAGE_TEXT_SYM)}, {SYM("MICROSECOND", MICROSECOND_SYM)}, {SYM("MIDDLEINT", MEDIUMINT_SYM)}, /* For powerbuilder */ {SYM("MIGRATE", MIGRATE_SYM)}, {SYM("MINUTE", MINUTE_SYM)}, {SYM("MINUTE_MICROSECOND", MINUTE_MICROSECOND_SYM)}, {SYM("MINUTE_SECOND", MINUTE_SECOND_SYM)}, {SYM("MIN_ROWS", MIN_ROWS)}, {SYM("MOD", MOD_SYM)}, {SYM("MODE", MODE_SYM)}, {SYM("MODIFIES", MODIFIES_SYM)}, {SYM("MODIFY", MODIFY_SYM)}, {SYM("MONTH", MONTH_SYM)}, {SYM("MULTILINESTRING", MULTILINESTRING_SYM)}, {SYM("MULTIPOINT", MULTIPOINT_SYM)}, {SYM("MULTIPOLYGON", MULTIPOLYGON_SYM)}, {SYM("MUTEX", MUTEX_SYM)}, {SYM("MYSQL_ERRNO", MYSQL_ERRNO_SYM)}, {SYM("NAME", NAME_SYM)}, {SYM("NAMES", NAMES_SYM)}, {SYM("NATIONAL", NATIONAL_SYM)}, {SYM("NATURAL", NATURAL)}, {SYM("NDB", NDBCLUSTER_SYM)}, {SYM("NDBCLUSTER", NDBCLUSTER_SYM)}, {SYM("NCHAR", NCHAR_SYM)}, {SYM("NESTED", NESTED_SYM)}, {SYM("NETWORK_NAMESPACE", NETWORK_NAMESPACE_SYM)}, {SYM("NEVER", NEVER_SYM)}, {SYM("NEW", NEW_SYM)}, {SYM("NEXT", NEXT_SYM)}, {SYM("NO", NO_SYM)}, {SYM("NO_WAIT", NO_WAIT_SYM)}, {SYM("NOWAIT", NOWAIT_SYM)}, {SYM("NODEGROUP", NODEGROUP_SYM)}, {SYM("NONE", NONE_SYM)}, {SYM("NOT", NOT_SYM)}, {SYM("NO_WRITE_TO_BINLOG", NO_WRITE_TO_BINLOG)}, {SYM("NTH_VALUE", NTH_VALUE_SYM)}, {SYM("NTILE", NTILE_SYM)}, {SYM("NULL", NULL_SYM)}, {SYM("NULLS", NULLS_SYM)}, {SYM("NUMBER", NUMBER_SYM)}, {SYM("NUMERIC", NUMERIC_SYM)}, {SYM("NVARCHAR", NVARCHAR_SYM)}, {SYM("OF", OF_SYM)}, {SYM("OFF", OFF_SYM)}, {SYM("OFFSET", OFFSET_SYM)}, {SYM("OJ", OJ_SYM)}, {SYM("OLD", OLD_SYM)}, {SYM("ON", ON_SYM)}, {SYM("ONE", ONE_SYM)}, {SYM("ONLY", ONLY_SYM)}, {SYM("OPEN", OPEN_SYM)}, {SYM("OPTIMIZE", OPTIMIZE)}, {SYM("OPTIMIZER_COSTS", OPTIMIZER_COSTS_SYM)}, {SYM("OPTIONS", OPTIONS_SYM)}, {SYM("OPTION", OPTION)}, {SYM("OPTIONAL", OPTIONAL_SYM)}, {SYM("OPTIONALLY", OPTIONALLY)}, {SYM("OR", OR_SYM)}, {SYM("ORGANIZATION", ORGANIZATION_SYM)}, {SYM("OTHERS", OTHERS_SYM)}, {SYM("ORDER", ORDER_SYM)}, {SYM("ORDINALITY", ORDINALITY_SYM)}, {SYM("OUT", OUT_SYM)}, {SYM("OUTER", OUTER_SYM)}, {SYM("OUTFILE", OUTFILE)}, {SYM("OVER", OVER_SYM)}, {SYM("OWNER", OWNER_SYM)}, {SYM("PACK_KEYS", PACK_KEYS_SYM)}, {SYM("PATH", PATH_SYM)}, {SYM("PARSE_TREE", PARSE_TREE_SYM)}, {SYM("PARSER", PARSER_SYM)}, {SYM("PAGE", PAGE_SYM)}, {SYM("PARALLEL", PARALLEL_SYM)}, {SYM("PARTIAL", PARTIAL)}, {SYM("PARTITION", PARTITION_SYM)}, {SYM("PARTITIONING", PARTITIONING_SYM)}, {SYM("PARTITIONS", PARTITIONS_SYM)}, {SYM("PASSWORD", PASSWORD)}, {SYM("PASSWORD_LOCK_TIME", PASSWORD_LOCK_TIME_SYM)}, {SYM("PERCENT_RANK", PERCENT_RANK_SYM)}, {SYM("PERSIST", PERSIST_SYM)}, {SYM("PERSIST_ONLY", PERSIST_ONLY_SYM)}, {SYM("PHASE", PHASE_SYM)}, {SYM("PLUGIN", PLUGIN_SYM)}, {SYM("PLUGINS", PLUGINS_SYM)}, {SYM("PLUGIN_DIR", PLUGIN_DIR_SYM)}, {SYM("POINT", POINT_SYM)}, {SYM("POLYGON", POLYGON_SYM)}, {SYM("PORT", PORT_SYM)}, {SYM("PRECEDES", PRECEDES_SYM)}, {SYM("PRECEDING", PRECEDING_SYM)}, {SYM("PRECISION", PRECISION)}, {SYM("PREPARE", PREPARE_SYM)}, {SYM("PRESERVE", PRESERVE_SYM)}, {SYM("PREV", PREV_SYM)}, {SYM("PRIMARY", PRIMARY_SYM)}, {SYM("PRIVILEGES", PRIVILEGES)}, {SYM("PRIVILEGE_CHECKS_USER", PRIVILEGE_CHECKS_USER_SYM)}, {SYM("PROCEDURE", PROCEDURE_SYM)}, {SYM("PROCESS", PROCESS)}, {SYM("PROCESSLIST", PROCESSLIST_SYM)}, {SYM("PROFILE", PROFILE_SYM)}, {SYM("PROFILES", PROFILES_SYM)}, {SYM("PROXY", PROXY_SYM)}, {SYM("PURGE", PURGE)}, {SYM("QUALIFY", QUALIFY_SYM)}, {SYM("QUARTER", QUARTER_SYM)}, {SYM("QUERY", QUERY_SYM)}, {SYM("QUICK", QUICK)}, {SYM("RANDOM", RANDOM_SYM)}, {SYM("RANK", RANK_SYM)}, {SYM("RANGE", RANGE_SYM)}, {SYM("READ", READ_SYM)}, {SYM("READ_ONLY", READ_ONLY_SYM)}, {SYM("READ_WRITE", READ_WRITE_SYM)}, {SYM("READS", READS_SYM)}, {SYM("REAL", REAL_SYM)}, {SYM("REBUILD", REBUILD_SYM)}, {SYM("RECOVER", RECOVER_SYM)}, {SYM("RECURSIVE", RECURSIVE_SYM)}, {SYM("REDO_BUFFER_SIZE", REDO_BUFFER_SIZE_SYM)}, {SYM("REDUNDANT", REDUNDANT_SYM)}, {SYM("REFERENCE", REFERENCE_SYM)}, {SYM("REFERENCES", REFERENCES)}, {SYM("REGEXP", REGEXP)}, {SYM("REGISTRATION", REGISTRATION_SYM)}, {SYM("RELAY", RELAY)}, {SYM("RELAYLOG", RELAYLOG_SYM)}, {SYM("RELAY_LOG_FILE", RELAY_LOG_FILE_SYM)}, {SYM("RELAY_LOG_POS", RELAY_LOG_POS_SYM)}, {SYM("RELAY_THREAD", RELAY_THREAD)}, {SYM("RELEASE", RELEASE_SYM)}, {SYM("RELOAD", RELOAD)}, {SYM("REMOVE", REMOVE_SYM)}, {SYM("RENAME", RENAME)}, {SYM("ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS", ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYM)}, {SYM("REORGANIZE", REORGANIZE_SYM)}, {SYM("REPAIR", REPAIR)}, {SYM("REPEATABLE", REPEATABLE_SYM)}, {SYM("REPLICA", REPLICA_SYM)}, {SYM("REPLICAS", REPLICAS_SYM)}, {SYM("REPLICATION", REPLICATION)}, {SYM("REPLICATE_DO_DB", REPLICATE_DO_DB)}, {SYM("REPLICATE_IGNORE_DB", REPLICATE_IGNORE_DB)}, {SYM("REPLICATE_DO_TABLE", REPLICATE_DO_TABLE)}, {SYM("REPLICATE_IGNORE_TABLE", REPLICATE_IGNORE_TABLE)}, {SYM("REPLICATE_WILD_DO_TABLE", REPLICATE_WILD_DO_TABLE)}, {SYM("REPLICATE_WILD_IGNORE_TABLE", REPLICATE_WILD_IGNORE_TABLE)}, {SYM("REPLICATE_REWRITE_DB", REPLICATE_REWRITE_DB)}, {SYM("REPEAT", REPEAT_SYM)}, {SYM("REQUIRE", REQUIRE_SYM)}, {SYM("REQUIRE_ROW_FORMAT", REQUIRE_ROW_FORMAT_SYM)}, {SYM("REQUIRE_TABLE_PRIMARY_KEY_CHECK", REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYM)}, {SYM("RESET", RESET_SYM)}, {SYM("RESPECT", RESPECT_SYM)}, {SYM("RESIGNAL", RESIGNAL_SYM)}, {SYM("RESOURCE", RESOURCE_SYM)}, {SYM("RESTART", RESTART_SYM)}, {SYM("RESTORE", RESTORE_SYM)}, {SYM("RESTRICT", RESTRICT)}, {SYM("RESUME", RESUME_SYM)}, {SYM("RETAIN", RETAIN_SYM)}, {SYM("RETURNED_SQLSTATE", RETURNED_SQLSTATE_SYM)}, {SYM("RETURN", RETURN_SYM)}, {SYM("RETURNING", RETURNING_SYM)}, {SYM("RETURNS", RETURNS_SYM)}, {SYM("REUSE", REUSE_SYM)}, {SYM("REVERSE", REVERSE_SYM)}, {SYM("REVOKE", REVOKE)}, {SYM("RIGHT", RIGHT)}, {SYM("RLIKE", REGEXP)}, /* Like in mSQL2 */ {SYM("ROLE", ROLE_SYM)}, {SYM("ROLLBACK", ROLLBACK_SYM)}, {SYM("ROLLUP", ROLLUP_SYM)}, {SYM("ROUTINE", ROUTINE_SYM)}, {SYM("ROTATE", ROTATE_SYM)}, {SYM("ROW", ROW_SYM)}, {SYM("ROW_COUNT", ROW_COUNT_SYM)}, {SYM("ROW_NUMBER", ROW_NUMBER_SYM)}, {SYM("ROWS", ROWS_SYM)}, {SYM("ROW_FORMAT", ROW_FORMAT_SYM)}, {SYM("RTREE", RTREE_SYM)}, {SYM("S3", S3_SYM)}, {SYM("SAVEPOINT", SAVEPOINT_SYM)}, {SYM("SCHEDULE", SCHEDULE_SYM)}, {SYM("SCHEMA", DATABASE)}, {SYM("SCHEMA_NAME", SCHEMA_NAME_SYM)}, {SYM("SCHEMAS", DATABASES)}, {SYM("SECOND", SECOND_SYM)}, {SYM("SECOND_MICROSECOND", SECOND_MICROSECOND_SYM)}, {SYM("SECONDARY", SECONDARY_SYM)}, {SYM("SECONDARY_ENGINE", SECONDARY_ENGINE_SYM)}, {SYM("SECONDARY_ENGINE_ATTRIBUTE", SECONDARY_ENGINE_ATTRIBUTE_SYM)}, {SYM("SECONDARY_LOAD", SECONDARY_LOAD_SYM)}, {SYM("SECONDARY_UNLOAD", SECONDARY_UNLOAD_SYM)}, {SYM("SECURITY", SECURITY_SYM)}, {SYM("SENSITIVE", SENSITIVE_SYM)}, {SYM("SEPARATOR", SEPARATOR_SYM)}, {SYM("SERIAL", SERIAL_SYM)}, {SYM("SERIALIZABLE", SERIALIZABLE_SYM)}, {SYM("SESSION", SESSION_SYM)}, {SYM("SERVER", SERVER_SYM)}, {SYM("SET", SET_SYM)}, {SYM("SHARE", SHARE_SYM)}, {SYM("SHOW", SHOW)}, {SYM("SHUTDOWN", SHUTDOWN)}, {SYM("SIGNAL", SIGNAL_SYM)}, {SYM("SIGNED", SIGNED_SYM)}, {SYM("SIMPLE", SIMPLE_SYM)}, {SYM("SKIP", SKIP_SYM)}, {SYM("SLAVE", SLAVE)}, {SYM("SLOW", SLOW)}, {SYM("SNAPSHOT", SNAPSHOT_SYM)}, {SYM("SMALLINT", SMALLINT_SYM)}, {SYM("SOCKET", SOCKET_SYM)}, {SYM("SOME", ANY_SYM)}, {SYM("SONAME", SONAME_SYM)}, {SYM("SOUNDS", SOUNDS_SYM)}, {SYM("SOURCE", SOURCE_SYM)}, {SYM("SOURCE_AUTO_POSITION", SOURCE_AUTO_POSITION_SYM)}, {SYM("SOURCE_BIND", SOURCE_BIND_SYM)}, {SYM("SOURCE_COMPRESSION_ALGORITHMS", SOURCE_COMPRESSION_ALGORITHM_SYM)}, {SYM("SOURCE_CONNECT_RETRY", SOURCE_CONNECT_RETRY_SYM)}, {SYM("SOURCE_CONNECTION_AUTO_FAILOVER", SOURCE_CONNECTION_AUTO_FAILOVER_SYM)}, {SYM("SOURCE_DELAY", SOURCE_DELAY_SYM)}, {SYM("SOURCE_HEARTBEAT_PERIOD", SOURCE_HEARTBEAT_PERIOD_SYM)}, {SYM("SOURCE_HOST", SOURCE_HOST_SYM)}, {SYM("SOURCE_LOG_FILE", SOURCE_LOG_FILE_SYM)}, {SYM("SOURCE_LOG_POS", SOURCE_LOG_POS_SYM)}, {SYM("SOURCE_PASSWORD", SOURCE_PASSWORD_SYM)}, {SYM("SOURCE_PORT", SOURCE_PORT_SYM)}, {SYM("SOURCE_PUBLIC_KEY_PATH", SOURCE_PUBLIC_KEY_PATH_SYM)}, {SYM("SOURCE_RETRY_COUNT", SOURCE_RETRY_COUNT_SYM)}, {SYM("SOURCE_SSL_CAPATH", SOURCE_SSL_CAPATH_SYM)}, {SYM("SOURCE_SSL_CA", SOURCE_SSL_CA_SYM)}, {SYM("SOURCE_SSL_CERT", SOURCE_SSL_CERT_SYM)}, {SYM("SOURCE_SSL_CIPHER", SOURCE_SSL_CIPHER_SYM)}, {SYM("SOURCE_SSL_CRL", SOURCE_SSL_CRL_SYM)}, {SYM("SOURCE_SSL_CRLPATH", SOURCE_SSL_CRLPATH_SYM)}, {SYM("SOURCE_SSL_KEY", SOURCE_SSL_KEY_SYM)}, {SYM("SOURCE_SSL", SOURCE_SSL_SYM)}, {SYM("SOURCE_SSL_VERIFY_SERVER_CERT", SOURCE_SSL_VERIFY_SERVER_CERT_SYM)}, {SYM("SOURCE_TLS_CIPHERSUITES", SOURCE_TLS_CIPHERSUITES_SYM)}, {SYM("SOURCE_TLS_VERSION", SOURCE_TLS_VERSION_SYM)}, {SYM("SOURCE_USER", SOURCE_USER_SYM)}, {SYM("SOURCE_ZSTD_COMPRESSION_LEVEL", SOURCE_ZSTD_COMPRESSION_LEVEL_SYM)}, {SYM("SPATIAL", SPATIAL_SYM)}, {SYM("SPECIFIC", SPECIFIC_SYM)}, {SYM("SQL", SQL_SYM)}, {SYM("SQLEXCEPTION", SQLEXCEPTION_SYM)}, {SYM("SQLSTATE", SQLSTATE_SYM)}, {SYM("SQLWARNING", SQLWARNING_SYM)}, {SYM("SQL_AFTER_GTIDS", SQL_AFTER_GTIDS)}, {SYM("SQL_AFTER_MTS_GAPS", SQL_AFTER_MTS_GAPS)}, {SYM("SQL_BEFORE_GTIDS", SQL_BEFORE_GTIDS)}, {SYM("SQL_BIG_RESULT", SQL_BIG_RESULT)}, {SYM("SQL_BUFFER_RESULT", SQL_BUFFER_RESULT)}, {SYM("SQL_CALC_FOUND_ROWS", SQL_CALC_FOUND_ROWS)}, {SYM("SQL_NO_CACHE", SQL_NO_CACHE_SYM)}, {SYM("SQL_SMALL_RESULT", SQL_SMALL_RESULT)}, {SYM("SQL_THREAD", SQL_THREAD)}, {SYM("SQL_TSI_SECOND", SECOND_SYM)}, {SYM("SQL_TSI_MINUTE", MINUTE_SYM)}, {SYM("SQL_TSI_HOUR", HOUR_SYM)}, {SYM("SQL_TSI_DAY", DAY_SYM)}, {SYM("SQL_TSI_WEEK", WEEK_SYM)}, {SYM("SQL_TSI_MONTH", MONTH_SYM)}, {SYM("SQL_TSI_QUARTER", QUARTER_SYM)}, {SYM("SQL_TSI_YEAR", YEAR_SYM)}, {SYM("SRID", SRID_SYM)}, {SYM("SSL", SSL_SYM)}, {SYM("STACKED", STACKED_SYM)}, {SYM("START", START_SYM)}, {SYM("STARTING", STARTING)}, {SYM("STARTS", STARTS_SYM)}, {SYM("STATS_AUTO_RECALC", STATS_AUTO_RECALC_SYM)}, {SYM("STATS_PERSISTENT", STATS_PERSISTENT_SYM)}, {SYM("STATS_SAMPLE_PAGES", STATS_SAMPLE_PAGES_SYM)}, {SYM("STATUS", STATUS_SYM)}, {SYM("STOP", STOP_SYM)}, {SYM("STORAGE", STORAGE_SYM)}, {SYM("STORED", STORED_SYM)}, {SYM("STRAIGHT_JOIN", STRAIGHT_JOIN)}, {SYM("STREAM", STREAM_SYM)}, {SYM("STRING", STRING_SYM)}, {SYM("SUBCLASS_ORIGIN", SUBCLASS_ORIGIN_SYM)}, {SYM("SUBJECT", SUBJECT_SYM)}, {SYM("SUBPARTITION", SUBPARTITION_SYM)}, {SYM("SUBPARTITIONS", SUBPARTITIONS_SYM)}, {SYM("SUPER", SUPER_SYM)}, {SYM("SUSPEND", SUSPEND_SYM)}, {SYM("SWAPS", SWAPS_SYM)}, {SYM("SWITCHES", SWITCHES_SYM)}, {SYM("SYSTEM", SYSTEM_SYM)}, {SYM("TABLE", TABLE_SYM)}, {SYM("TABLE_NAME", TABLE_NAME_SYM)}, {SYM("TABLES", TABLES)}, {SYM("TABLESAMPLE", TABLESAMPLE_SYM)}, {SYM("TABLESPACE", TABLESPACE_SYM)}, {SYM("TABLE_CHECKSUM", TABLE_CHECKSUM_SYM)}, {SYM("TEMPORARY", TEMPORARY)}, {SYM("TEMPTABLE", TEMPTABLE_SYM)}, {SYM("TERMINATED", TERMINATED)}, {SYM("TEXT", TEXT_SYM)}, {SYM("THAN", THAN_SYM)}, {SYM("THEN", THEN_SYM)}, {SYM("THREAD_PRIORITY", THREAD_PRIORITY_SYM)}, {SYM("TIES", TIES_SYM)}, {SYM("TIME", TIME_SYM)}, {SYM("TIMESTAMP", TIMESTAMP_SYM)}, {SYM("TIMESTAMPADD", TIMESTAMP_ADD)}, {SYM("TIMESTAMPDIFF", TIMESTAMP_DIFF)}, {SYM("TINYBLOB", TINYBLOB_SYM)}, {SYM("TINYINT", TINYINT_SYM)}, {SYM("TINYTEXT", TINYTEXT_SYN)}, {SYM("TLS", TLS_SYM)}, {SYM("TO", TO_SYM)}, {SYM("TRAILING", TRAILING)}, {SYM("TRANSACTION", TRANSACTION_SYM)}, {SYM("TRIGGER", TRIGGER_SYM)}, {SYM("TRIGGERS", TRIGGERS_SYM)}, {SYM("TRUE", TRUE_SYM)}, {SYM("TRUNCATE", TRUNCATE_SYM)}, {SYM("TYPE", TYPE_SYM)}, {SYM("TYPES", TYPES_SYM)}, {SYM("UNBOUNDED", UNBOUNDED_SYM)}, {SYM("UNCOMMITTED", UNCOMMITTED_SYM)}, {SYM("UNDEFINED", UNDEFINED_SYM)}, {SYM("UNDO_BUFFER_SIZE", UNDO_BUFFER_SIZE_SYM)}, {SYM("UNDOFILE", UNDOFILE_SYM)}, {SYM("UNDO", UNDO_SYM)}, {SYM("UNICODE", UNICODE_SYM)}, {SYM("UNION", UNION_SYM)}, {SYM("UNIQUE", UNIQUE_SYM)}, {SYM("UNKNOWN", UNKNOWN_SYM)}, {SYM("UNLOCK", UNLOCK_SYM)}, {SYM("UNINSTALL", UNINSTALL_SYM)}, {SYM("UNREGISTER", UNREGISTER_SYM)}, {SYM("UNSIGNED", UNSIGNED_SYM)}, {SYM("UNTIL", UNTIL_SYM)}, {SYM("UPGRADE", UPGRADE_SYM)}, {SYM("URL", URL_SYM)}, {SYM("USAGE", USAGE)}, {SYM("USE", USE_SYM)}, {SYM("USER", USER)}, {SYM("USER_RESOURCES", RESOURCES)}, {SYM("USE_FRM", USE_FRM)}, {SYM("USING", USING)}, {SYM("UTC_DATE", UTC_DATE_SYM)}, {SYM("UTC_TIME", UTC_TIME_SYM)}, {SYM("UTC_TIMESTAMP", UTC_TIMESTAMP_SYM)}, {SYM("VALIDATION", VALIDATION_SYM)}, {SYM("VALUE", VALUE_SYM)}, {SYM("VALUES", VALUES)}, {SYM("VARBINARY", VARBINARY_SYM)}, {SYM("VARCHAR", VARCHAR_SYM)}, {SYM("VARCHARACTER", VARCHAR_SYM)}, {SYM("VARIABLES", VARIABLES)}, {SYM("VARYING", VARYING)}, {SYM("WAIT", WAIT_SYM)}, {SYM("WARNINGS", WARNINGS)}, {SYM("WEEK", WEEK_SYM)}, {SYM("WEIGHT_STRING", WEIGHT_STRING_SYM)}, {SYM("WHEN", WHEN_SYM)}, {SYM("WHERE", WHERE)}, {SYM("WHILE", WHILE_SYM)}, {SYM("WINDOW", WINDOW_SYM)}, {SYM("VCPU", VCPU_SYM)}, {SYM("VIEW", VIEW_SYM)}, {SYM("VIRTUAL", VIRTUAL_SYM)}, {SYM("VISIBLE", VISIBLE_SYM)}, {SYM("WITH", WITH)}, {SYM("WITHOUT", WITHOUT_SYM)}, {SYM("WORK", WORK_SYM)}, {SYM("WRAPPER", WRAPPER_SYM)}, {SYM("WRITE", WRITE_SYM)}, {SYM("X509", X509_SYM)}, {SYM("XOR", XOR)}, {SYM("XA", XA_SYM)}, {SYM("XID", XID_SYM)}, {SYM("XML", XML_SYM)}, /* LOAD XML Arnold/Erik */ {SYM("YEAR", YEAR_SYM)}, {SYM("YEAR_MONTH", YEAR_MONTH_SYM)}, {SYM("ZEROFILL", ZEROFILL_SYM)}, {SYM("ZONE", ZONE_SYM)}, {SYM("||", OR_OR_SYM)}, /* Place keywords that accept optimizer hints below this comment. */ {SYM_HK("DELETE", DELETE_SYM)}, {SYM_HK("INSERT", INSERT_SYM)}, {SYM_HK("REPLACE", REPLACE_SYM)}, {SYM_HK("SELECT", SELECT_SYM)}, {SYM_HK("UPDATE", UPDATE_SYM)}, /* Insert new function definitions after that commentary (by alphabetical order) */ {SYM_FN("ADDDATE", ADDDATE_SYM)}, {SYM_FN("BIT_AND", BIT_AND_SYM)}, {SYM_FN("BIT_OR", BIT_OR_SYM)}, {SYM_FN("BIT_XOR", BIT_XOR_SYM)}, {SYM_FN("CAST", CAST_SYM)}, {SYM_FN("COUNT", COUNT_SYM)}, {SYM_FN("CURDATE", CURDATE)}, {SYM_FN("CURTIME", CURTIME)}, {SYM_FN("DATE_ADD", DATE_ADD_INTERVAL)}, {SYM_FN("DATE_SUB", DATE_SUB_INTERVAL)}, {SYM_FN("EXTRACT", EXTRACT_SYM)}, {SYM_FN("GROUP_CONCAT", GROUP_CONCAT_SYM)}, {SYM_FN("JSON_OBJECTAGG", JSON_OBJECTAGG)}, {SYM_FN("JSON_ARRAYAGG", JSON_ARRAYAGG)}, {SYM_FN("MAX", MAX_SYM)}, {SYM_FN("MID", SUBSTRING)}, /* unireg function */ {SYM_FN("MIN", MIN_SYM)}, {SYM_FN("NOW", NOW_SYM)}, {SYM_FN("POSITION", POSITION_SYM)}, {SYM_FN("SESSION_USER", USER)}, {SYM_FN("STD", STD_SYM)}, {SYM_FN("STDDEV", STD_SYM)}, {SYM_FN("STDDEV_POP", STD_SYM)}, {SYM_FN("STDDEV_SAMP", STDDEV_SAMP_SYM)}, {SYM_FN("ST_COLLECT", ST_COLLECT_SYM)}, {SYM_FN("SUBDATE", SUBDATE_SYM)}, {SYM_FN("SUBSTR", SUBSTRING)}, {SYM_FN("SUBSTRING", SUBSTRING)}, {SYM_FN("SUM", SUM_SYM)}, {SYM_FN("SYSDATE", SYSDATE)}, {SYM_FN("SYSTEM_USER", USER)}, {SYM_FN("TRIM", TRIM)}, {SYM_FN("VARIANCE", VARIANCE_SYM)}, {SYM_FN("VAR_POP", VARIANCE_SYM)}, {SYM_FN("VAR_SAMP", VAR_SAMP_SYM)}, /* Insert new optimizer hint keywords after that commentary: */ {SYM_H("BKA", BKA_HINT)}, {SYM_H("BNL", BNL_HINT)}, {SYM_H("DUPSWEEDOUT", DUPSWEEDOUT_HINT)}, {SYM_H("FIRSTMATCH", FIRSTMATCH_HINT)}, {SYM_H("INTOEXISTS", INTOEXISTS_HINT)}, {SYM_H("LOOSESCAN", LOOSESCAN_HINT)}, {SYM_H("MATERIALIZATION", MATERIALIZATION_HINT)}, {SYM_H("MAX_EXECUTION_TIME", MAX_EXECUTION_TIME_HINT)}, {SYM_H("NO_BKA", NO_BKA_HINT)}, {SYM_H("NO_BNL", NO_BNL_HINT)}, {SYM_H("NO_ICP", NO_ICP_HINT)}, {SYM_H("NO_MRR", NO_MRR_HINT)}, {SYM_H("NO_RANGE_OPTIMIZATION", NO_RANGE_OPTIMIZATION_HINT)}, {SYM_H("NO_SEMIJOIN", NO_SEMIJOIN_HINT)}, {SYM_H("MRR", MRR_HINT)}, {SYM_H("QB_NAME", QB_NAME_HINT)}, {SYM_H("SEMIJOIN", SEMIJOIN_HINT)}, {SYM_H("SET_VAR", SET_VAR_HINT)}, {SYM_H("SUBQUERY", SUBQUERY_HINT)}, {SYM_H("MERGE", DERIVED_MERGE_HINT)}, {SYM_H("NO_MERGE", NO_DERIVED_MERGE_HINT)}, {SYM_H("JOIN_PREFIX", JOIN_PREFIX_HINT)}, {SYM_H("JOIN_SUFFIX", JOIN_SUFFIX_HINT)}, {SYM_H("JOIN_ORDER", JOIN_ORDER_HINT)}, {SYM_H("JOIN_FIXED_ORDER", JOIN_FIXED_ORDER_HINT)}, {SYM_H("INDEX_MERGE", INDEX_MERGE_HINT)}, {SYM_H("NO_INDEX_MERGE", NO_INDEX_MERGE_HINT)}, {SYM_H("RESOURCE_GROUP", RESOURCE_GROUP_HINT)}, {SYM_H("SKIP_SCAN", SKIP_SCAN_HINT)}, {SYM_H("NO_SKIP_SCAN", NO_SKIP_SCAN_HINT)}, {SYM_H("HASH_JOIN", HASH_JOIN_HINT)}, {SYM_H("NO_HASH_JOIN", NO_HASH_JOIN_HINT)}, {SYM_H("INDEX", INDEX_HINT)}, {SYM_H("NO_INDEX", NO_INDEX_HINT)}, {SYM_H("JOIN_INDEX", JOIN_INDEX_HINT)}, {SYM_H("NO_JOIN_INDEX", NO_JOIN_INDEX_HINT)}, {SYM_H("GROUP_INDEX", GROUP_INDEX_HINT)}, {SYM_H("NO_GROUP_INDEX", NO_GROUP_INDEX_HINT)}, {SYM_H("ORDER_INDEX", ORDER_INDEX_HINT)}, {SYM_H("NO_ORDER_INDEX", NO_ORDER_INDEX_HINT)}, {SYM_H("DERIVED_CONDITION_PUSHDOWN", DERIVED_CONDITION_PUSHDOWN_HINT)}, {SYM_H("NO_DERIVED_CONDITION_PUSHDOWN", NO_DERIVED_CONDITION_PUSHDOWN_HINT)}}; #endif /* LEX_INCLUDED */