Quelle  lex.h  Sprache: unbekannt

#ifndef LEX_INCLUDED
#define LEX_INCLUDED

/* Copyright (c) 2000, 2010, Oracle and/or its affiliates.
   Copyright (c) 2009, 2015, MariaDB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   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 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-1335  USA */


/* This file includes all reserved words and functions */

#include "lex_symbol.h"

SYM_GROUP sym_group_common= {"", ""};

/* We don't want to include sql_yacc.h into gen_lex_hash */
#ifdef NO_YACC_SYMBOLS
#define SYM_OR_NULL(A) 0
#else
#define SYM_OR_NULL(A) A
#endif

#define SYM(A) SYM_OR_NULL(A),0,&sym_group_common

/*
  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
  NOTE!!
  If you add or delete symbols from this file, you must also update results for
  the perfschema.start_server_low_digest_sql_length test!
*/

SYMBOL symbols[] = {
  { "&&",  SYM(AND_AND_SYM)},
  { "<=",  SYM(LE)},
  { "<>",  SYM(NE)},
  { "!=",  SYM(NE)},
  { ">=",  SYM(GE)},
  { "<<",  SYM(SHIFT_LEFT)},
  { ">>",  SYM(SHIFT_RIGHT)},
  { "<=>",  SYM(EQUAL_SYM)},
  { "=>",   SYM(ARROW_SYM)},
  { "ACCOUNT",  SYM(ACCOUNT_SYM)},
  { "ACTION",  SYM(ACTION)},
  { "ADD",  SYM(ADD)},
  { "ADMIN",            SYM(ADMIN_SYM)},
  { "AFTER",  SYM(AFTER_SYM)},
  { "AGAINST",          SYM(AGAINST)},
  { "AGGREGATE", SYM(AGGREGATE_SYM)},
  { "ALL",  SYM(ALL)},
  { "ALGORITHM", SYM(ALGORITHM_SYM)},
  { "ALTER",  SYM(ALTER)},
  { "ALWAYS",           SYM(ALWAYS_SYM)},
  { "ANALYZE",  SYM(ANALYZE_SYM)},
  { "AND",  SYM(AND_SYM)},
  { "ANY",              SYM(ANY_SYM)},
  { "ARRAY",  SYM(ARRAY_SYM)},
  { "AS",  SYM(AS)},
  { "ASC",  SYM(ASC)},
  { "ASCII",  SYM(ASCII_SYM)},
  { "ASENSITIVE",       SYM(ASENSITIVE_SYM)},
  { "AT",  SYM(AT_SYM)},
  { "ATOMIC",  SYM(ATOMIC_SYM)},
  { "AUTHORS",         SYM(AUTHORS_SYM)},
  { "AUTHORIZATION",    SYM(AUTHORIZATION_SYM)},
  { "AUTO",             SYM(AUTO_SYM)},
  { "AUTO_INCREMENT", SYM(AUTO_INC)},
  { "AVG",  SYM(AVG_SYM)},
  { "AVG_ROW_LENGTH", SYM(AVG_ROW_LENGTH)},
  { "BACKUP",         SYM(BACKUP_SYM)},
  { "BEFORE",         SYM(BEFORE_SYM)},
  { "BEGIN",         SYM(BEGIN_MARIADB_SYM)},
  { "BETWEEN",  SYM(BETWEEN_SYM)},
  { "BIGINT",  SYM(BIGINT)},
  { "BINARY",  SYM(BINARY)},
  { "BINLOG",  SYM(BINLOG_SYM)},
  { "BIT",  SYM(BIT_SYM)},
  { "BLOB",  SYM(BLOB_MARIADB_SYM)},
  { "BLOCK",  SYM(BLOCK_SYM)},
  { "BODY",             SYM(BODY_MARIADB_SYM)},
  { "BOOL",  SYM(BOOL_SYM)},
  { "BOOLEAN",  SYM(BOOLEAN_SYM)},
  { "BOTH",  SYM(BOTH)},
  { "BTREE",  SYM(BTREE_SYM)},
  { "BY",  SYM(BY)},
  { "BYTE",  SYM(BYTE_SYM)},
  { "CACHE",  SYM(CACHE_SYM)},
  { "CALL",             SYM(CALL_SYM)},
  { "CASCADE",  SYM(CASCADE)},
  { "CASCADED",         SYM(CASCADED)},
  { "CASE",  SYM(CASE_SYM)},
  { "CATALOG_NAME",     SYM(CATALOG_NAME_SYM)},
  { "CHAIN",  SYM(CHAIN_SYM)},
  { "CHANGE",  SYM(CHANGE)},
  { "CHANGED",  SYM(CHANGED)},
  { "CHANNEL",  SYM(CHANNEL_SYM)},
  { "CHAR",  SYM(CHAR_SYM)},
  { "CHARACTER", SYM(CHAR_SYM)},
  { "CHARSET",  SYM(CHARSET)},
  { "CHECK",  SYM(CHECK_SYM)},
  { "CHECKPOINT", SYM(CHECKPOINT_SYM)},
  { "CHECKSUM",  SYM(CHECKSUM_SYM)},
  { "CIPHER",  SYM(CIPHER_SYM)},
  { "CLASS_ORIGIN",     SYM(CLASS_ORIGIN_SYM)},
  { "CLIENT",  SYM(CLIENT_SYM)},
  { "CLOB",             SYM(CLOB_MARIADB_SYM)},
  { "CLOSE",  SYM(CLOSE_SYM)},
  { "COALESCE",  SYM(COALESCE)},
  { "CODE",             SYM(CODE_SYM)},
  { "COLLATE",  SYM(COLLATE_SYM)},
  { "COLLATION", SYM(COLLATION_SYM)},
  { "COLUMN",  SYM(COLUMN_SYM)},
  { "COLUMN_NAME",      SYM(COLUMN_NAME_SYM)},
  { "COLUMNS",  SYM(COLUMNS)},
  { "COLUMN_ADD",       SYM(COLUMN_ADD_SYM)},
  { "COLUMN_CHECK",     SYM(COLUMN_CHECK_SYM)},
  { "COLUMN_CREATE",    SYM(COLUMN_CREATE_SYM)},
  { "COLUMN_DELETE",    SYM(COLUMN_DELETE_SYM)},
  { "COLUMN_GET",       SYM(COLUMN_GET_SYM)},
  { "COMMENT",  SYM(COMMENT_SYM)},
  { "COMMIT",  SYM(COMMIT_SYM)},
  { "COMMITTED", SYM(COMMITTED_SYM)},
  { "COMPACT",  SYM(COMPACT_SYM)},
  { "COMPLETION", SYM(COMPLETION_SYM)},
  { "COMPRESSED", SYM(COMPRESSED_SYM)},
  { "CONCURRENT", SYM(CONCURRENT)},
  { "CONDITION",        SYM(CONDITION_SYM)},
  { "CONNECTION",       SYM(CONNECTION_SYM)},
  { "CONSISTENT", SYM(CONSISTENT_SYM)},
  { "CONSTRAINT", SYM(CONSTRAINT)},
  { "CONSTRAINT_CATALOG", SYM(CONSTRAINT_CATALOG_SYM)},
  { "CONSTRAINT_NAME",  SYM(CONSTRAINT_NAME_SYM)},
  { "CONSTRAINT_SCHEMA", SYM(CONSTRAINT_SCHEMA_SYM)},
  { "CONTAINS",         SYM(CONTAINS_SYM)},
  { "CONTEXT",    SYM(CONTEXT_SYM)},
  { "CONTINUE",         SYM(CONTINUE_MARIADB_SYM)},
  { "CONTRIBUTORS",     SYM(CONTRIBUTORS_SYM)},
  { "CONVERSION",       SYM(CONVERSION_SYM)},
  { "CONVERT",  SYM(CONVERT_SYM)},
  { "CPU",              SYM(CPU_SYM)},
  { "CREATE",  SYM(CREATE)},
  { "CROSS",  SYM(CROSS)},
  { "CUBE",  SYM(CUBE_SYM)},
  { "CURRENT",          SYM(CURRENT_SYM)},
  { "CURRENT_DATE", SYM(CURDATE)},
  { "CURRENT_PATH", SYM(CURRENT_PATH)},
  { "CURRENT_POS",      SYM(CURRENT_POS_SYM)},
  { "CURRENT_ROLE", SYM(CURRENT_ROLE)},
  { "CURRENT_TIME", SYM(CURTIME)},
  { "CURRENT_TIMESTAMP", SYM(NOW_SYM)},
  { "CURRENT_USER", SYM(CURRENT_USER)},
  { "CURSOR",           SYM(CURSOR_SYM)},
  { "CURSOR_NAME",      SYM(CURSOR_NAME_SYM)},
  { "CYCLE",            SYM(CYCLE_SYM)},
  { "DATA",  SYM(DATA_SYM)},
  { "DATABASE",  SYM(DATABASE)},
  { "DATABASES", SYM(DATABASES)},
  { "DATE",  SYM(DATE_SYM)},
  { "DATETIME",  SYM(DATETIME)},
  { "DAY",  SYM(DAY_SYM)},
  { "DAY_HOUR",  SYM(DAY_HOUR_SYM)},
  { "DAY_MICROSECOND", SYM(DAY_MICROSECOND_SYM)},
  { "DAY_MINUTE", SYM(DAY_MINUTE_SYM)},
  { "DAY_SECOND", SYM(DAY_SECOND_SYM)},
  { "DEALLOCATE",       SYM(DEALLOCATE_SYM)},
  { "DEC",  SYM(DECIMAL_SYM)},
  { "DECIMAL",  SYM(DECIMAL_SYM)},
  { "DECLARE",          SYM(DECLARE_MARIADB_SYM)},
  { "DEFAULT",  SYM(DEFAULT)},
  { "DEFINER",          SYM(DEFINER_SYM)},
  { "DELAYED",  SYM(DELAYED_SYM)},
  { "DELAY_KEY_WRITE", SYM(DELAY_KEY_WRITE_SYM)},
  { "DELETE",  SYM(DELETE_SYM)},
  { "DELETE_DOMAIN_ID", SYM(DELETE_DOMAIN_ID_SYM)},
  { "DENY",             SYM(DENY)},
  { "DESC",  SYM(DESC)},
  { "DESCRIBE",  SYM(DESCRIBE)},
  { "DETERMINISTIC",    SYM(DETERMINISTIC_SYM)},
  { "DIAGNOSTICS",      SYM(DIAGNOSTICS_SYM)},
  { "DIRECTORY", SYM(DIRECTORY_SYM)},
  { "DISABLE",  SYM(DISABLE_SYM)},
  { "DISCARD",  SYM(DISCARD)},
  { "DISK",  SYM(DISK_SYM)},
  { "DISTINCT",  SYM(DISTINCT)},
  { "DISTINCTROW", SYM(DISTINCT)}, /* Access likes this */
  { "DIV",  SYM(DIV_SYM)},
  { "DO",  SYM(DO_SYM)},
  { "DOUBLE",  SYM(DOUBLE_SYM)},
  { "DO_DOMAIN_IDS",    SYM(DO_DOMAIN_IDS_SYM)},
  { "DROP",  SYM(DROP)},
  { "DUAL",  SYM(DUAL_SYM)},
  { "DUMPFILE",  SYM(DUMPFILE)},
  { "DUPLICATE", SYM(DUPLICATE_SYM)},
  { "DYNAMIC",  SYM(DYNAMIC_SYM)},
  { "EACH",             SYM(EACH_SYM)},
  { "ELSE",             SYM(ELSE)},
  { "ELSEIF",           SYM(ELSEIF_MARIADB_SYM)},
  { "ELSIF",            SYM(ELSIF_MARIADB_SYM)},
  { "EMPTY",  SYM(EMPTY_SYM)},
  { "ENABLE",  SYM(ENABLE_SYM)},
  { "ENCLOSED",  SYM(ENCLOSED)},
  { "END",  SYM(END)},
  { "ENDS",  SYM(ENDS_SYM)},
  { "ENGINE",  SYM(ENGINE_SYM)},
  { "ENGINES",  SYM(ENGINES_SYM)},
  { "ENUM",  SYM(ENUM)},
  { "ERROR",            SYM(ERROR_SYM)},
  { "ERRORS",  SYM(ERRORS)},
  { "ESCAPE",  SYM(ESCAPE_SYM)},
  { "ESCAPED",  SYM(ESCAPED)},
  { "EVENT",  SYM(EVENT_SYM)},
  { "EVENTS",  SYM(EVENTS_SYM)},
  { "EVERY",  SYM(EVERY_SYM)},
  { "EXAMINED",         SYM(EXAMINED_SYM)},
  { "EXCEPT",           SYM(EXCEPT_SYM)},
  { "EXCHANGE",         SYM(EXCHANGE_SYM)},
  { "EXCLUDE",          SYM(EXCLUDE_SYM)},
  { "EXECUTE",  SYM(EXECUTE_SYM)},
  { "EXCEPTION", SYM(EXCEPTION_MARIADB_SYM)},
  { "EXISTS",  SYM(EXISTS)},
  { "EXIT",             SYM(EXIT_MARIADB_SYM)},
  { "EXPANSION", SYM(EXPANSION_SYM)},
  { "EXPIRE",  SYM(EXPIRE_SYM)},
  { "EXPORT",           SYM(EXPORT_SYM)},
  { "EXPLAIN",  SYM(DESCRIBE)},
  { "EXTENDED",  SYM(EXTENDED_SYM)},
  { "EXTENT_SIZE", SYM(EXTENT_SIZE_SYM)},
  { "FALSE",  SYM(FALSE_SYM)},
  { "FAST",  SYM(FAST_SYM)},
  { "FAULTS",  SYM(FAULTS_SYM)},
  { "FEDERATED", SYM(FEDERATED_SYM)},
  { "FETCH",            SYM(FETCH_SYM)},
  { "FIELDS",  SYM(COLUMNS)},
  { "FILE",  SYM(FILE_SYM)},
  { "FILTER",  SYM(FILTER_SYM)},
  { "FIRST",  SYM(FIRST_SYM)},
  { "FIXED",  SYM(FIXED_SYM)},
  { "FLOAT",  SYM(FLOAT_SYM)},
  { "FLOAT4",  SYM(FLOAT_SYM)},
  { "FLOAT8",  SYM(DOUBLE_SYM)},
  { "FLUSH",  SYM(FLUSH_SYM)},
  { "FOLLOWING",        SYM(FOLLOWING_SYM)},
  { "FOLLOWS",          SYM(FOLLOWS_SYM)},
  { "FOR",  SYM(FOR_SYM)},
  { "FORCE",  SYM(FORCE_SYM)},
  { "FOREIGN",  SYM(FOREIGN)},
  { "FORMAT",  SYM(FORMAT_SYM)},
  { "FOUND",            SYM(FOUND_SYM)},
  { "FROM",  SYM(FROM)},
  { "FULL",  SYM(FULL)},
  { "FULLTEXT",  SYM(FULLTEXT_SYM)},
  { "FUNCTION",  SYM(FUNCTION_SYM)},
  { "GENERAL",          SYM(GENERAL)},
  { "GENERATED",        SYM(GENERATED_SYM)},
  { "GET_FORMAT",       SYM(GET_FORMAT)},
  { "GET",              SYM(GET_SYM)},
  { "GLOBAL",  SYM(GLOBAL_SYM)},
  { "GOTO",             SYM(GOTO_MARIADB_SYM)},
  { "GRANT",  SYM(GRANT)},
  { "GRANTS",         SYM(GRANTS)},
  { "GROUP",  SYM(GROUP_SYM)},
  { "HANDLER",  SYM(HANDLER_SYM)},
  { "HARD",  SYM(HARD_SYM)},
  { "HASH",  SYM(HASH_SYM)},
  { "HAVING",  SYM(HAVING)},
  { "HELP",  SYM(HELP_SYM)},
  { "HIGH_PRIORITY", SYM(HIGH_PRIORITY)},
  { "HISTORY",       SYM(HISTORY_SYM)},
  { "HOSTS",  SYM(HOSTS_SYM)},
  { "HOUR",  SYM(HOUR_SYM)},
  { "HOUR_MICROSECOND", SYM(HOUR_MICROSECOND_SYM)},
  { "HOUR_MINUTE", SYM(HOUR_MINUTE_SYM)},
  { "HOUR_SECOND", SYM(HOUR_SECOND_SYM)},
  { "ID",               SYM(ID_SYM)},
  { "IDENTIFIED", SYM(IDENTIFIED_SYM)},
  { "IF",  SYM(IF_SYM)},
  { "IGNORE",  SYM(IGNORE_SYM)},
  { "IGNORED",  SYM(IGNORED_SYM)},
  { "IGNORE_DOMAIN_IDS", SYM(IGNORE_DOMAIN_IDS_SYM)},
  { "IGNORE_SERVER_IDS", SYM(IGNORE_SERVER_IDS_SYM)},
  { "IMMEDIATE", SYM(IMMEDIATE_SYM)},
  { "IMPORT",  SYM(IMPORT)},
  { "INTERSECT",        SYM(INTERSECT_SYM)},
  { "IN",  SYM(IN_SYM)},
  { "INCREMENT",        SYM(INCREMENT_SYM)},
  { "INDEX",  SYM(INDEX_SYM)},
  { "INDEXES",  SYM(INDEXES)},
  { "INFILE",  SYM(INFILE)},
  { "INNER",  SYM(INNER_SYM)},
  { "INOUT",            SYM(INOUT_SYM)},
  { "INSENSITIVE",      SYM(INSENSITIVE_SYM)},
  { "INSERT",  SYM(INSERT)},
  { "INSERT_METHOD",    SYM(INSERT_METHOD)},
  { "INSTALL",          SYM(INSTALL_SYM)},
  { "INT",  SYM(INT_SYM)},
  { "INT1",  SYM(TINYINT)},
  { "INT2",  SYM(SMALLINT)},
  { "INT3",  SYM(MEDIUMINT)},
  { "INT4",  SYM(INT_SYM)},
  { "INT8",  SYM(BIGINT)},
  { "INTEGER",  SYM(INT_SYM)},
  { "INTERVAL",  SYM(INTERVAL_SYM)},
  { "INVISIBLE",        SYM(INVISIBLE_SYM)},
  { "INTO",  SYM(INTO)},
  { "IO",     SYM(IO_SYM)},
  { "IO_THREAD",        SYM(RELAY_THREAD)},
  { "IPC",    SYM(IPC_SYM)},
  { "IS",  SYM(IS)},
  { "ISOLATION", SYM(ISOLATION)},
  { "ISOPEN",           SYM(ISOPEN_SYM)},
  { "ISSUER",  SYM(ISSUER_SYM)},
  { "ITERATE",          SYM(ITERATE_SYM)},
  { "INVOKER",          SYM(INVOKER_SYM)},
  { "JOIN",  SYM(JOIN_SYM)},
  { "JSON",  SYM(JSON_SYM)},
  { "JSON_TABLE", SYM(JSON_TABLE_SYM)},
  { "KEY",  SYM(KEY_SYM)},
  { "KEYS",  SYM(KEYS)},
  { "KEY_BLOCK_SIZE", SYM(KEY_BLOCK_SIZE)},
  { "KILL",  SYM(KILL_SYM)},
  { "LANGUAGE",         SYM(LANGUAGE_SYM)},
  { "LAST",  SYM(LAST_SYM)},
  { "LAST_VALUE", SYM(LAST_VALUE)},
  { "LASTVAL",  SYM(LASTVAL_SYM)},
  { "LEADING",  SYM(LEADING)},
  { "LEAVE",            SYM(LEAVE_SYM)},
  { "LEAVES",  SYM(LEAVES)},
  { "LEFT",  SYM(LEFT)},
  { "LESS",             SYM(LESS_SYM)},
  { "LEVEL",  SYM(LEVEL_SYM)},
  { "LIKE",  SYM(LIKE)},
  { "LIMIT",  SYM(LIMIT)},
  { "LINEAR",  SYM(LINEAR_SYM)},
  { "LINES",  SYM(LINES)},
  { "LIST",             SYM(LIST_SYM)},
  { "LOAD",  SYM(LOAD)},
  { "LOCAL",  SYM(LOCAL_SYM)},
  { "LOCALTIME", SYM(CURTIME)},
  { "LOCALTIMESTAMP", SYM(LOCALTIMESTAMP)},
  { "LOCK",  SYM(LOCK_SYM)},
  { "LOCKED",  SYM(LOCKED_SYM)},
  { "LOCKS",  SYM(LOCKS_SYM)},
  { "LOG",  SYM(LOG_SYM)},
  { "LOGS",  SYM(LOGS_SYM)},
  { "LONG",  SYM(LONG_SYM)},
  { "LONGBLOB",  SYM(LONGBLOB)},
  { "LONGTEXT",  SYM(LONGTEXT)},
  { "LOOP",             SYM(LOOP_SYM)},
  { "LOW_PRIORITY", SYM(LOW_PRIORITY)},
  { "MASTER",           SYM(MASTER_SYM)},
  { "MASTER_CONNECT_RETRY",           SYM(MASTER_CONNECT_RETRY_SYM)},
  { "MASTER_DELAY",     SYM(MASTER_DELAY_SYM)},
  { "MASTER_GTID_POS",  SYM(MASTER_GTID_POS_SYM)},
  { "MASTER_HOST",           SYM(MASTER_HOST_SYM)},
  { "MASTER_LOG_FILE",           SYM(MASTER_LOG_FILE_SYM)},
  { "MASTER_LOG_POS",           SYM(MASTER_LOG_POS_SYM)},
  { "MASTER_PASSWORD",           SYM(MASTER_PASSWORD_SYM)},
  { "MASTER_PORT",           SYM(MASTER_PORT_SYM)},
  { "MASTER_RETRY_COUNT", SYM(MASTER_RETRY_COUNT_SYM)},
  { "MASTER_SERVER_ID",           SYM(MASTER_SERVER_ID_SYM)},
  { "MASTER_SSL",       SYM(MASTER_SSL_SYM)},
  { "MASTER_SSL_CA",    SYM(MASTER_SSL_CA_SYM)},
  { "MASTER_SSL_CAPATH",SYM(MASTER_SSL_CAPATH_SYM)},
  { "MASTER_SSL_CERT",  SYM(MASTER_SSL_CERT_SYM)},
  { "MASTER_SSL_CIPHER",SYM(MASTER_SSL_CIPHER_SYM)},
  { "MASTER_SSL_CRL",   SYM(MASTER_SSL_CRL_SYM)},
  { "MASTER_SSL_CRLPATH",SYM(MASTER_SSL_CRLPATH_SYM)},
  { "MASTER_SSL_KEY",   SYM(MASTER_SSL_KEY_SYM)},
  { "MASTER_SSL_VERIFY_SERVER_CERT", SYM(MASTER_SSL_VERIFY_SERVER_CERT_SYM)},
  { "MASTER_USER",           SYM(MASTER_USER_SYM)},
  { "MASTER_USE_GTID",  SYM(MASTER_USE_GTID_SYM)},
  { "MASTER_DEMOTE_TO_REPLICA",  SYM(MASTER_DEMOTE_TO_SLAVE_SYM)},
  { "MASTER_DEMOTE_TO_SLAVE",  SYM(MASTER_DEMOTE_TO_SLAVE_SYM)},
  { "MASTER_HEARTBEAT_PERIOD", SYM(MASTER_HEARTBEAT_PERIOD_SYM)},
  { "MATCH",  SYM(MATCH)},
  { "MAX_CONNECTIONS_PER_HOUR", SYM(MAX_CONNECTIONS_PER_HOUR)},
  { "MAX_QUERIES_PER_HOUR", SYM(MAX_QUERIES_PER_HOUR)},
  { "MAX_ROWS",  SYM(MAX_ROWS)},
  { "MAX_STATEMENT_TIME",   SYM(MAX_STATEMENT_TIME_SYM)},
  { "MAX_UPDATES_PER_HOUR", SYM(MAX_UPDATES_PER_HOUR)},
  { "MAX_USER_CONNECTIONS", SYM(MAX_USER_CONNECTIONS_SYM)},
  { "MAXVALUE",         SYM(MAXVALUE_SYM)},
  { "MEDIUM",  SYM(MEDIUM_SYM)},
  { "MEDIUMBLOB", SYM(MEDIUMBLOB)},
  { "MEDIUMINT", SYM(MEDIUMINT)},
  { "MEDIUMTEXT", SYM(MEDIUMTEXT)},
  { "MEMORY",  SYM(MEMORY_SYM)},
  { "MERGE",  SYM(MERGE_SYM)},
  { "MESSAGE_TEXT",     SYM(MESSAGE_TEXT_SYM)},
  { "MICROSECOND", SYM(MICROSECOND_SYM)},
  { "MIDDLEINT", SYM(MEDIUMINT)}, /* For powerbuilder */
  { "MIGRATE",          SYM(MIGRATE_SYM)},
  { "MINUS",            SYM(MINUS_ORACLE_SYM)},
  { "MINUTE",  SYM(MINUTE_SYM)},
  { "MINUTE_MICROSECOND", SYM(MINUTE_MICROSECOND_SYM)},
  { "MINUTE_SECOND", SYM(MINUTE_SECOND_SYM)},
  { "MINVALUE",  SYM(MINVALUE_SYM)},
  { "MIN_ROWS",  SYM(MIN_ROWS)},
  { "MOD",  SYM(MOD_SYM)},
  { "MODE",  SYM(MODE_SYM)},
  { "MODIFIES",  SYM(MODIFIES_SYM)},
  { "MODIFY",  SYM(MODIFY_SYM)},
  { "MONITOR",          SYM(MONITOR_SYM)},
  { "MONTH",  SYM(MONTH_SYM)},
  { "MUTEX",  SYM(MUTEX_SYM)},
  { "MYSQL",            SYM(MYSQL_SYM)},
  { "MYSQL_ERRNO",      SYM(MYSQL_ERRNO_SYM)},
  { "NAME",             SYM(NAME_SYM)},
  { "NAMES",  SYM(NAMES_SYM)},
  { "NATIONAL",  SYM(NATIONAL_SYM)},
  { "NATURAL",  SYM(NATURAL)},
  { "NCHAR",  SYM(NCHAR_SYM)},
  { "NESTED",  SYM(NESTED_SYM)},
  { "NEVER",  SYM(NEVER_SYM)},
  { "NEXT",  SYM(NEXT_SYM)},
  { "NEXTVAL",  SYM(NEXTVAL_SYM)},
  { "NO",  SYM(NO_SYM)},
  { "NOCOPY",  SYM(NOCOPY_SYM)},
  { "NOMAXVALUE", SYM(NOMAXVALUE_SYM)},
  { "NOMINVALUE", SYM(NOMINVALUE_SYM)},
  { "NOCACHE",          SYM(NOCACHE_SYM)},
  { "NOCYCLE",          SYM(NOCYCLE_SYM)},
  { "NOWAIT",  SYM(NOWAIT_SYM)},
  { "NODEGROUP", SYM(NODEGROUP_SYM)},
  { "NONE",  SYM(NONE_SYM)},
  { "NOT",  SYM(NOT_SYM)},
  { "NOTFOUND",         SYM(NOTFOUND_SYM)},
  { "NO_WRITE_TO_BINLOG",  SYM(NO_WRITE_TO_BINLOG)},
  { "NULL",  SYM(NULL_SYM)},
  { "NUMBER",           SYM(NUMBER_MARIADB_SYM)},
  { "NUMERIC",  SYM(NUMERIC_SYM)},
  { "NVARCHAR",  SYM(NVARCHAR_SYM)},
  { "OBJECT",  SYM(OBJECT_SYM)},
  { "OF",  SYM(OF_SYM)},
  { "OFFSET",  SYM(OFFSET_SYM)},
  { "OLD_PASSWORD", SYM(OLD_PASSWORD_SYM)},
  { "OLD_VALUE", SYM(OLD_VALUE_SYM)},
  { "ON",  SYM(ON)},
  { "ONE",              SYM(ONE_SYM)},
  { "ONLINE",  SYM(ONLINE_SYM)},
  { "ONLY",             SYM(ONLY_SYM)},
  { "OPEN",  SYM(OPEN_SYM)},
  { "OPTIMIZE",  SYM(OPTIMIZE)},
  { "OPTIONS",  SYM(OPTIONS_SYM)},
  { "OPTION",  SYM(OPTION)},
  { "OPTIONALLY", SYM(OPTIONALLY)},
  { "OR",  SYM(OR_SYM)},
  { "ORDER",  SYM(ORDER_SYM)},
  { "ORDINALITY", SYM(ORDINALITY_SYM)},
  { "OTHERS",           SYM(OTHERS_MARIADB_SYM)},
  { "OUT",              SYM(OUT_SYM)},
  { "OUTER",  SYM(OUTER)},
  { "OUTFILE",  SYM(OUTFILE)},
  { "OVER",             SYM(OVER_SYM)},
  { "OVERLAPS",         SYM(OVERLAPS_SYM)},
  { "PACKAGE",          SYM(PACKAGE_MARIADB_SYM)},
  { "PACK_KEYS", SYM(PACK_KEYS_SYM)},
  { "PAGE",         SYM(PAGE_SYM)},
  { "PAGE_CHECKSUM", SYM(PAGE_CHECKSUM_SYM)},
  { "PARSER",           SYM(PARSER_SYM)},
  { "PARSE_VCOL_EXPR",  SYM(PARSE_VCOL_EXPR_SYM)},
  { "PATH",  SYM(PATH_SYM)},
  { "PERIOD",  SYM(PERIOD_SYM)},
  { "PARTIAL",  SYM(PARTIAL)},
  { "PARTITION",        SYM(PARTITION_SYM)},
  { "PARTITIONING",     SYM(PARTITIONING_SYM)},
  { "PARTITIONS",       SYM(PARTITIONS_SYM)},
  { "PASSWORD",  SYM(PASSWORD_SYM)},
  { "PERSISTENT", SYM(PERSISTENT_SYM)},
  { "PHASE",            SYM(PHASE_SYM)},
  { "PLUGIN",           SYM(PLUGIN_SYM)},
  { "PLUGINS",          SYM(PLUGINS_SYM)},
  { "PORT",  SYM(PORT_SYM)},
  { "PORTION",  SYM(PORTION_SYM)},
  { "PRECEDES",         SYM(PRECEDES_SYM)},
  { "PRECEDING",        SYM(PRECEDING_SYM)},
  { "PRECISION", SYM(PRECISION)},
  { "PREPARE",          SYM(PREPARE_SYM)},
  { "PRESERVE",  SYM(PRESERVE_SYM)},
  { "PREV",  SYM(PREV_SYM)},
  { "PREVIOUS",  SYM(PREVIOUS_SYM)},
  { "PRIMARY",  SYM(PRIMARY_SYM)},
  { "PRIVILEGES", SYM(PRIVILEGES)},
  { "PROCEDURE", SYM(PROCEDURE_SYM)},
  { "PROCESS" , SYM(PROCESS)},
  { "PROCESSLIST", SYM(PROCESSLIST_SYM)},
  { "PROFILE",          SYM(PROFILE_SYM)},
  { "PROFILES",         SYM(PROFILES_SYM)},
  { "PROXY",            SYM(PROXY_SYM)},
  { "PURGE",  SYM(PURGE)},
  { "QUARTER",          SYM(QUARTER_SYM)},
  { "QUERY",  SYM(QUERY_SYM)},
  { "QUICK",         SYM(QUICK)},
  { "RAISE",            SYM(RAISE_MARIADB_SYM)},
  { "RANGE",            SYM(RANGE_SYM)},
  { "RAW",              SYM(RAW_MARIADB_SYM)},
  { "READ",  SYM(READ_SYM)},
  { "READ_ONLY", SYM(READ_ONLY_SYM)},
  { "READ_WRITE", SYM(READ_WRITE_SYM)},
  { "READS",  SYM(READS_SYM)},
  { "REAL",  SYM(REAL)},
  { "REBUILD",  SYM(REBUILD_SYM)},
  { "RECORD",           SYM(RECORD_SYM)},
  { "RECOVER",          SYM(RECOVER_SYM)},
  { "RECURSIVE",        SYM(RECURSIVE_SYM)},
  { "REDUNDANT", SYM(REDUNDANT_SYM)},
  { "REF",  SYM(REF_SYM)},
  { "REFERENCES", SYM(REFERENCES)},
  { "REGEXP",  SYM(REGEXP)},
  { "RELAY",            SYM(RELAY)},
  { "RELAYLOG",         SYM(RELAYLOG_SYM)},
  { "RELAY_LOG_FILE",   SYM(RELAY_LOG_FILE_SYM)},
  { "RELAY_LOG_POS",    SYM(RELAY_LOG_POS_SYM)},
  { "RELAY_THREAD",     SYM(RELAY_THREAD)},
  { "RELEASE",  SYM(RELEASE_SYM)},
  { "RELOAD",  SYM(RELOAD)},
  { "REMOVE",  SYM(REMOVE_SYM)},
  { "RENAME",  SYM(RENAME)},
  { "REORGANIZE", SYM(REORGANIZE_SYM)},
  { "REPAIR",  SYM(REPAIR)},
  { "REPEATABLE", SYM(REPEATABLE_SYM)},
  { "REPLACE",  SYM(REPLACE)},
  { "REPLAY",           SYM(REPLAY_SYM)},
  { "REPLICA",      SYM(SLAVE)},
  { "REPLICAS",     SYM(SLAVES)},
  { "REPLICA_POS",  SYM(SLAVE_POS_SYM)},
  { "REPLICATION", SYM(REPLICATION)},
  { "REPEAT",           SYM(REPEAT_SYM)},
  { "REQUIRE",         SYM(REQUIRE_SYM)},
  { "RESET",  SYM(RESET_SYM)},
  { "RESIGNAL",         SYM(RESIGNAL_SYM)},
  { "RESTART",  SYM(RESTART_SYM)},
  { "RESTRICT",  SYM(RESTRICT)},
  { "RESUME",           SYM(RESUME_SYM)},
  { "RETURNED_SQLSTATE",SYM(RETURNED_SQLSTATE_SYM)},
  { "RETURN",           SYM(RETURN_MARIADB_SYM)},
  { "RETURNING",        SYM(RETURNING_SYM)},
  { "RETURNS",  SYM(RETURNS_SYM)},
  { "REUSE",            SYM(REUSE_SYM)},
  { "REVERSE",  SYM(REVERSE_SYM)},
  { "REVOKE",  SYM(REVOKE)},
  { "RIGHT",  SYM(RIGHT)},
  { "RLIKE",  SYM(REGEXP)}, /* Like in mSQL2 */
  { "ROLE",             SYM(ROLE_SYM)},
  { "ROLLBACK",  SYM(ROLLBACK_SYM)},
  { "ROLLUP",  SYM(ROLLUP_SYM)},
  { "ROUTINE",  SYM(ROUTINE_SYM)},
  { "ROW",  SYM(ROW_SYM)},
  { "ROWCOUNT",         SYM(ROWCOUNT_SYM)}, /* Oracle-N */
  { "ROWNUM",           SYM(ROWNUM_SYM)}, /* Oracle-R */
  { "ROWS",  SYM(ROWS_SYM)},
  { "ROWTYPE",          SYM(ROWTYPE_MARIADB_SYM)},
  { "ROW_COUNT",        SYM(ROW_COUNT_SYM)},
  { "ROW_FORMAT", SYM(ROW_FORMAT_SYM)},
  /** sql_function and condition_property_name for GET DIAGNOSTICS */
  { "ROW_NUMBER", SYM(ROW_NUMBER_SYM)},
  { "RTREE",  SYM(RTREE_SYM)},
  { "SAVEPOINT", SYM(SAVEPOINT_SYM)},
  { "SCALAR",  SYM(SCALAR_SYM)},
  { "SCHEDULE",  SYM(SCHEDULE_SYM)},
  { "SCHEMA",  SYM(DATABASE)},
  { "SCHEMA_NAME",      SYM(SCHEMA_NAME_SYM)},
  { "SCHEMAS",          SYM(DATABASES)},
  { "SECOND",  SYM(SECOND_SYM)},
  { "SECOND_MICROSECOND", SYM(SECOND_MICROSECOND_SYM)},
  { "SECURITY",         SYM(SECURITY_SYM)},
  { "SELECT",  SYM(SELECT_SYM)},
  { "SENSITIVE",        SYM(SENSITIVE_SYM)},
  { "SEPARATOR", SYM(SEPARATOR_SYM)},
  { "SEQUENCE",  SYM(SEQUENCE_SYM)},
  { "SERIAL",  SYM(SERIAL_SYM)},
  { "SERIALIZABLE", SYM(SERIALIZABLE_SYM)},
  { "SESSION",  SYM(SESSION_SYM)},
  { "SERVER",           SYM(SERVER_SYM)},
  { "SET",  SYM(SET)},
  { "SETVAL",  SYM(SETVAL_SYM)},
  { "SHARE",  SYM(SHARE_SYM)},
  { "SHOW",  SYM(SHOW)},
  { "SHUTDOWN",  SYM(SHUTDOWN)},
  { "SIGNAL",           SYM(SIGNAL_SYM)},
  { "SIGNED",  SYM(SIGNED_SYM)},
  { "SIMPLE",  SYM(SIMPLE_SYM)},
  { "SKIP",             SYM(SKIP_SYM)},
  { "SLAVE",            SYM(SLAVE)},
  { "SLAVES",           SYM(SLAVES)},
  { "SLAVE_POS",        SYM(SLAVE_POS_SYM)},
  { "SLOW",             SYM(SLOW)},
  { "SNAPSHOT",         SYM(SNAPSHOT_SYM)},
  { "SMALLINT",  SYM(SMALLINT)},
  { "SOFT",             SYM(SOFT_SYM)},
  { "SOME",             SYM(ANY_SYM)},
  { "SONAME",  SYM(SONAME_SYM)},
  { "SOUNDS",  SYM(SOUNDS_SYM)},
  { "SOURCE",           SYM(SOURCE_SYM)},
  { "STAGE",            SYM(STAGE_SYM)},
  { "STORED",           SYM(STORED_SYM)},
  { "SPATIAL",  SYM(SPATIAL_SYM)},
  { "SPECIFIC",         SYM(SPECIFIC_SYM)},
  { "REF_SYSTEM_ID",    SYM(REF_SYSTEM_ID_SYM)},
  { "SQL",              SYM(SQL_SYM)},
  { "SQLEXCEPTION",     SYM(SQLEXCEPTION_SYM)},
  { "SQLSTATE",         SYM(SQLSTATE_SYM)},
  { "SQLWARNING",       SYM(SQLWARNING_SYM)},
  { "SQL_AFTER_GTIDS",  SYM(SQL_AFTER_GTIDS_SYM)},
  { "SQL_BEFORE_GTIDS",  SYM(SQL_BEFORE_GTIDS_SYM)},
  { "SQL_BIG_RESULT", SYM(SQL_BIG_RESULT)},
  { "SQL_BUFFER_RESULT", SYM(SQL_BUFFER_RESULT)},
  { "SQL_CACHE",        SYM(SQL_CACHE_SYM)},
  { "SQL_CALC_FOUND_ROWS", SYM(SQL_CALC_FOUND_ROWS)},
  { "SQL_NO_CACHE", SYM(SQL_NO_CACHE_SYM)},
  { "SQL_SMALL_RESULT", SYM(SQL_SMALL_RESULT)},
  { "SQL_THREAD", SYM(SQL_THREAD)},
  { "SQL_TSI_SECOND",   SYM(SECOND_SYM)},
  { "SQL_TSI_MINUTE",   SYM(MINUTE_SYM)},
  { "SQL_TSI_HOUR",     SYM(HOUR_SYM)},
  { "SQL_TSI_DAY",      SYM(DAY_SYM)},
  { "SQL_TSI_WEEK",     SYM(WEEK_SYM)},
  { "SQL_TSI_MONTH",    SYM(MONTH_SYM)},
  { "SQL_TSI_QUARTER",  SYM(QUARTER_SYM)},
  { "SQL_TSI_YEAR",     SYM(YEAR_SYM)},
  { "SSL",  SYM(SSL_SYM)},
  { "START",  SYM(START_SYM)},
  { "STARTING",  SYM(STARTING)},
  { "STARTS",  SYM(STARTS_SYM)},
  { "STATEMENT", SYM(STATEMENT_SYM)},
  { "STATS_AUTO_RECALC",SYM(STATS_AUTO_RECALC_SYM)},
  { "STATS_PERSISTENT", SYM(STATS_PERSISTENT_SYM)},
  { "STATS_SAMPLE_PAGES",SYM(STATS_SAMPLE_PAGES_SYM)},
  { "STATUS",  SYM(STATUS_SYM)},
  { "STOP",  SYM(STOP_SYM)},
  { "STORAGE",  SYM(STORAGE_SYM)},
  { "STRAIGHT_JOIN", SYM(STRAIGHT_JOIN)},
  { "STRING",  SYM(STRING_SYM)},
  { "SUBCLASS_ORIGIN",  SYM(SUBCLASS_ORIGIN_SYM)},
  { "SUBJECT",  SYM(SUBJECT_SYM)},
  { "SUBPARTITION",     SYM(SUBPARTITION_SYM)},
  { "SUBPARTITIONS",    SYM(SUBPARTITIONS_SYM)},
  { "SUPER",  SYM(SUPER_SYM)},
  { "SUSPEND",          SYM(SUSPEND_SYM)},
  { "SWAPS",      SYM(SWAPS_SYM)},
  { "SWITCHES",   SYM(SWITCHES_SYM)},
  { "SYSDATE",  SYM(SYSDATE)},
  { "SYSTEM",     SYM(SYSTEM)},
  { "SYSTEM_TIME",      SYM(SYSTEM_TIME_SYM)},
  { "TABLE",  SYM(TABLE_SYM)},
  { "TABLE_NAME",       SYM(TABLE_NAME_SYM)},
  { "TABLES",  SYM(TABLES)},
  { "TABLESPACE",         SYM(TABLESPACE)},
  { "TABLE_CHECKSUM", SYM(TABLE_CHECKSUM_SYM)},
  { "TEMPORARY", SYM(TEMPORARY)},
  { "TEMPTABLE", SYM(TEMPTABLE_SYM)},
  { "TERMINATED", SYM(TERMINATED)},
  { "TEXT",  SYM(TEXT_SYM)},
  { "THAN",             SYM(THAN_SYM)},
  { "THEN",  SYM(THEN_SYM)},
  { "TIES",             SYM(TIES_SYM)},
  { "TIME",  SYM(TIME_SYM)},
  { "TIMESTAMP", SYM(TIMESTAMP)},
  { "TIMESTAMPADD",     SYM(TIMESTAMP_ADD)},
  { "TIMESTAMPDIFF",    SYM(TIMESTAMP_DIFF)},
  { "TINYBLOB",  SYM(TINYBLOB)},
  { "TINYINT",  SYM(TINYINT)},
  { "TINYTEXT",  SYM(TINYTEXT)},
  { "TO",  SYM(TO_SYM)},
  { "TO_DATE",  SYM(TO_DATE)},
  { "TRAILING",  SYM(TRAILING)},
  { "TRANSACTION", SYM(TRANSACTION_SYM)},
  { "TRANSACTIONAL", SYM(TRANSACTIONAL_SYM)},
  { "THREADS",          SYM(THREADS_SYM)},
  { "TRIGGER",          SYM(TRIGGER_SYM)},
  { "TRIGGERS",         SYM(TRIGGERS_SYM)},
  { "TRUE",  SYM(TRUE_SYM)},
  { "TRUNCATE",  SYM(TRUNCATE_SYM)},
  { "TYPE",  SYM(TYPE_SYM)},
  { "UNBOUNDED",        SYM(UNBOUNDED_SYM)},
  { "UNCOMMITTED", SYM(UNCOMMITTED_SYM)},
  { "UNDEFINED", SYM(UNDEFINED_SYM)},
  { "UNDO",             SYM(UNDO_SYM)},
  { "UNICODE",         SYM(UNICODE_SYM)},
  { "UNION",         SYM(UNION_SYM)},
  { "UNIQUE",  SYM(UNIQUE_SYM)},
  { "UNKNOWN",  SYM(UNKNOWN_SYM)},
  { "UNLOCK",  SYM(UNLOCK_SYM)},
  { "UNINSTALL",        SYM(UNINSTALL_SYM)},
  { "UNSIGNED",  SYM(UNSIGNED)},
  { "UNTIL",  SYM(UNTIL_SYM)},
  { "UPDATE",  SYM(UPDATE_SYM)},
  { "UPGRADE",          SYM(UPGRADE_SYM)},
  { "USAGE",  SYM(USAGE)},
  { "USE",  SYM(USE_SYM)},
  { "USER",  SYM(USER_SYM)},
  { "USER_RESOURCES", SYM(RESOURCES)},
  { "USE_FRM",  SYM(USE_FRM)},
  { "USING",  SYM(USING)},
  { "UTC_DATE",         SYM(UTC_DATE_SYM)},
  { "UTC_TIME",         SYM(UTC_TIME_SYM)},
  { "UTC_TIMESTAMP",    SYM(UTC_TIMESTAMP_SYM)},
  { "VALIDATION",       SYM(VALIDATION_SYM)},
  { "VALUE",  SYM(VALUE_SYM)},
  { "VALUES",  SYM(VALUES)},
  { "VARBINARY", SYM(VARBINARY)},
  { "VARCHAR",  SYM(VARCHAR)},
  { "VARCHARACTER", SYM(VARCHAR)},
  { "VARCHAR2",         SYM(VARCHAR2_MARIADB_SYM)},
  { "VARIABLES", SYM(VARIABLES)},
  { "VARYING",  SYM(VARYING)},
  { "VIA",              SYM(VIA_SYM)},
  { "VIEW",  SYM(VIEW_SYM)},
  { "VIRTUAL",          SYM(VIRTUAL_SYM)},
  { "VISIBLE",          SYM(VISIBLE_SYM)},
  { "VECTOR",           SYM(VECTOR_SYM)},
  { "VERSIONING",       SYM(VERSIONING_SYM)},
  { "WAIT",  SYM(WAIT_SYM)},
  { "WARNINGS",  SYM(WARNINGS)},
  { "WEEK",  SYM(WEEK_SYM)},
  { "WEIGHT_STRING", SYM(WEIGHT_STRING_SYM)},
  { "WHEN",  SYM(WHEN_SYM)},
  { "WHERE",  SYM(WHERE)},
  { "WHILE",            SYM(WHILE_SYM)},
  { "WINDOW",           SYM(WINDOW_SYM)},
  { "WITH",  SYM(WITH)},
  { "WITHIN",   SYM(WITHIN)},
  { "WITHOUT",          SYM(WITHOUT)},
  { "WORK",  SYM(WORK_SYM)},
  { "WRAPPER",  SYM(WRAPPER_SYM)},
  { "WRITE",  SYM(WRITE_SYM)},
  { "X509",  SYM(X509_SYM)},
  { "XOR",  SYM(XOR)},
  { "XA",               SYM(XA_SYM)},
  { "XML",              SYM(XML_SYM)}, /* LOAD XML Arnold/Erik */
  { "YEAR",  SYM(YEAR_SYM)},
  { "YEAR_MONTH", SYM(YEAR_MONTH_SYM)},
  { "ZEROFILL",  SYM(ZEROFILL)},
  { "||",  SYM(OR2_SYM)}
};


SYMBOL sql_functions[] = {
  { "ADDDATE",  SYM(ADDDATE_SYM)},
  { "BIT_AND",  SYM(BIT_AND)},
  { "BIT_OR",  SYM(BIT_OR)},
  { "BIT_XOR",  SYM(BIT_XOR)},
  { "CAST",  SYM(CAST_SYM)},
  { "COUNT",  SYM(COUNT_SYM)},
  { "CUME_DIST",        SYM(CUME_DIST_SYM)},
  { "CURDATE",  SYM(CURDATE)},
  { "CURTIME",  SYM(CURTIME)},
  { "DATE_ADD",  SYM(DATE_ADD_INTERVAL)},
  { "DATE_SUB",  SYM(DATE_SUB_INTERVAL)},
  { "DENSE_RANK",       SYM(DENSE_RANK_SYM)},
  { "EXTRACT",  SYM(EXTRACT_SYM)},
  { "FIRST_VALUE",      SYM(FIRST_VALUE_SYM)},
  { "GROUP_CONCAT", SYM(GROUP_CONCAT_SYM)},
  { "JSON_ARRAYAGG", SYM(JSON_ARRAYAGG_SYM)},
  { "JSON_OBJECTAGG", SYM(JSON_OBJECTAGG_SYM)},
  { "LAG",              SYM(LAG_SYM)},
  { "LEAD",             SYM(LEAD_SYM)},
  { "MAX",  SYM(MAX_SYM)},
  { "MEDIAN", SYM(MEDIAN_SYM)},
  { "MID",  SYM(SUBSTRING)}, /* unireg function */
  { "MIN",  SYM(MIN_SYM)},
  { "NOW",  SYM(NOW_SYM)},
  { "NTH_VALUE",        SYM(NTH_VALUE_SYM)},
  { "NTILE",            SYM(NTILE_SYM)},
  { "NUMTODSINTERVAL",  SYM(NUMTODSINTERVAL_SYM)},
  { "NUMTOYMINTERVAL",  SYM(NUMTOYMINTERVAL_SYM)},
  { "POSITION",  SYM(POSITION_SYM)},
  { "PERCENT_RANK",     SYM(PERCENT_RANK_SYM)},
  { "PERCENTILE_CONT",  SYM(PERCENTILE_CONT_SYM)},
  { "PERCENTILE_DISC",  SYM(PERCENTILE_DISC_SYM)},
  { "RANK",             SYM(RANK_SYM)},
  { "SESSION_USER",     SYM(SESSION_USER_SYM)},
  { "STD",  SYM(STD_SYM)},
  { "STDDEV",  SYM(STD_SYM)},
  { "STDDEV_POP", SYM(STD_SYM)},
  { "STDDEV_SAMP", SYM(STDDEV_SAMP_SYM)},
  { "ST_COLLECT", SYM(ST_COLLECT_SYM)},
  { "SUBDATE",  SYM(SUBDATE_SYM)},
  { "SUBSTR",  SYM(SUBSTRING)},
  { "SUBSTRING", SYM(SUBSTRING)},
  { "SUM",  SYM(SUM_SYM)},
  { "SYSTEM_USER",      SYM(USER_SYM)},
  { "TRIM",  SYM(TRIM)},
  { "TRIM_ORACLE", SYM(TRIM_ORACLE)},
  { "VARIANCE",  SYM(VARIANCE_SYM)},
  { "VAR_POP",  SYM(VARIANCE_SYM)},
  { "VAR_SAMP",  SYM(VAR_SAMP_SYM)},
};

size_t symbols_length= sizeof(symbols) / sizeof(SYMBOL);
size_t sql_functions_length= sizeof(sql_functions) / sizeof(SYMBOL);

#endif /* LEX_INCLUDED */