开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
lex.h
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：28k
源码类别：

MySQL数据库

开发平台：

Visual C++

lex.h：源码内容
  1. /* Copyright (C) 2000-2002 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* This file includes all reserved words and functions */
  20. #include "lex_symbol.h"
  22. /* We don't want to include sql_yacc.h into gen_lex_hash */
  23. SYM_GROUP sym_group_common= {"", ""};
  24. SYM_GROUP sym_group_geom= {"Spatial extentions", "HAVE_SPATIAL"};
  25. SYM_GROUP sym_group_rtree= {"RTree keys", "HAVE_RTREE_KEYS"};
  27. #ifdef NO_YACC_SYMBOLS
  28. #define SYM_OR_NULL(A) 0
  29. #else
  30. #define SYM_OR_NULL(A) A
  31. #endif
  33. #define SYM(A) SYM_OR_NULL(A),0,0,&sym_group_common
  34. #define F_SYM(A) SYM_OR_NULL(A)
  36. #define CREATE_FUNC(A) (void *)(SYM_OR_NULL(A)), &sym_group_common
  38. #ifdef HAVE_SPATIAL
  39. #define CREATE_FUNC_GEOM(A) (void *)(SYM_OR_NULL(A)), &sym_group_geom
  40. #else
  41. #define CREATE_FUNC_GEOM(A) 0, &sym_group_geom
  42. #endif
  44. /*
  45.   Symbols are broken into separated arrays to allow field names with
  46.   same name as functions.
  47.   These are kept sorted for human lookup (the symbols are hashed).
  48. */
  50. static SYMBOL symbols[] = {
  51.   { "&&", SYM(AND_SYM)},
  52.   { "<", SYM(LT)},
  53.   { "<=", SYM(LE)},
  54.   { "<>", SYM(NE)},
  55.   { "!=", SYM(NE)},
  56.   { "=", SYM(EQ)},
  57.   { ">", SYM(GT_SYM)},
  58.   { ">=", SYM(GE)},
  59.   { "<<", SYM(SHIFT_LEFT)},
  60.   { ">>", SYM(SHIFT_RIGHT)},
  61.   { "<=>", SYM(EQUAL_SYM)},
  62.   { "ACTION", SYM(ACTION)},
  63.   { "ADD", SYM(ADD)},
  64.   { "AFTER", SYM(AFTER_SYM)},
  65.   { "AGAINST",          SYM(AGAINST)},
  66.   { "AGGREGATE", SYM(AGGREGATE_SYM)},
  67.   { "ALL", SYM(ALL)},
  68.   { "ALTER", SYM(ALTER)},
  69.   { "ANALYZE", SYM(ANALYZE_SYM)},
  70.   { "AND", SYM(AND_SYM)},
  71.   { "ANY",              SYM(ANY_SYM)},
  72.   { "AS", SYM(AS)},
  73.   { "ASC", SYM(ASC)},
  74.   { "ASCII", SYM(ASCII_SYM)},
  75.   { "AUTO_INCREMENT", SYM(AUTO_INC)},
  76.   { "AVG", SYM(AVG_SYM)},
  77.   { "AVG_ROW_LENGTH", SYM(AVG_ROW_LENGTH)},
  78.   { "BACKUP",         SYM(BACKUP_SYM)},
  79.   { "BDB",              SYM(BERKELEY_DB_SYM)},
  80.   { "BEFORE",         SYM(BEFORE_SYM)},
  81.   { "BEGIN",         SYM(BEGIN_SYM)},
  82.   { "BERKELEYDB",       SYM(BERKELEY_DB_SYM)},
  83.   { "BETWEEN", SYM(BETWEEN_SYM)},
  84.   { "BIGINT", SYM(BIGINT)},
  85.   { "BINARY", SYM(BINARY)},
  86.   { "BINLOG", SYM(BINLOG_SYM)},
  87.   { "BIT", SYM(BIT_SYM)},
  88.   { "BLOB", SYM(BLOB_SYM)},
  89.   { "BOOL", SYM(BOOL_SYM)},
  90.   { "BOOLEAN", SYM(BOOLEAN_SYM)},
  91.   { "BOTH", SYM(BOTH)},
  92.   { "BTREE", SYM(BTREE_SYM)},
  93.   { "BY", SYM(BY)},
  94.   { "BYTE", SYM(BYTE_SYM)},
  95.   { "CACHE", SYM(CACHE_SYM)},
  96.   { "CASCADE", SYM(CASCADE)},
  97.   { "CASE", SYM(CASE_SYM)},
  98.   { "CHANGE", SYM(CHANGE)},
  99.   { "CHANGED", SYM(CHANGED)},
  100.   { "CHAR", SYM(CHAR_SYM)},
  101.   { "CHARACTER", SYM(CHAR_SYM)},
  102.   { "CHARSET", SYM(CHARSET)},
  103.   { "CHECK", SYM(CHECK_SYM)},
  104.   { "CHECKSUM", SYM(CHECKSUM_SYM)},
  105.   { "CIPHER", SYM(CIPHER_SYM)},
  106.   { "CLIENT", SYM(CLIENT_SYM)},
  107.   { "CLOSE", SYM(CLOSE_SYM)},
  108.   { "COLLATE", SYM(COLLATE_SYM)},
  109.   { "COLLATION", SYM(COLLATION_SYM)},
  110.   { "COLUMN", SYM(COLUMN_SYM)},
  111.   { "COLUMNS", SYM(COLUMNS)},
  112.   { "COMMENT", SYM(COMMENT_SYM)},
  113.   { "COMMIT", SYM(COMMIT_SYM)},
  114.   { "COMMITTED", SYM(COMMITTED_SYM)},
  115.   { "COMPRESSED", SYM(COMPRESSED_SYM)},
  116.   { "CONCURRENT", SYM(CONCURRENT)},
  117.   { "CONSISTENT", SYM(CONSISTENT_SYM)},
  118.   { "CONSTRAINT", SYM(CONSTRAINT)},
  119.   { "CONVERT", SYM(CONVERT_SYM)},
  120.   { "CREATE", SYM(CREATE)},
  121.   { "CROSS", SYM(CROSS)},
  122.   { "CUBE", SYM(CUBE_SYM)},
  123.   { "CURRENT_DATE", SYM(CURDATE)},
  124.   { "CURRENT_TIME", SYM(CURTIME)},
  125.   { "CURRENT_TIMESTAMP", SYM(NOW_SYM)},
  126.   { "CURRENT_USER", SYM(CURRENT_USER)},
  127.   { "DATA", SYM(DATA_SYM)},
  128.   { "DATABASE", SYM(DATABASE)},
  129.   { "DATABASES", SYM(DATABASES)},
  130.   { "DATE", SYM(DATE_SYM)},
  131.   { "DATETIME", SYM(DATETIME)},
  132.   { "DAY", SYM(DAY_SYM)},
  133.   { "DAY_HOUR", SYM(DAY_HOUR_SYM)},
  134.   { "DAY_MICROSECOND", SYM(DAY_MICROSECOND_SYM)},
  135.   { "DAY_MINUTE", SYM(DAY_MINUTE_SYM)},
  136.   { "DAY_SECOND", SYM(DAY_SECOND_SYM)},
  137.   { "DEALLOCATE",       SYM(DEALLOCATE_SYM)},     
  138.   { "DEC", SYM(DECIMAL_SYM)},
  139.   { "DECIMAL", SYM(DECIMAL_SYM)},
  140.   { "DEFAULT", SYM(DEFAULT)},
  141.   { "DELAYED", SYM(DELAYED_SYM)},
  142.   { "DELAY_KEY_WRITE", SYM(DELAY_KEY_WRITE_SYM)},
  143.   { "DELETE", SYM(DELETE_SYM)},
  144.   { "DESC", SYM(DESC)},
  145.   { "DESCRIBE", SYM(DESCRIBE)},
  146.   { "DES_KEY_FILE", SYM(DES_KEY_FILE)},
  147.   { "DIRECTORY", SYM(DIRECTORY_SYM)},
  148.   { "DISABLE", SYM(DISABLE_SYM)},
  149.   { "DISCARD", SYM(DISCARD)},
  150.   { "DISTINCT", SYM(DISTINCT)},
  151.   { "DISTINCTROW", SYM(DISTINCT)}, /* Access likes this */
  152.   { "DIV", SYM(DIV_SYM)},
  153.   { "DO", SYM(DO_SYM)},
  154.   { "DOUBLE", SYM(DOUBLE_SYM)},
  155.   { "DROP", SYM(DROP)},
  156.   { "DUAL", SYM(DUAL_SYM)},
  157.   { "DUMPFILE", SYM(DUMPFILE)},
  158.   { "DUPLICATE", SYM(DUPLICATE_SYM)},
  159.   { "DYNAMIC", SYM(DYNAMIC_SYM)},
  160.   { "ELSE",             SYM(ELSE)},
  161.   { "ENABLE", SYM(ENABLE_SYM)},
  162.   { "ENCLOSED", SYM(ENCLOSED)},
  163.   { "END", SYM(END)},
  164.   { "ENGINE", SYM(ENGINE_SYM)},
  165.   { "ENGINES", SYM(ENGINES_SYM)},
  166.   { "ENUM", SYM(ENUM)},
  167.   { "ERRORS", SYM(ERRORS)},
  168.   { "ESCAPE", SYM(ESCAPE_SYM)},
  169.   { "ESCAPED", SYM(ESCAPED)},
  170.   { "EVENTS", SYM(EVENTS_SYM)},
  171.   { "EXECUTE", SYM(EXECUTE_SYM)},
  172.   { "EXISTS", SYM(EXISTS)},
  173.   { "EXPANSION", SYM(EXPANSION_SYM)},
  174.   { "EXPLAIN", SYM(DESCRIBE)},
  175.   { "EXTENDED", SYM(EXTENDED_SYM)},
  176.   { "FALSE", SYM(FALSE_SYM)},
  177.   { "FAST", SYM(FAST_SYM)},
  178.   { "FIELDS", SYM(COLUMNS)},
  179.   { "FILE", SYM(FILE_SYM)},
  180.   { "FIRST", SYM(FIRST_SYM)},
  181.   { "FIXED", SYM(FIXED_SYM)},
  182.   { "FLOAT", SYM(FLOAT_SYM)},
  183.   { "FLOAT4", SYM(FLOAT_SYM)},
  184.   { "FLOAT8", SYM(DOUBLE_SYM)},
  185.   { "FLUSH", SYM(FLUSH_SYM)},
  186.   { "FOR", SYM(FOR_SYM)},
  187.   { "FORCE", SYM(FORCE_SYM)},
  188.   { "FOREIGN", SYM(FOREIGN)},
  189.   { "FROM", SYM(FROM)},
  190.   { "FULL", SYM(FULL)},
  191.   { "FULLTEXT", SYM(FULLTEXT_SYM)},
  192.   { "FUNCTION", SYM(UDF_SYM)},
  193.   { "GEOMETRY", SYM(GEOMETRY_SYM)},
  194.   { "GEOMETRYCOLLECTION",SYM(GEOMETRYCOLLECTION)},
  195.   { "GET_FORMAT",       SYM(GET_FORMAT)},
  196.   { "GLOBAL", SYM(GLOBAL_SYM)},
  197.   { "GRANT", SYM(GRANT)},
  198.   { "GRANTS",         SYM(GRANTS)},
  199.   { "GROUP", SYM(GROUP)},
  200.   { "HANDLER", SYM(HANDLER_SYM)},
  201.   { "HASH", SYM(HASH_SYM)},
  202.   { "HAVING", SYM(HAVING)},
  203.   { "HELP", SYM(HELP_SYM)},
  204.   { "HIGH_PRIORITY", SYM(HIGH_PRIORITY)},
  205.   { "HOSTS", SYM(HOSTS_SYM)},
  206.   { "HOUR", SYM(HOUR_SYM)},
  207.   { "HOUR_MICROSECOND", SYM(HOUR_MICROSECOND_SYM)},
  208.   { "HOUR_MINUTE", SYM(HOUR_MINUTE_SYM)},
  209.   { "HOUR_SECOND", SYM(HOUR_SECOND_SYM)},
  210.   { "IDENTIFIED", SYM(IDENTIFIED_SYM)},
  211.   { "IF", SYM(IF)},
  212.   { "IGNORE", SYM(IGNORE_SYM)},
  213.   { "IMPORT", SYM(IMPORT)},
  214.   { "IN", SYM(IN_SYM)},
  215.   { "INDEX", SYM(INDEX_SYM)},
  216.   { "INDEXES", SYM(INDEXES)},
  217.   { "INFILE", SYM(INFILE)},
  218.   { "INNER", SYM(INNER_SYM)},
  219.   { "INNOBASE", SYM(INNOBASE_SYM)},
  220.   { "INNODB", SYM(INNOBASE_SYM)},
  221.   { "INSERT", SYM(INSERT)},
  222.   { "INSERT_METHOD",    SYM(INSERT_METHOD)},
  223.   { "INT", SYM(INT_SYM)},
  224.   { "INT1", SYM(TINYINT)},
  225.   { "INT2", SYM(SMALLINT)},
  226.   { "INT3", SYM(MEDIUMINT)},
  227.   { "INT4", SYM(INT_SYM)},
  228.   { "INT8", SYM(BIGINT)},
  229.   { "INTEGER", SYM(INT_SYM)},
  230.   { "INTERVAL", SYM(INTERVAL_SYM)},
  231.   { "INTO", SYM(INTO)},
  232.   { "IO_THREAD",        SYM(RELAY_THREAD)},
  233.   { "IS", SYM(IS)},
  234.   { "ISOLATION", SYM(ISOLATION)},
  235.   { "ISSUER", SYM(ISSUER_SYM)},
  236.   { "JOIN", SYM(JOIN_SYM)},
  237.   { "KEY", SYM(KEY_SYM)},
  238.   { "KEYS", SYM(KEYS)},
  239.   { "KILL", SYM(KILL_SYM)},
  240.   { "LAST", SYM(LAST_SYM)},
  241.   { "LEADING", SYM(LEADING)},
  242.   { "LEAVES", SYM(LEAVES)},
  243.   { "LEFT", SYM(LEFT)},
  244.   { "LEVEL", SYM(LEVEL_SYM)},
  245.   { "LIKE", SYM(LIKE)},
  246.   { "LIMIT", SYM(LIMIT)},
  247.   { "LINES", SYM(LINES)},
  248.   { "LINESTRING", SYM(LINESTRING)},
  249.   { "LOAD", SYM(LOAD)},
  250.   { "LOCAL", SYM(LOCAL_SYM)},
  251.   { "LOCALTIME", SYM(NOW_SYM)},
  252.   { "LOCALTIMESTAMP", SYM(NOW_SYM)},
  253.   { "LOCK", SYM(LOCK_SYM)},
  254.   { "LOCKS", SYM(LOCKS_SYM)},
  255.   { "LOGS", SYM(LOGS_SYM)},
  256.   { "LONG", SYM(LONG_SYM)},
  257.   { "LONGBLOB", SYM(LONGBLOB)},
  258.   { "LONGTEXT", SYM(LONGTEXT)},
  259.   { "LOW_PRIORITY", SYM(LOW_PRIORITY)},
  260.   { "MASTER",           SYM(MASTER_SYM)},
  261.   { "MASTER_CONNECT_RETRY",           SYM(MASTER_CONNECT_RETRY_SYM)},
  262.   { "MASTER_HOST",           SYM(MASTER_HOST_SYM)},
  263.   { "MASTER_LOG_FILE",           SYM(MASTER_LOG_FILE_SYM)},
  264.   { "MASTER_LOG_POS",           SYM(MASTER_LOG_POS_SYM)},
  265.   { "MASTER_PASSWORD",           SYM(MASTER_PASSWORD_SYM)},
  266.   { "MASTER_PORT",           SYM(MASTER_PORT_SYM)},
  267.   { "MASTER_SERVER_ID",           SYM(MASTER_SERVER_ID_SYM)},
  268.   { "MASTER_SSL",       SYM(MASTER_SSL_SYM)},
  269.   { "MASTER_SSL_CA",    SYM(MASTER_SSL_CA_SYM)},
  270.   { "MASTER_SSL_CAPATH",SYM(MASTER_SSL_CAPATH_SYM)},
  271.   { "MASTER_SSL_CERT",  SYM(MASTER_SSL_CERT_SYM)},
  272.   { "MASTER_SSL_CIPHER",SYM(MASTER_SSL_CIPHER_SYM)},
  273.   { "MASTER_SSL_KEY",   SYM(MASTER_SSL_KEY_SYM)},
  274.   { "MASTER_USER",           SYM(MASTER_USER_SYM)},
  275.   { "MATCH", SYM(MATCH)},
  276.   { "MAX_CONNECTIONS_PER_HOUR", SYM(MAX_CONNECTIONS_PER_HOUR)},
  277.   { "MAX_QUERIES_PER_HOUR", SYM(MAX_QUERIES_PER_HOUR)},
  278.   { "MAX_ROWS", SYM(MAX_ROWS)},
  279.   { "MAX_UPDATES_PER_HOUR", SYM(MAX_UPDATES_PER_HOUR)},
  280.   { "MEDIUM", SYM(MEDIUM_SYM)},
  281.   { "MEDIUMBLOB", SYM(MEDIUMBLOB)},
  282.   { "MEDIUMINT", SYM(MEDIUMINT)},
  283.   { "MEDIUMTEXT", SYM(MEDIUMTEXT)},
  284.   { "MICROSECOND", SYM(MICROSECOND_SYM)},
  285.   { "MIDDLEINT", SYM(MEDIUMINT)}, /* For powerbuilder */
  286.   { "MINUTE", SYM(MINUTE_SYM)},
  287.   { "MINUTE_MICROSECOND", SYM(MINUTE_MICROSECOND_SYM)},
  288.   { "MINUTE_SECOND", SYM(MINUTE_SECOND_SYM)},
  289.   { "MIN_ROWS", SYM(MIN_ROWS)},
  290.   { "MOD", SYM(MOD_SYM)},
  291.   { "MODE", SYM(MODE_SYM)},
  292.   { "MODIFY", SYM(MODIFY_SYM)},
  293.   { "MONTH", SYM(MONTH_SYM)},
  294.   { "MULTILINESTRING", SYM(MULTILINESTRING)},
  295.   { "MULTIPOINT", SYM(MULTIPOINT)},
  296.   { "MULTIPOLYGON", SYM(MULTIPOLYGON)},
  297.   { "NAMES", SYM(NAMES_SYM)},
  298.   { "NATIONAL", SYM(NATIONAL_SYM)},
  299.   { "NATURAL", SYM(NATURAL)},
  300.   { "NDB",              SYM(NDBCLUSTER_SYM)},
  301.   { "NDBCLUSTER",       SYM(NDBCLUSTER_SYM)},
  302.   { "NCHAR", SYM(NCHAR_SYM)},
  303.   { "NEW",              SYM(NEW_SYM)},
  304.   { "NEXT", SYM(NEXT_SYM)},
  305.   { "NO", SYM(NO_SYM)},
  306.   { "NONE", SYM(NONE_SYM)},
  307.   { "NOT", SYM(NOT)},
  308.   { "NO_WRITE_TO_BINLOG",  SYM(NO_WRITE_TO_BINLOG)},
  309.   { "NULL", SYM(NULL_SYM)},
  310.   { "NUMERIC", SYM(NUMERIC_SYM)},
  311.   { "NVARCHAR", SYM(NVARCHAR_SYM)},
  312.   { "OFFSET", SYM(OFFSET_SYM)},
  313.   { "OLD_PASSWORD", SYM(OLD_PASSWORD)},
  314.   { "ON", SYM(ON)},
  315.   { "ONE_SHOT", SYM(ONE_SHOT_SYM)},
  316.   { "OPEN", SYM(OPEN_SYM)},
  317.   { "OPTIMIZE", SYM(OPTIMIZE)},
  318.   { "OPTION", SYM(OPTION)},
  319.   { "OPTIONALLY", SYM(OPTIONALLY)},
  320.   { "OR", SYM(OR_SYM)},
  321.   { "ORDER", SYM(ORDER_SYM)},
  322.   { "OUTER", SYM(OUTER)},
  323.   { "OUTFILE", SYM(OUTFILE)},
  324.   { "PACK_KEYS", SYM(PACK_KEYS_SYM)},
  325.   { "PARTIAL", SYM(PARTIAL)},
  326.   { "PASSWORD", SYM(PASSWORD)},
  327.   { "POINT", SYM(POINT_SYM)},
  328.   { "POLYGON", SYM(POLYGON)},
  329.   { "PRECISION", SYM(PRECISION)},
  330.   { "PREPARE",          SYM(PREPARE_SYM)},
  331.   { "PREV", SYM(PREV_SYM)},
  332.   { "PRIMARY", SYM(PRIMARY_SYM)},
  333.   { "PRIVILEGES", SYM(PRIVILEGES)},
  334.   { "PROCEDURE", SYM(PROCEDURE)},
  335.   { "PROCESS" , SYM(PROCESS)},
  336.   { "PROCESSLIST", SYM(PROCESSLIST_SYM)},
  337.   { "PURGE", SYM(PURGE)},
  338.   { "QUERY", SYM(QUERY_SYM)},
  339.   { "QUICK",         SYM(QUICK)},
  340.   { "RAID0", SYM(RAID_0_SYM)},
  341.   { "RAID_CHUNKS", SYM(RAID_CHUNKS)},
  342.   { "RAID_CHUNKSIZE", SYM(RAID_CHUNKSIZE)},
  343.   { "RAID_TYPE", SYM(RAID_TYPE)},
  344.   { "READ", SYM(READ_SYM)},
  345.   { "REAL", SYM(REAL)},
  346.   { "REFERENCES", SYM(REFERENCES)},
  347.   { "REGEXP", SYM(REGEXP)},
  348.   { "RELAY_LOG_FILE",   SYM(RELAY_LOG_FILE_SYM)},
  349.   { "RELAY_LOG_POS",    SYM(RELAY_LOG_POS_SYM)},
  350.   { "RELAY_THREAD",     SYM(RELAY_THREAD)},
  351.   { "RELOAD", SYM(RELOAD)},
  352.   { "RENAME", SYM(RENAME)},
  353.   { "REPAIR", SYM(REPAIR)},
  354.   { "REPEATABLE", SYM(REPEATABLE_SYM)},
  355.   { "REPLACE", SYM(REPLACE)},
  356.   { "REPLICATION", SYM(REPLICATION)},
  357.   { "REQUIRE",         SYM(REQUIRE_SYM)},
  358.   { "RESET", SYM(RESET_SYM)},
  359.   { "RESTORE", SYM(RESTORE_SYM)},
  360.   { "RESTRICT", SYM(RESTRICT)},
  361.   { "RETURNS", SYM(UDF_RETURNS_SYM)},
  362.   { "REVOKE", SYM(REVOKE)},
  363.   { "RIGHT", SYM(RIGHT)},
  364.   { "RLIKE", SYM(REGEXP)}, /* Like in mSQL2 */
  365.   { "ROLLBACK", SYM(ROLLBACK_SYM)},
  366.   { "ROLLUP", SYM(ROLLUP_SYM)},
  367.   { "ROW", SYM(ROW_SYM)},
  368.   { "ROWS", SYM(ROWS_SYM)},
  369.   { "ROW_FORMAT", SYM(ROW_FORMAT_SYM)},
  370.   { "RTREE", SYM(RTREE_SYM)},
  371.   { "SAVEPOINT", SYM(SAVEPOINT_SYM)},
  372.   { "SECOND", SYM(SECOND_SYM)},
  373.   { "SECOND_MICROSECOND", SYM(SECOND_MICROSECOND_SYM)},
  374.   { "SELECT", SYM(SELECT_SYM)},
  375.   { "SEPARATOR", SYM(SEPARATOR_SYM)},
  376.   { "SERIAL", SYM(SERIAL_SYM)},
  377.   { "SERIALIZABLE", SYM(SERIALIZABLE_SYM)},
  378.   { "SESSION", SYM(SESSION_SYM)},
  379.   { "SET", SYM(SET)},
  380.   { "SHARE", SYM(SHARE_SYM)},
  381.   { "SHOW", SYM(SHOW)},
  382.   { "SHUTDOWN", SYM(SHUTDOWN)},
  383.   { "SIGNED", SYM(SIGNED_SYM)},
  384.   { "SIMPLE", SYM(SIMPLE_SYM)},
  385.   { "SLAVE",            SYM(SLAVE)},
  386.   { "SNAPSHOT",         SYM(SNAPSHOT_SYM)},
  387.   { "SMALLINT", SYM(SMALLINT)},
  388.   { "SOME",             SYM(ANY_SYM)},
  389.   { "SONAME", SYM(UDF_SONAME_SYM)},
  390.   { "SOUNDS", SYM(SOUNDS_SYM)},
  391.   { "SPATIAL", SYM(SPATIAL_SYM)},
  392.   { "SQL_BIG_RESULT", SYM(SQL_BIG_RESULT)},
  393.   { "SQL_BUFFER_RESULT", SYM(SQL_BUFFER_RESULT)},
  394.   { "SQL_CACHE",        SYM(SQL_CACHE_SYM)},
  395.   { "SQL_CALC_FOUND_ROWS", SYM(SQL_CALC_FOUND_ROWS)},
  396.   { "SQL_NO_CACHE", SYM(SQL_NO_CACHE_SYM)},
  397.   { "SQL_SMALL_RESULT", SYM(SQL_SMALL_RESULT)},
  398.   { "SQL_THREAD", SYM(SQL_THREAD)},
  399.   { "SSL", SYM(SSL_SYM)},
  400.   { "START", SYM(START_SYM)},
  401.   { "STARTING", SYM(STARTING)},
  402.   { "STATUS", SYM(STATUS_SYM)},
  403.   { "STOP", SYM(STOP_SYM)},
  404.   { "STORAGE", SYM(STORAGE_SYM)},
  405.   { "STRAIGHT_JOIN", SYM(STRAIGHT_JOIN)},
  406.   { "STRING", SYM(STRING_SYM)},
  407.   { "STRIPED", SYM(RAID_STRIPED_SYM)},
  408.   { "SUBJECT", SYM(SUBJECT_SYM)},
  409.   { "SUPER", SYM(SUPER_SYM)},
  410.   { "TABLE", SYM(TABLE_SYM)},
  411.   { "TABLES", SYM(TABLES)},
  412.   { "TABLESPACE", SYM(TABLESPACE)},
  413.   { "TEMPORARY", SYM(TEMPORARY)},
  414.   { "TERMINATED", SYM(TERMINATED)},
  415.   { "TEXT", SYM(TEXT_SYM)},
  416.   { "THEN", SYM(THEN_SYM)},
  417.   { "TIME", SYM(TIME_SYM)},
  418.   { "TIMESTAMP", SYM(TIMESTAMP)},
  419.   { "TINYBLOB", SYM(TINYBLOB)},
  420.   { "TINYINT", SYM(TINYINT)},
  421.   { "TINYTEXT", SYM(TINYTEXT)},
  422.   { "TO", SYM(TO_SYM)},
  423.   { "TRAILING", SYM(TRAILING)},
  424.   { "TRANSACTION", SYM(TRANSACTION_SYM)},
  425.   { "TRUE", SYM(TRUE_SYM)},
  426.   { "TRUNCATE", SYM(TRUNCATE_SYM)},
  427.   { "TYPE", SYM(TYPE_SYM)},
  428.   { "TYPES", SYM(TYPES_SYM)},
  429.   { "UNCOMMITTED", SYM(UNCOMMITTED_SYM)},
  430.   { "UNICODE",         SYM(UNICODE_SYM)},
  431.   { "UNION",         SYM(UNION_SYM)},
  432.   { "UNIQUE", SYM(UNIQUE_SYM)},
  433.   { "UNLOCK", SYM(UNLOCK_SYM)},
  434.   { "UNSIGNED", SYM(UNSIGNED)},
  435.   { "UNTIL", SYM(UNTIL_SYM)},
  436.   { "UPDATE", SYM(UPDATE_SYM)},
  437.   { "USAGE", SYM(USAGE)},
  438.   { "USE", SYM(USE_SYM)},
  439.   { "USER", SYM(USER)},
  440.   { "USER_RESOURCES", SYM(RESOURCES)},
  441.   { "USE_FRM", SYM(USE_FRM)},
  442.   { "USING", SYM(USING)},
  443.   { "UTC_DATE",         SYM(UTC_DATE_SYM)},
  444.   { "UTC_TIME",         SYM(UTC_TIME_SYM)},
  445.   { "UTC_TIMESTAMP",    SYM(UTC_TIMESTAMP_SYM)},
  446.   { "VALUE", SYM(VALUE_SYM)},
  447.   { "VALUES", SYM(VALUES)},
  448.   { "VARBINARY", SYM(VARBINARY)},
  449.   { "VARCHAR", SYM(VARCHAR)},
  450.   { "VARCHARACTER", SYM(VARCHAR)},
  451.   { "VARIABLES", SYM(VARIABLES)},
  452.   { "VARYING", SYM(VARYING)},
  453.   { "WARNINGS", SYM(WARNINGS)},
  454.   { "WHEN", SYM(WHEN_SYM)},
  455.   { "WHERE", SYM(WHERE)},
  456.   { "WITH", SYM(WITH)},
  457.   { "WORK", SYM(WORK_SYM)},
  458.   { "WRITE", SYM(WRITE_SYM)},
  459.   { "X509", SYM(X509_SYM)},
  460.   { "XOR", SYM(XOR)},
  461.   { "YEAR", SYM(YEAR_SYM)},
  462.   { "YEAR_MONTH", SYM(YEAR_MONTH_SYM)},
  463.   { "ZEROFILL", SYM(ZEROFILL)},
  464.   { "||", SYM(OR_OR_CONCAT)}
  465. };
  468. static SYMBOL sql_functions[] = {
  469.   { "ABS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_abs)},
  470.   { "ACOS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_acos)},
  471.   { "ADDDATE", SYM(ADDDATE_SYM)},
  472.   { "ADDTIME", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_addtime)},
  473.   { "AES_ENCRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_encrypt)},
  474.   { "AES_DECRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_decrypt)},
  475.   { "AREA", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_area)},
  476.   { "ASIN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_asin)},
  477.   { "ASBINARY", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
  478.   { "ASTEXT", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
  479.   { "ASWKB", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
  480.   { "ASWKT", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
  481.   { "ATAN", SYM(ATAN)},
  482.   { "ATAN2", SYM(ATAN)},
  483.   { "BENCHMARK", SYM(BENCHMARK_SYM)},
  484.   { "BIN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bin)},
  485.   { "BIT_COUNT", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_count)},
  486.   { "BIT_OR", SYM(BIT_OR)},
  487.   { "BIT_AND", SYM(BIT_AND)},
  488.   { "BIT_XOR", SYM(BIT_XOR)},
  489.   { "CAST", SYM(CAST_SYM)},
  490.   { "CEIL", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
  491.   { "CEILING", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
  492.   { "BIT_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_length)},
  493.   { "CENTROID", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_centroid)},
  494.   { "CHAR_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
  495.   { "CHARACTER_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
  496.   { "COALESCE", SYM(COALESCE)},
  497.   { "COERCIBILITY", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_coercibility)},
  498.   { "COMPRESS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_compress)},
  499.   { "CONCAT", SYM(CONCAT)},
  500.   { "CONCAT_WS", SYM(CONCAT_WS)},
  501.   { "CONNECTION_ID", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_connection_id)},
  502.   { "CONTAINS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_contains)},
  503.   { "CONV", F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_conv)},
  504.   { "CONVERT_TZ", SYM(CONVERT_TZ_SYM)},
  505.   { "COUNT", SYM(COUNT_SYM)},
  506.   { "COS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cos)},
  507.   { "COT", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cot)},
  508.   { "CRC32", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_crc32)},
  509.   { "CROSSES", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_crosses)},
  510.   { "CURDATE", SYM(CURDATE)},
  511.   { "CURTIME", SYM(CURTIME)},
  512.   { "DATE_ADD", SYM(DATE_ADD_INTERVAL)},
  513.   { "DATEDIFF", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_datediff)},
  514.   { "DATE_FORMAT", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_date_format)},
  515.   { "DATE_SUB", SYM(DATE_SUB_INTERVAL)},
  516.   { "DAYNAME", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayname)},
  517.   { "DAYOFMONTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofmonth)},
  518.   { "DAYOFWEEK", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofweek)},
  519.   { "DAYOFYEAR", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofyear)},
  520.   { "DECODE", SYM(DECODE_SYM)},
  521.   { "DEGREES", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_degrees)},
  522.   { "DES_ENCRYPT", SYM(DES_ENCRYPT_SYM)},
  523.   { "DES_DECRYPT", SYM(DES_DECRYPT_SYM)},
  524.   { "DIMENSION", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_dimension)},
  525.   { "DISJOINT", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
  526.   { "ELT", SYM(ELT_FUNC)},
  527.   { "ENCODE", SYM(ENCODE_SYM)},
  528.   { "ENCRYPT", SYM(ENCRYPT)},
  529.   { "ENDPOINT", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_endpoint)},
  530.   { "ENVELOPE", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_envelope)},
  531.   { "EQUALS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
  532.   { "EXTERIORRING", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_exteriorring)},
  533.   { "EXTRACT", SYM(EXTRACT_SYM)},
  534.   { "EXP", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_exp)},
  535.   { "EXPORT_SET", SYM(EXPORT_SET)},
  536.   { "FIELD", SYM(FIELD_FUNC)}, /* For compability */
  537.   { "FIND_IN_SET", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_find_in_set)},
  538.   { "FLOOR", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_floor)},
  539.   { "FORMAT", SYM(FORMAT_SYM)},
  540.   { "FOUND_ROWS", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_found_rows)},
  541.   { "FROM_DAYS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_from_days)},
  542.   { "FROM_UNIXTIME", SYM(FROM_UNIXTIME)},
  543.   { "GET_LOCK", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_get_lock)},
  544.   { "GEOMETRYN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_geometryn)},
  545.   { "GEOMETRYTYPE", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_geometry_type)},
  546.   { "GEOMCOLLFROMTEXT", SYM(GEOMCOLLFROMTEXT)},
  547.   { "GEOMCOLLFROMWKB", SYM(GEOMFROMWKB)},
  548.   { "GEOMETRYCOLLECTIONFROMTEXT",SYM(GEOMCOLLFROMTEXT)},
  549.   { "GEOMETRYCOLLECTIONFROMWKB",SYM(GEOMFROMWKB)},
  550.   { "GEOMETRYFROMTEXT", SYM(GEOMFROMTEXT)},
  551.   { "GEOMETRYFROMWKB", SYM(GEOMFROMWKB)},
  552.   { "GEOMFROMTEXT", SYM(GEOMFROMTEXT)},
  553.   { "GEOMFROMWKB", SYM(GEOMFROMWKB)},
  554.   { "GLENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_glength)},
  555.   { "GREATEST", SYM(GREATEST_SYM)},
  556.   { "GROUP_CONCAT", SYM(GROUP_CONCAT_SYM)},
  557.   { "GROUP_UNIQUE_USERS", SYM(GROUP_UNIQUE_USERS)},
  558.   { "HEX", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_hex)},
  559.   { "IFNULL", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_ifnull)},
  560.   { "INET_ATON", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_aton)},
  561.   { "INET_NTOA", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_ntoa)},
  562.   { "INSTR", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_instr)},
  563.   { "INTERIORRINGN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_interiorringn)},
  564.   { "INTERSECTS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
  565.   { "ISCLOSED", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isclosed)},
  566.   { "ISEMPTY", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isempty)},
  567.   { "ISNULL", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isnull)},
  568.   { "IS_FREE_LOCK", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_free_lock)},
  569.   { "IS_USED_LOCK", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_used_lock)},
  570.   { "LAST_INSERT_ID", SYM(LAST_INSERT_ID)},
  571.   { "ISSIMPLE",         F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_issimple)},
  572.   { "LAST_DAY",         F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_last_day)},
  573.   { "LCASE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
  574.   { "LEAST", SYM(LEAST_SYM)},
  575.   { "LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
  576.   { "LN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ln)},
  577.   { "LINEFROMTEXT", SYM(LINEFROMTEXT)},
  578.   { "LINEFROMWKB", SYM(GEOMFROMWKB)},
  579.   { "LINESTRINGFROMTEXT",SYM(LINEFROMTEXT)},
  580.   { "LINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
  581.   { "LOAD_FILE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_load_file)},
  582.   { "LOCATE", SYM(LOCATE)},
  583.   { "LOG", SYM(LOG_SYM)},
  584.   { "LOG2", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log2)},
  585.   { "LOG10", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log10)},
  586.   { "LOWER", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
  587.   { "LPAD", F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_lpad)},
  588.   { "LTRIM", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ltrim)},
  589.   { "MAKE_SET", SYM(MAKE_SET_SYM)},
  590.   { "MAKEDATE", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_makedate)},
  591.   { "MAKETIME", F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_maketime)},
  592.   { "MASTER_POS_WAIT", SYM(MASTER_POS_WAIT)},
  593.   { "MAX", SYM(MAX_SYM)},
  594.   { "MBRCONTAINS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_contains)},
  595.   { "MBRDISJOINT", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
  596.   { "MBREQUAL", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
  597.   { "MBRINTERSECTS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
  598.   { "MBROVERLAPS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
  599.   { "MBRTOUCHES", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
  600.   { "MBRWITHIN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
  601.   { "MD5",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_md5)},
  602.   { "MID", SYM(SUBSTRING)}, /* unireg function */
  603.   { "MIN", SYM(MIN_SYM)},
  604.   { "MLINEFROMTEXT", SYM(MLINEFROMTEXT)},
  605.   { "MLINEFROMWKB", SYM(GEOMFROMWKB)},
  606.   { "MPOINTFROMTEXT", SYM(MPOINTFROMTEXT)},
  607.   { "MPOINTFROMWKB", SYM(GEOMFROMWKB)},
  608.   { "MPOLYFROMTEXT", SYM(MPOLYFROMTEXT)},
  609.   { "MPOLYFROMWKB", SYM(GEOMFROMWKB)},
  610.   { "MONTHNAME", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_monthname)},
  611.   { "MULTILINESTRINGFROMTEXT",SYM(MLINEFROMTEXT)},
  612.   { "MULTILINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
  613.   { "MULTIPOINTFROMTEXT",SYM(MPOINTFROMTEXT)},
  614.   { "MULTIPOINTFROMWKB",SYM(GEOMFROMWKB)},
  615.   { "MULTIPOLYGONFROMTEXT",SYM(MPOLYFROMTEXT)},
  616.   { "MULTIPOLYGONFROMWKB",SYM(GEOMFROMWKB)},
  617.   { "NOW", SYM(NOW_SYM)},
  618.   { "NULLIF", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_nullif)},
  619.   { "NUMGEOMETRIES", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numgeometries)},
  620.   { "NUMINTERIORRINGS", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numinteriorring)},
  621.   { "NUMPOINTS", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numpoints)},
  622.   { "OCTET_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
  623.   { "OCT", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_oct)},
  624.   { "ORD",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ord)},
  625.   { "OVERLAPS", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
  626.   { "PERIOD_ADD", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_add)},
  627.   { "PERIOD_DIFF", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_diff)},
  628.   { "PI", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_pi)},
  629.   { "POINTFROMTEXT", SYM(POINTFROMTEXT)},
  630.   { "POINTFROMWKB", SYM(GEOMFROMWKB)},
  631.   { "POINTN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_pointn)},
  632.   { "POLYFROMTEXT", SYM(POLYFROMTEXT)},
  633.   { "POLYFROMWKB", SYM(GEOMFROMWKB)},
  634.   { "POLYGONFROMTEXT", SYM(POLYFROMTEXT)},
  635.   { "POLYGONFROMWKB", SYM(GEOMFROMWKB)},
  636.   { "POSITION", SYM(POSITION_SYM)},
  637.   { "POW", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
  638.   { "POWER", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
  639.   { "QUARTER", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quarter)},
  640.   { "QUOTE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quote)},
  641.   { "RADIANS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_radians)},
  642.   { "RAND", SYM(RAND)},
  643.   { "RELEASE_LOCK", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_release_lock)},
  644.   { "REPEAT", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_repeat)},
  645.   { "REVERSE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_reverse)},
  646.   { "ROUND", SYM(ROUND)},
  647.   { "RPAD", F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_rpad)},
  648.   { "RTRIM", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_rtrim)},
  649.   { "SEC_TO_TIME", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sec_to_time)},
  650.   { "SESSION_USER", SYM(USER)},
  651.   { "SUBDATE", SYM(SUBDATE_SYM)},
  652.   { "SIGN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sign)},
  653.   { "SIN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sin)},
  654.   { "SHA",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
  655.   { "SHA1",             F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
  656.   { "SOUNDEX", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_soundex)},
  657.   { "SPACE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_space)},
  658.   { "SQRT", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sqrt)},
  659.   { "SRID", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_srid)},
  660.   { "STARTPOINT", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_startpoint)},
  661.   { "STD", SYM(STD_SYM)},
  662.   { "STDDEV", SYM(STD_SYM)},
  663.   { "STR_TO_DATE", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_str_to_date)},
  664.   { "STRCMP", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_strcmp)},
  665.   { "SUBSTR", SYM(SUBSTRING)},
  666.   { "SUBSTRING", SYM(SUBSTRING)},
  667.   { "SUBSTRING_INDEX", SYM(SUBSTRING_INDEX)},
  668.   { "SUBTIME",          F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_subtime)},
  669.   { "SUM", SYM(SUM_SYM)},
  670.   { "SYSDATE", SYM(NOW_SYM)},
  671.   { "SYSTEM_USER", SYM(USER)},
  672.   { "TAN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_tan)},
  673.   { "TIME_FORMAT", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_time_format)},
  674.   { "TIME_TO_SEC", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_time_to_sec)},
  675.   { "TIMEDIFF",         F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_timediff)},
  676.   { "TO_DAYS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_to_days)},
  677.   { "TOUCHES", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
  678.   { "TRIM", SYM(TRIM)},
  679.   { "UCASE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
  680.   { "UNCOMPRESS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompress)},
  681.   { "UNCOMPRESSED_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompressed_length)},
  682.   { "UNHEX", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_unhex)},
  683.   { "UNIQUE_USERS", SYM(UNIQUE_USERS)},
  684.   { "UNIX_TIMESTAMP", SYM(UNIX_TIMESTAMP)},
  685.   { "UPPER", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
  686.   { "UUID", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_uuid)},
  687.   { "VARIANCE", SYM(VARIANCE_SYM)},
  688.   { "VERSION", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)},
  689.   { "WEEK", SYM(WEEK_SYM)},
  690.   { "WEEKDAY", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekday)},
  691.   { "WEEKOFYEAR", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekofyear)},
  692.   { "WITHIN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
  693.   { "X", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_x)},
  694.   { "Y", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_y)},
  695.   { "YEARWEEK", SYM(YEARWEEK)}
  696. };