Bug#21114 (Foreign key creation fails to table with name format)

Due to the complexity of this change, everything is documented in WL#3565

This patch is the third iteration, it takes into account the comments
received to date.


mysql-test/r/func_math.result:
  Improved test coverage
mysql-test/r/view.result:
  Name collision, x() is a geometry native in function
mysql-test/t/func_math.test:
  Improved test coverage
mysql-test/t/view.test:
  Name collision, x() is a geometry native in function
sql/item_create.cc:
  Revised the create_func implementation
sql/item_create.h:
  Revised the create_func implementation
sql/item_geofunc.h:
  Explicit Item allocation in the thread memory pool.
sql/lex.h:
  Removed function parsing from the lexical parser
sql/lex_symbol.h:
  Removed function parsing from the lexical parser
sql/mysql_priv.h:
  Server initialization and shutdown
sql/mysqld.cc:
  Server initialization and shutdown
sql/share/errmsg.txt:
  New error messages
sql/sql_yacc.yy:
  Removed function parsing from the lexical parser
tests/mysql_client_test.c:
  Spaces are no longer significant for function calls
mysql-test/include/parser_bug21114.inc:
  New tests
mysql-test/r/parser.result:
  New tests
mysql-test/r/parser_bug21114_innodb.result:
  New tests
mysql-test/t/parser.test:
  New tests
mysql-test/t/parser_bug21114_innodb.test:
  New tests

19 files changed, 7628 insertions, 1463 deletions

diff --git a/mysql-test/include/parser_bug21114.inc b/mysql-test/include/parser_bug21114.inc
new file mode 100755
index 00000000000..eb709d5cc03
--- /dev/null
+++ b/mysql-test/include/parser_bug21114.inc
@@ -0,0 +1,59 @@
+#
+# Bug#21114 (Foreign key creation fails to table with name format)
+#
+# Trying to trick the parser into thinking $FCT(...) is a function call,
+# which is not in the CREATE TABLE and FOREIGN KEY ... REFERENCES syntax
+#
+# Usage :
+#
+# let $engine_type=InnoDb;
+# let $verbose=1;
+# let $FCT= <value_1>;
+# -- source parser_stress_func.inc
+# let $FCT= <value_2>;
+# -- source parser_stress_func.inc
+# let $verbose=0;
+# let $FCT= <value_3>;
+# -- source parser_stress_func.inc
+# let $FCT= <value_4>;
+# -- source parser_stress_func.inc
+
+-- disable_warnings
+eval drop table if exists $FCT;
+drop table if exists bug21114_child;
+-- enable_warnings
+
+--disable_query_log
+--disable_result_log
+
+eval CREATE TABLE $FCT(
+  col1 int not null,
+  col2 int not null,
+  col3 varchar(10),
+  CONSTRAINT pk PRIMARY KEY (col1, col2)
+) ENGINE $engine_type;
+
+eval CREATE TABLE bug21114_child(
+  pk int not null,
+  fk_col1 int not null,
+  fk_col2 int not null,
+  fk_col3 int not null,
+  fk_col4 int not null,
+  CONSTRAINT fk_fct FOREIGN KEY (fk_col1, fk_col2)
+    REFERENCES $FCT(col1, col2),
+  CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4)
+    REFERENCES $FCT (col1, col2)
+) ENGINE $engine_type;
+
+--enable_query_log
+--enable_result_log
+
+if ($verbose)
+{
+  eval SHOW CREATE TABLE $FCT;
+  SHOW CREATE TABLE bug21114_child;
+}
+
+DROP TABLE bug21114_child;
+eval DROP TABLE $FCT;
+
diff --git a/mysql-test/r/func_math.result b/mysql-test/r/func_math.result
index 4bd18ae589e..9a2c55b802d 100644
--- a/mysql-test/r/func_math.result
+++ b/mysql-test/r/func_math.result
@@ -102,6 +102,18 @@ Note	1003	select pi() AS `pi()`,format(sin((pi() / 2)),6) AS `format(sin(pi()/2)
 select degrees(pi()),radians(360);
 degrees(pi())	radians(360)
 180	6.2831853071796
+select format(atan(-2, 2), 6);
+format(atan(-2, 2), 6)
+-0.785398
+select format(atan(pi(), 0), 6);
+format(atan(pi(), 0), 6)
+1.570796
+select format(atan2(-2, 2), 6);
+format(atan2(-2, 2), 6)
+-0.785398
+select format(atan2(pi(), 0), 6);
+format(atan2(pi(), 0), 6)
+1.570796
 SELECT ACOS(1.0);
 ACOS(1.0)
 0
diff --git a/mysql-test/r/parser.result b/mysql-test/r/parser.result
new file mode 100644
index 00000000000..afd78561898
--- /dev/null
+++ b/mysql-test/r/parser.result
@@ -0,0 +1,388 @@
+SET @save_sql_mode=@@sql_mode;
+set SQL_MODE='';
+create table ADDDATE(a int);
+drop table ADDDATE;
+create table ADDDATE (a int);
+drop table ADDDATE;
+create table BIT_AND(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_AND(a int)' at line 1
+create table BIT_AND (a int);
+drop table BIT_AND;
+create table BIT_OR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_OR(a int)' at line 1
+create table BIT_OR (a int);
+drop table BIT_OR;
+create table BIT_XOR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_XOR(a int)' at line 1
+create table BIT_XOR (a int);
+drop table BIT_XOR;
+create table CAST(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CAST(a int)' at line 1
+create table CAST (a int);
+drop table CAST;
+create table COUNT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'COUNT(a int)' at line 1
+create table COUNT (a int);
+drop table COUNT;
+create table CURDATE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURDATE(a int)' at line 1
+create table CURDATE (a int);
+drop table CURDATE;
+create table CURTIME(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURTIME(a int)' at line 1
+create table CURTIME (a int);
+drop table CURTIME;
+create table DATE_ADD(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_ADD(a int)' at line 1
+create table DATE_ADD (a int);
+drop table DATE_ADD;
+create table DATE_SUB(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_SUB(a int)' at line 1
+create table DATE_SUB (a int);
+drop table DATE_SUB;
+create table EXTRACT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'EXTRACT(a int)' at line 1
+create table EXTRACT (a int);
+drop table EXTRACT;
+create table GROUP_CONCAT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_CONCAT(a int)' at line 1
+create table GROUP_CONCAT (a int);
+drop table GROUP_CONCAT;
+create table GROUP_UNIQUE_USERS(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_UNIQUE_USERS(a int)' at line 1
+create table GROUP_UNIQUE_USERS (a int);
+drop table GROUP_UNIQUE_USERS;
+create table MAX(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MAX(a int)' at line 1
+create table MAX (a int);
+drop table MAX;
+create table MID(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MID(a int)' at line 1
+create table MID (a int);
+drop table MID;
+create table MIN(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MIN(a int)' at line 1
+create table MIN (a int);
+drop table MIN;
+create table NOW(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'NOW(a int)' at line 1
+create table NOW (a int);
+drop table NOW;
+create table POSITION(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'POSITION(a int)' at line 1
+create table POSITION (a int);
+drop table POSITION;
+create table SESSION_USER(a int);
+drop table SESSION_USER;
+create table SESSION_USER (a int);
+drop table SESSION_USER;
+create table STD(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STD(a int)' at line 1
+create table STD (a int);
+drop table STD;
+create table STDDEV(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV(a int)' at line 1
+create table STDDEV (a int);
+drop table STDDEV;
+create table STDDEV_POP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_POP(a int)' at line 1
+create table STDDEV_POP (a int);
+drop table STDDEV_POP;
+create table STDDEV_SAMP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_SAMP(a int)' at line 1
+create table STDDEV_SAMP (a int);
+drop table STDDEV_SAMP;
+create table SUBDATE(a int);
+drop table SUBDATE;
+create table SUBDATE (a int);
+drop table SUBDATE;
+create table SUBSTR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTR(a int)' at line 1
+create table SUBSTR (a int);
+drop table SUBSTR;
+create table SUBSTRING(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTRING(a int)' at line 1
+create table SUBSTRING (a int);
+drop table SUBSTRING;
+create table SUM(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUM(a int)' at line 1
+create table SUM (a int);
+drop table SUM;
+create table SYSDATE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SYSDATE(a int)' at line 1
+create table SYSDATE (a int);
+drop table SYSDATE;
+create table SYSTEM_USER(a int);
+drop table SYSTEM_USER;
+create table SYSTEM_USER (a int);
+drop table SYSTEM_USER;
+create table TRIM(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'TRIM(a int)' at line 1
+create table TRIM (a int);
+drop table TRIM;
+create table UNIQUE_USERS(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'UNIQUE_USERS(a int)' at line 1
+create table UNIQUE_USERS (a int);
+drop table UNIQUE_USERS;
+create table VARIANCE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VARIANCE(a int)' at line 1
+create table VARIANCE (a int);
+drop table VARIANCE;
+create table VAR_POP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_POP(a int)' at line 1
+create table VAR_POP (a int);
+drop table VAR_POP;
+create table VAR_SAMP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_SAMP(a int)' at line 1
+create table VAR_SAMP (a int);
+drop table VAR_SAMP;
+set SQL_MODE='IGNORE_SPACE';
+create table ADDDATE(a int);
+drop table ADDDATE;
+create table ADDDATE (a int);
+drop table ADDDATE;
+create table BIT_AND(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_AND(a int)' at line 1
+create table BIT_AND (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_AND (a int)' at line 1
+create table BIT_OR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_OR(a int)' at line 1
+create table BIT_OR (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_OR (a int)' at line 1
+create table BIT_XOR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_XOR(a int)' at line 1
+create table BIT_XOR (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BIT_XOR (a int)' at line 1
+create table CAST(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CAST(a int)' at line 1
+create table CAST (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CAST (a int)' at line 1
+create table COUNT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'COUNT(a int)' at line 1
+create table COUNT (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'COUNT (a int)' at line 1
+create table CURDATE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURDATE(a int)' at line 1
+create table CURDATE (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURDATE (a int)' at line 1
+create table CURTIME(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURTIME(a int)' at line 1
+create table CURTIME (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'CURTIME (a int)' at line 1
+create table DATE_ADD(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_ADD(a int)' at line 1
+create table DATE_ADD (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_ADD (a int)' at line 1
+create table DATE_SUB(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_SUB(a int)' at line 1
+create table DATE_SUB (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DATE_SUB (a int)' at line 1
+create table EXTRACT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'EXTRACT(a int)' at line 1
+create table EXTRACT (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'EXTRACT (a int)' at line 1
+create table GROUP_CONCAT(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_CONCAT(a int)' at line 1
+create table GROUP_CONCAT (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_CONCAT (a int)' at line 1
+create table GROUP_UNIQUE_USERS(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_UNIQUE_USERS(a int)' at line 1
+create table GROUP_UNIQUE_USERS (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'GROUP_UNIQUE_USERS (a int)' at line 1
+create table MAX(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MAX(a int)' at line 1
+create table MAX (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MAX (a int)' at line 1
+create table MID(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MID(a int)' at line 1
+create table MID (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MID (a int)' at line 1
+create table MIN(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MIN(a int)' at line 1
+create table MIN (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'MIN (a int)' at line 1
+create table NOW(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'NOW(a int)' at line 1
+create table NOW (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'NOW (a int)' at line 1
+create table POSITION(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'POSITION(a int)' at line 1
+create table POSITION (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'POSITION (a int)' at line 1
+create table SESSION_USER(a int);
+drop table SESSION_USER;
+create table SESSION_USER (a int);
+drop table SESSION_USER;
+create table STD(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STD(a int)' at line 1
+create table STD (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STD (a int)' at line 1
+create table STDDEV(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV(a int)' at line 1
+create table STDDEV (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV (a int)' at line 1
+create table STDDEV_POP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_POP(a int)' at line 1
+create table STDDEV_POP (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_POP (a int)' at line 1
+create table STDDEV_SAMP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_SAMP(a int)' at line 1
+create table STDDEV_SAMP (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'STDDEV_SAMP (a int)' at line 1
+create table SUBDATE(a int);
+drop table SUBDATE;
+create table SUBDATE (a int);
+drop table SUBDATE;
+create table SUBSTR(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTR(a int)' at line 1
+create table SUBSTR (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTR (a int)' at line 1
+create table SUBSTRING(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTRING(a int)' at line 1
+create table SUBSTRING (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUBSTRING (a int)' at line 1
+create table SUM(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUM(a int)' at line 1
+create table SUM (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SUM (a int)' at line 1
+create table SYSDATE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SYSDATE(a int)' at line 1
+create table SYSDATE (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SYSDATE (a int)' at line 1
+create table SYSTEM_USER(a int);
+drop table SYSTEM_USER;
+create table SYSTEM_USER (a int);
+drop table SYSTEM_USER;
+create table TRIM(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'TRIM(a int)' at line 1
+create table TRIM (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'TRIM (a int)' at line 1
+create table UNIQUE_USERS(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'UNIQUE_USERS(a int)' at line 1
+create table UNIQUE_USERS (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'UNIQUE_USERS (a int)' at line 1
+create table VARIANCE(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VARIANCE(a int)' at line 1
+create table VARIANCE (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VARIANCE (a int)' at line 1
+create table VAR_POP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_POP(a int)' at line 1
+create table VAR_POP (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_POP (a int)' at line 1
+create table VAR_SAMP(a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_SAMP(a int)' at line 1
+create table VAR_SAMP (a int);
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VAR_SAMP (a int)' at line 1
+SET @@sql_mode=@save_sql_mode;
+select pi(3.14);
+ERROR 42000: Incorrect parameter count in the call to native function 'pi'
+select tan();
+ERROR 42000: Incorrect parameter count in the call to native function 'tan'
+select tan(1, 2);
+ERROR 42000: Incorrect parameter count in the call to native function 'tan'
+select makedate(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'makedate'
+select makedate(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'makedate'
+select maketime();
+ERROR 42000: Incorrect parameter count in the call to native function 'maketime'
+select maketime(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'maketime'
+select maketime(1, 2);
+ERROR 42000: Incorrect parameter count in the call to native function 'maketime'
+select maketime(1, 2, 3, 4);
+ERROR 42000: Incorrect parameter count in the call to native function 'maketime'
+select atan();
+ERROR 42000: Incorrect parameter count in the call to native function 'atan'
+select atan2(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'atan2'
+select benchmark(10, 1+1);
+benchmark(10, 1+1)
+0
+select benchmark(5+5, 2);
+ERROR 42000: Incorrect parameters in the call to native function 'BENCHMARK'
+select concat();
+ERROR 42000: Incorrect parameter count in the call to native function 'concat'
+select concat("foo");
+concat("foo")
+foo
+select concat_ws();
+ERROR 42000: Incorrect parameter count in the call to native function 'concat_ws'
+select concat_ws("foo");
+ERROR 42000: Incorrect parameter count in the call to native function 'concat_ws'
+set @pwd="my password";
+select encode("secret", @pwd);
+ERROR 42000: Incorrect parameters in the call to native function 'ENCODE'
+select decode("encoded-secret", @pwd);
+ERROR 42000: Incorrect parameters in the call to native function 'DECODE'
+select encrypt();
+ERROR 42000: Incorrect parameter count in the call to native function 'encrypt'
+select encrypt(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'encrypt'
+select des_encrypt("p1", "p2", "not expected");
+ERROR 42000: Incorrect parameter count in the call to native function 'des_encrypt'
+select des_decrypt("p1", "p2", "not expected");
+ERROR 42000: Incorrect parameter count in the call to native function 'des_decrypt'
+select elt();
+ERROR 42000: Incorrect parameter count in the call to native function 'elt'
+select elt(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'elt'
+select export_set();
+ERROR 42000: Incorrect parameter count in the call to native function 'export_set'
+select export_set("p1");
+ERROR 42000: Incorrect parameter count in the call to native function 'export_set'
+select export_set("p1", "p2");
+ERROR 42000: Incorrect parameter count in the call to native function 'export_set'
+select export_set("p1", "p2", "p3", "p4", "p5", "p6");
+ERROR 42000: Incorrect parameter count in the call to native function 'export_set'
+select field();
+ERROR 42000: Incorrect parameter count in the call to native function 'field'
+select field("p1");
+ERROR 42000: Incorrect parameter count in the call to native function 'field'
+set @dec=2;
+select format(pi(), @dec);
+ERROR 42000: Incorrect parameters in the call to native function 'FORMAT'
+select from_unixtime();
+ERROR 42000: Incorrect parameter count in the call to native function 'from_unixtime'
+select from_unixtime(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'from_unixtime'
+select unix_timestamp(1, 2);
+ERROR 42000: Incorrect parameter count in the call to native function 'unix_timestamp'
+select greatest();
+ERROR 42000: Incorrect parameter count in the call to native function 'greatest'
+select greatest(12);
+ERROR 42000: Incorrect parameter count in the call to native function 'greatest'
+select last_insert_id(1, 2);
+ERROR 42000: Incorrect parameter count in the call to native function 'last_insert_id'
+select least();
+ERROR 42000: Incorrect parameter count in the call to native function 'least'
+select least(12);
+ERROR 42000: Incorrect parameter count in the call to native function 'least'
+select locate();
+ERROR 42000: Incorrect parameter count in the call to native function 'locate'
+select locate(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'locate'
+select locate(1, 2, 3, 4);
+ERROR 42000: Incorrect parameter count in the call to native function 'locate'
+select log();
+ERROR 42000: Incorrect parameter count in the call to native function 'log'
+select log(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'log'
+select make_set();
+ERROR 42000: Incorrect parameter count in the call to native function 'make_set'
+select make_set(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'make_set'
+select master_pos_wait();
+ERROR 42000: Incorrect parameter count in the call to native function 'master_pos_wait'
+select master_pos_wait(1);
+ERROR 42000: Incorrect parameter count in the call to native function 'master_pos_wait'
+select master_pos_wait(1, 2, 3, 4);
+ERROR 42000: Incorrect parameter count in the call to native function 'master_pos_wait'
+select rand(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'rand'
+select round(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'round'
+select yearweek();
+ERROR 42000: Incorrect parameter count in the call to native function 'yearweek'
+select yearweek(1, 2, 3);
+ERROR 42000: Incorrect parameter count in the call to native function 'yearweek'
diff --git a/mysql-test/r/parser_bug21114_innodb.result b/mysql-test/r/parser_bug21114_innodb.result
new file mode 100644
index 00000000000..d3ceda38979
--- /dev/null
+++ b/mysql-test/r/parser_bug21114_innodb.result
@@ -0,0 +1,867 @@
+drop table if exists ABS;
+drop table if exists bug21114_child;
+SHOW CREATE TABLE ABS;
+Table	Create Table
+ABS	CREATE TABLE `ABS` (
+  `col1` int(11) NOT NULL,
+  `col2` int(11) NOT NULL,
+  `col3` varchar(10) DEFAULT NULL,
+  PRIMARY KEY (`col1`,`col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+SHOW CREATE TABLE bug21114_child;
+Table	Create Table
+bug21114_child	CREATE TABLE `bug21114_child` (
+  `pk` int(11) NOT NULL,
+  `fk_col1` int(11) NOT NULL,
+  `fk_col2` int(11) NOT NULL,
+  `fk_col3` int(11) NOT NULL,
+  `fk_col4` int(11) NOT NULL,
+  KEY `fk_fct` (`fk_col1`,`fk_col2`),
+  KEY `fk_fct_space` (`fk_col3`,`fk_col4`),
+  CONSTRAINT `fk_fct` FOREIGN KEY (`fk_col1`, `fk_col2`) REFERENCES `ABS` (`col1`, `col2`),
+  CONSTRAINT `fk_fct_space` FOREIGN KEY (`fk_col3`, `fk_col4`) REFERENCES `ABS` (`col1`, `col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+DROP TABLE bug21114_child;
+DROP TABLE ABS;
+drop table if exists FIELD;
+drop table if exists bug21114_child;
+SHOW CREATE TABLE FIELD;
+Table	Create Table
+FIELD	CREATE TABLE `FIELD` (
+  `col1` int(11) NOT NULL,
+  `col2` int(11) NOT NULL,
+  `col3` varchar(10) DEFAULT NULL,
+  PRIMARY KEY (`col1`,`col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+SHOW CREATE TABLE bug21114_child;
+Table	Create Table
+bug21114_child	CREATE TABLE `bug21114_child` (
+  `pk` int(11) NOT NULL,
+  `fk_col1` int(11) NOT NULL,
+  `fk_col2` int(11) NOT NULL,
+  `fk_col3` int(11) NOT NULL,
+  `fk_col4` int(11) NOT NULL,
+  KEY `fk_fct` (`fk_col1`,`fk_col2`),
+  KEY `fk_fct_space` (`fk_col3`,`fk_col4`),
+  CONSTRAINT `fk_fct` FOREIGN KEY (`fk_col1`, `fk_col2`) REFERENCES `FIELD` (`col1`, `col2`),
+  CONSTRAINT `fk_fct_space` FOREIGN KEY (`fk_col3`, `fk_col4`) REFERENCES `FIELD` (`col1`, `col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+DROP TABLE bug21114_child;
+DROP TABLE FIELD;
+drop table if exists FORMAT;
+drop table if exists bug21114_child;
+SHOW CREATE TABLE FORMAT;
+Table	Create Table
+FORMAT	CREATE TABLE `FORMAT` (
+  `col1` int(11) NOT NULL,
+  `col2` int(11) NOT NULL,
+  `col3` varchar(10) DEFAULT NULL,
+  PRIMARY KEY (`col1`,`col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+SHOW CREATE TABLE bug21114_child;
+Table	Create Table
+bug21114_child	CREATE TABLE `bug21114_child` (
+  `pk` int(11) NOT NULL,
+  `fk_col1` int(11) NOT NULL,
+  `fk_col2` int(11) NOT NULL,
+  `fk_col3` int(11) NOT NULL,
+  `fk_col4` int(11) NOT NULL,
+  KEY `fk_fct` (`fk_col1`,`fk_col2`),
+  KEY `fk_fct_space` (`fk_col3`,`fk_col4`),
+  CONSTRAINT `fk_fct` FOREIGN KEY (`fk_col1`, `fk_col2`) REFERENCES `FORMAT` (`col1`, `col2`),
+  CONSTRAINT `fk_fct_space` FOREIGN KEY (`fk_col3`, `fk_col4`) REFERENCES `FORMAT` (`col1`, `col2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1
+DROP TABLE bug21114_child;
+DROP TABLE FORMAT;
+drop table if exists ACOS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ACOS;
+drop table if exists ADDDATE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ADDDATE;
+drop table if exists ADDTIME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ADDTIME;
+drop table if exists AES_DECRYPT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE AES_DECRYPT;
+drop table if exists AES_ENCRYPT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE AES_ENCRYPT;
+drop table if exists AREA;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE AREA;
+drop table if exists ASBINARY;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ASBINARY;
+drop table if exists ASIN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ASIN;
+drop table if exists ASTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ASTEXT;
+drop table if exists ASWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ASWKB;
+drop table if exists ASWKT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ASWKT;
+drop table if exists ATAN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ATAN;
+drop table if exists ATAN2;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ATAN2;
+drop table if exists BENCHMARK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE BENCHMARK;
+drop table if exists BIN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE BIN;
+drop table if exists BIT_COUNT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE BIT_COUNT;
+drop table if exists BIT_LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE BIT_LENGTH;
+drop table if exists CEIL;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CEIL;
+drop table if exists CEILING;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CEILING;
+drop table if exists CENTROID;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CENTROID;
+drop table if exists CHARACTER_LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CHARACTER_LENGTH;
+drop table if exists CHAR_LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CHAR_LENGTH;
+drop table if exists COERCIBILITY;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE COERCIBILITY;
+drop table if exists COMPRESS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE COMPRESS;
+drop table if exists CONCAT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CONCAT;
+drop table if exists CONCAT_WS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CONCAT_WS;
+drop table if exists CONNECTION_ID;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CONNECTION_ID;
+drop table if exists CONV;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CONV;
+drop table if exists CONVERT_TZ;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CONVERT_TZ;
+drop table if exists COS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE COS;
+drop table if exists COT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE COT;
+drop table if exists CRC32;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CRC32;
+drop table if exists CROSSES;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE CROSSES;
+drop table if exists DATEDIFF;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DATEDIFF;
+drop table if exists DATE_FORMAT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DATE_FORMAT;
+drop table if exists DAYNAME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DAYNAME;
+drop table if exists DAYOFMONTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DAYOFMONTH;
+drop table if exists DAYOFWEEK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DAYOFWEEK;
+drop table if exists DAYOFYEAR;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DAYOFYEAR;
+drop table if exists DECODE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DECODE;
+drop table if exists DEGREES;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DEGREES;
+drop table if exists DES_DECRYPT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DES_DECRYPT;
+drop table if exists DES_ENCRYPT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DES_ENCRYPT;
+drop table if exists DIMENSION;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DIMENSION;
+drop table if exists DISJOINT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE DISJOINT;
+drop table if exists ELT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ELT;
+drop table if exists ENCODE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ENCODE;
+drop table if exists ENCRYPT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ENCRYPT;
+drop table if exists ENDPOINT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ENDPOINT;
+drop table if exists ENVELOPE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ENVELOPE;
+drop table if exists EQUALS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE EQUALS;
+drop table if exists EXP;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE EXP;
+drop table if exists EXPORT_SET;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE EXPORT_SET;
+drop table if exists EXTERIORRING;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE EXTERIORRING;
+drop table if exists EXTRACTVALUE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE EXTRACTVALUE;
+drop table if exists FIND_IN_SET;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE FIND_IN_SET;
+drop table if exists FLOOR;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE FLOOR;
+drop table if exists FOUND_ROWS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE FOUND_ROWS;
+drop table if exists FROM_DAYS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE FROM_DAYS;
+drop table if exists FROM_UNIXTIME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE FROM_UNIXTIME;
+drop table if exists GEOMCOLLFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMCOLLFROMTEXT;
+drop table if exists GEOMCOLLFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMCOLLFROMWKB;
+drop table if exists GEOMETRYCOLLECTIONFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYCOLLECTIONFROMTEXT;
+drop table if exists GEOMETRYCOLLECTIONFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYCOLLECTIONFROMWKB;
+drop table if exists GEOMETRYFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYFROMTEXT;
+drop table if exists GEOMETRYFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYFROMWKB;
+drop table if exists GEOMETRYN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYN;
+drop table if exists GEOMETRYTYPE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMETRYTYPE;
+drop table if exists GEOMFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMFROMTEXT;
+drop table if exists GEOMFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GEOMFROMWKB;
+drop table if exists GET_LOCK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GET_LOCK;
+drop table if exists GLENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GLENGTH;
+drop table if exists GREATEST;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE GREATEST;
+drop table if exists HEX;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE HEX;
+drop table if exists IFNULL;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE IFNULL;
+drop table if exists INET_ATON;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE INET_ATON;
+drop table if exists INET_NTOA;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE INET_NTOA;
+drop table if exists INSTR;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE INSTR;
+drop table if exists INTERIORRINGN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE INTERIORRINGN;
+drop table if exists INTERSECTS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE INTERSECTS;
+drop table if exists ISCLOSED;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ISCLOSED;
+drop table if exists ISEMPTY;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ISEMPTY;
+drop table if exists ISNULL;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ISNULL;
+drop table if exists ISSIMPLE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ISSIMPLE;
+drop table if exists IS_FREE_LOCK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE IS_FREE_LOCK;
+drop table if exists IS_USED_LOCK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE IS_USED_LOCK;
+drop table if exists LAST_DAY;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LAST_DAY;
+drop table if exists LAST_INSERT_ID;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LAST_INSERT_ID;
+drop table if exists LCASE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LCASE;
+drop table if exists LEAST;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LEAST;
+drop table if exists LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LENGTH;
+drop table if exists LINEFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LINEFROMTEXT;
+drop table if exists LINEFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LINEFROMWKB;
+drop table if exists LINESTRINGFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LINESTRINGFROMTEXT;
+drop table if exists LINESTRINGFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LINESTRINGFROMWKB;
+drop table if exists LN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LN;
+drop table if exists LOAD_FILE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOAD_FILE;
+drop table if exists LOCATE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOCATE;
+drop table if exists LOG;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOG;
+drop table if exists LOG10;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOG10;
+drop table if exists LOG2;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOG2;
+drop table if exists LOWER;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LOWER;
+drop table if exists LPAD;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LPAD;
+drop table if exists LTRIM;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE LTRIM;
+drop table if exists MAKEDATE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MAKEDATE;
+drop table if exists MAKETIME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MAKETIME;
+drop table if exists MAKE_SET;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MAKE_SET;
+drop table if exists MASTER_POS_WAIT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MASTER_POS_WAIT;
+drop table if exists MBRCONTAINS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBRCONTAINS;
+drop table if exists MBRDISJOINT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBRDISJOINT;
+drop table if exists MBREQUAL;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBREQUAL;
+drop table if exists MBRINTERSECTS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBRINTERSECTS;
+drop table if exists MBROVERLAPS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBROVERLAPS;
+drop table if exists MBRTOUCHES;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBRTOUCHES;
+drop table if exists MBRWITHIN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MBRWITHIN;
+drop table if exists MD5;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MD5;
+drop table if exists MLINEFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MLINEFROMTEXT;
+drop table if exists MLINEFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MLINEFROMWKB;
+drop table if exists MONTHNAME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MONTHNAME;
+drop table if exists MPOINTFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MPOINTFROMTEXT;
+drop table if exists MPOINTFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MPOINTFROMWKB;
+drop table if exists MPOLYFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MPOLYFROMTEXT;
+drop table if exists MPOLYFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MPOLYFROMWKB;
+drop table if exists MULTILINESTRINGFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTILINESTRINGFROMTEXT;
+drop table if exists MULTILINESTRINGFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTILINESTRINGFROMWKB;
+drop table if exists MULTIPOINTFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTIPOINTFROMTEXT;
+drop table if exists MULTIPOINTFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTIPOINTFROMWKB;
+drop table if exists MULTIPOLYGONFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTIPOLYGONFROMTEXT;
+drop table if exists MULTIPOLYGONFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE MULTIPOLYGONFROMWKB;
+drop table if exists NAME_CONST;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE NAME_CONST;
+drop table if exists NULLIF;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE NULLIF;
+drop table if exists NUMGEOMETRIES;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE NUMGEOMETRIES;
+drop table if exists NUMINTERIORRINGS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE NUMINTERIORRINGS;
+drop table if exists NUMPOINTS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE NUMPOINTS;
+drop table if exists OCT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE OCT;
+drop table if exists OCTET_LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE OCTET_LENGTH;
+drop table if exists ORD;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ORD;
+drop table if exists OVERLAPS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE OVERLAPS;
+drop table if exists PERIOD_ADD;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE PERIOD_ADD;
+drop table if exists PERIOD_DIFF;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE PERIOD_DIFF;
+drop table if exists PI;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE PI;
+drop table if exists POINTFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POINTFROMTEXT;
+drop table if exists POINTFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POINTFROMWKB;
+drop table if exists POINTN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POINTN;
+drop table if exists POLYFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POLYFROMTEXT;
+drop table if exists POLYFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POLYFROMWKB;
+drop table if exists POLYGONFROMTEXT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POLYGONFROMTEXT;
+drop table if exists POLYGONFROMWKB;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POLYGONFROMWKB;
+drop table if exists POW;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POW;
+drop table if exists POWER;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE POWER;
+drop table if exists QUOTE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE QUOTE;
+drop table if exists RADIANS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE RADIANS;
+drop table if exists RAND;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE RAND;
+drop table if exists RELEASE_LOCK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE RELEASE_LOCK;
+drop table if exists REVERSE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE REVERSE;
+drop table if exists ROUND;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ROUND;
+drop table if exists ROW_COUNT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE ROW_COUNT;
+drop table if exists RPAD;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE RPAD;
+drop table if exists RTRIM;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE RTRIM;
+drop table if exists SEC_TO_TIME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SEC_TO_TIME;
+drop table if exists SESSION_USER;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SESSION_USER;
+drop table if exists SHA;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SHA;
+drop table if exists SHA1;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SHA1;
+drop table if exists SIGN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SIGN;
+drop table if exists SIN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SIN;
+drop table if exists SLEEP;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SLEEP;
+drop table if exists SOUNDEX;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SOUNDEX;
+drop table if exists SPACE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SPACE;
+drop table if exists SQRT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SQRT;
+drop table if exists SRID;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SRID;
+drop table if exists STARTPOINT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE STARTPOINT;
+drop table if exists STRCMP;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE STRCMP;
+drop table if exists STR_TO_DATE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE STR_TO_DATE;
+drop table if exists SUBDATE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SUBDATE;
+drop table if exists SUBSTRING_INDEX;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SUBSTRING_INDEX;
+drop table if exists SUBTIME;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SUBTIME;
+drop table if exists SYSTEM_USER;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE SYSTEM_USER;
+drop table if exists TAN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TAN;
+drop table if exists TIMEDIFF;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TIMEDIFF;
+drop table if exists TIME_FORMAT;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TIME_FORMAT;
+drop table if exists TIME_TO_SEC;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TIME_TO_SEC;
+drop table if exists TOUCHES;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TOUCHES;
+drop table if exists TO_DAYS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE TO_DAYS;
+drop table if exists UCASE;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UCASE;
+drop table if exists UNCOMPRESS;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UNCOMPRESS;
+drop table if exists UNCOMPRESSED_LENGTH;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UNCOMPRESSED_LENGTH;
+drop table if exists UNHEX;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UNHEX;
+drop table if exists UNIX_TIMESTAMP;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UNIX_TIMESTAMP;
+drop table if exists UPDATEXML;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UPDATEXML;
+drop table if exists UPPER;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UPPER;
+drop table if exists UUID;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE UUID;
+drop table if exists VERSION;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE VERSION;
+drop table if exists WEEKDAY;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE WEEKDAY;
+drop table if exists WEEKOFYEAR;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE WEEKOFYEAR;
+drop table if exists WITHIN;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE WITHIN;
+drop table if exists X;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE X;
+drop table if exists Y;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE Y;
+drop table if exists YEARWEEK;
+drop table if exists bug21114_child;
+DROP TABLE bug21114_child;
+DROP TABLE YEARWEEK;
diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 7c467749ee6..1cdb782b2fe 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -791,13 +791,13 @@ test.`f``1` ()
 5
 drop view v1;
 drop function `f``1`;
-create function x () returns int return 5;
-create view v1 as select x ();
+create function a() returns int return 5;
+create view v1 as select a();
 select * from v1;
-x ()
+a()
 5
 drop view v1;
-drop function x;
+drop function a;
 create table t2 (col1 char collate latin1_german2_ci);
 create view v2 as select col1 collate latin1_german1_ci from t2;
 show create view v2;
diff --git a/mysql-test/t/func_math.test b/mysql-test/t/func_math.test
index 4041c267134..09aa5751301 100644
--- a/mysql-test/t/func_math.test
+++ b/mysql-test/t/func_math.test
@@ -34,6 +34,11 @@ select pi(),format(sin(pi()/2),6),format(cos(pi()/2),6),format(abs(tan(pi())),6)
 explain extended select pi(),format(sin(pi()/2),6),format(cos(pi()/2),6),format(abs(tan(pi())),6),format(cot(1),6),format(asin(1),6),format(acos(0),6),format(atan(1),6);
 select degrees(pi()),radians(360);
 
+select format(atan(-2, 2), 6);
+select format(atan(pi(), 0), 6);
+select format(atan2(-2, 2), 6);
+select format(atan2(pi(), 0), 6);
+
 #
 # Bug #2338 Trignometric arithmatic problems 
 #
diff --git a/mysql-test/t/parser.test b/mysql-test/t/parser.test
new file mode 100644
index 00000000000..11af7c691d8
--- /dev/null
+++ b/mysql-test/t/parser.test
@@ -0,0 +1,510 @@
+#
+# This file contains tests covering the parser
+#
+
+#=============================================================================
+# LEXICAL PARSER (lex)
+#=============================================================================
+
+SET @save_sql_mode=@@sql_mode;
+
+#
+# Documenting the current behavior, to detect incompatible changes.
+# In each cases:
+# - no error is the correct result
+# - an error is the expected result with the current implementation,
+#   and is a limitation.
+
+set SQL_MODE='';
+
+create table ADDDATE(a int);
+drop table ADDDATE;
+create table ADDDATE (a int);
+drop table ADDDATE;
+
+--error ER_PARSE_ERROR
+create table BIT_AND(a int);
+create table BIT_AND (a int);
+drop table BIT_AND;
+
+--error ER_PARSE_ERROR
+create table BIT_OR(a int);
+create table BIT_OR (a int);
+drop table BIT_OR;
+
+--error ER_PARSE_ERROR
+create table BIT_XOR(a int);
+create table BIT_XOR (a int);
+drop table BIT_XOR;
+
+--error ER_PARSE_ERROR
+create table CAST(a int);
+create table CAST (a int);
+drop table CAST;
+
+--error ER_PARSE_ERROR
+create table COUNT(a int);
+create table COUNT (a int);
+drop table COUNT;
+
+--error ER_PARSE_ERROR
+create table CURDATE(a int);
+create table CURDATE (a int);
+drop table CURDATE;
+
+--error ER_PARSE_ERROR
+create table CURTIME(a int);
+create table CURTIME (a int);
+drop table CURTIME;
+
+--error ER_PARSE_ERROR
+create table DATE_ADD(a int);
+create table DATE_ADD (a int);
+drop table DATE_ADD;
+
+--error ER_PARSE_ERROR
+create table DATE_SUB(a int);
+create table DATE_SUB (a int);
+drop table DATE_SUB;
+
+--error ER_PARSE_ERROR
+create table EXTRACT(a int);
+create table EXTRACT (a int);
+drop table EXTRACT;
+
+--error ER_PARSE_ERROR
+create table GROUP_CONCAT(a int);
+create table GROUP_CONCAT (a int);
+drop table GROUP_CONCAT;
+
+--error ER_PARSE_ERROR
+create table GROUP_UNIQUE_USERS(a int);
+create table GROUP_UNIQUE_USERS (a int);
+drop table GROUP_UNIQUE_USERS;
+
+--error ER_PARSE_ERROR
+create table MAX(a int);
+create table MAX (a int);
+drop table MAX;
+
+--error ER_PARSE_ERROR
+create table MID(a int);
+create table MID (a int);
+drop table MID;
+
+--error ER_PARSE_ERROR
+create table MIN(a int);
+create table MIN (a int);
+drop table MIN;
+
+--error ER_PARSE_ERROR
+create table NOW(a int);
+create table NOW (a int);
+drop table NOW;
+
+--error ER_PARSE_ERROR
+create table POSITION(a int);
+create table POSITION (a int);
+drop table POSITION;
+
+create table SESSION_USER(a int);
+drop table SESSION_USER;
+create table SESSION_USER (a int);
+drop table SESSION_USER;
+
+--error ER_PARSE_ERROR
+create table STD(a int);
+create table STD (a int);
+drop table STD;
+
+--error ER_PARSE_ERROR
+create table STDDEV(a int);
+create table STDDEV (a int);
+drop table STDDEV;
+
+--error ER_PARSE_ERROR
+create table STDDEV_POP(a int);
+create table STDDEV_POP (a int);
+drop table STDDEV_POP;
+
+--error ER_PARSE_ERROR
+create table STDDEV_SAMP(a int);
+create table STDDEV_SAMP (a int);
+drop table STDDEV_SAMP;
+
+create table SUBDATE(a int);
+drop table SUBDATE;
+create table SUBDATE (a int);
+drop table SUBDATE;
+
+--error ER_PARSE_ERROR
+create table SUBSTR(a int);
+create table SUBSTR (a int);
+drop table SUBSTR;
+
+--error ER_PARSE_ERROR
+create table SUBSTRING(a int);
+create table SUBSTRING (a int);
+drop table SUBSTRING;
+
+--error ER_PARSE_ERROR
+create table SUM(a int);
+create table SUM (a int);
+drop table SUM;
+
+--error ER_PARSE_ERROR
+create table SYSDATE(a int);
+create table SYSDATE (a int);
+drop table SYSDATE;
+
+create table SYSTEM_USER(a int);
+drop table SYSTEM_USER;
+create table SYSTEM_USER (a int);
+drop table SYSTEM_USER;
+
+--error ER_PARSE_ERROR
+create table TRIM(a int);
+create table TRIM (a int);
+drop table TRIM;
+
+--error ER_PARSE_ERROR
+create table UNIQUE_USERS(a int);
+create table UNIQUE_USERS (a int);
+drop table UNIQUE_USERS;
+
+--error ER_PARSE_ERROR
+create table VARIANCE(a int);
+create table VARIANCE (a int);
+drop table VARIANCE;
+
+--error ER_PARSE_ERROR
+create table VAR_POP(a int);
+create table VAR_POP (a int);
+drop table VAR_POP;
+
+--error ER_PARSE_ERROR
+create table VAR_SAMP(a int);
+create table VAR_SAMP (a int);
+drop table VAR_SAMP;
+
+set SQL_MODE='IGNORE_SPACE';
+
+create table ADDDATE(a int);
+drop table ADDDATE;
+create table ADDDATE (a int);
+drop table ADDDATE;
+
+--error ER_PARSE_ERROR
+create table BIT_AND(a int);
+--error ER_PARSE_ERROR
+create table BIT_AND (a int);
+
+--error ER_PARSE_ERROR
+create table BIT_OR(a int);
+--error ER_PARSE_ERROR
+create table BIT_OR (a int);
+
+--error ER_PARSE_ERROR
+create table BIT_XOR(a int);
+--error ER_PARSE_ERROR
+create table BIT_XOR (a int);
+
+--error ER_PARSE_ERROR
+create table CAST(a int);
+--error ER_PARSE_ERROR
+create table CAST (a int);
+
+--error ER_PARSE_ERROR
+create table COUNT(a int);
+--error ER_PARSE_ERROR
+create table COUNT (a int);
+
+--error ER_PARSE_ERROR
+create table CURDATE(a int);
+--error ER_PARSE_ERROR
+create table CURDATE (a int);
+
+--error ER_PARSE_ERROR
+create table CURTIME(a int);
+--error ER_PARSE_ERROR
+create table CURTIME (a int);
+
+--error ER_PARSE_ERROR
+create table DATE_ADD(a int);
+--error ER_PARSE_ERROR
+create table DATE_ADD (a int);
+
+--error ER_PARSE_ERROR
+create table DATE_SUB(a int);
+--error ER_PARSE_ERROR
+create table DATE_SUB (a int);
+
+--error ER_PARSE_ERROR
+create table EXTRACT(a int);
+--error ER_PARSE_ERROR
+create table EXTRACT (a int);
+
+--error ER_PARSE_ERROR
+create table GROUP_CONCAT(a int);
+--error ER_PARSE_ERROR
+create table GROUP_CONCAT (a int);
+
+--error ER_PARSE_ERROR
+create table GROUP_UNIQUE_USERS(a int);
+--error ER_PARSE_ERROR
+create table GROUP_UNIQUE_USERS (a int);
+
+--error ER_PARSE_ERROR
+create table MAX(a int);
+--error ER_PARSE_ERROR
+create table MAX (a int);
+
+--error ER_PARSE_ERROR
+create table MID(a int);
+--error ER_PARSE_ERROR
+create table MID (a int);
+
+--error ER_PARSE_ERROR
+create table MIN(a int);
+--error ER_PARSE_ERROR
+create table MIN (a int);
+
+--error ER_PARSE_ERROR
+create table NOW(a int);
+--error ER_PARSE_ERROR
+create table NOW (a int);
+
+--error ER_PARSE_ERROR
+create table POSITION(a int);
+--error ER_PARSE_ERROR
+create table POSITION (a int);
+
+create table SESSION_USER(a int);
+drop table SESSION_USER;
+create table SESSION_USER (a int);
+drop table SESSION_USER;
+
+--error ER_PARSE_ERROR
+create table STD(a int);
+--error ER_PARSE_ERROR
+create table STD (a int);
+
+--error ER_PARSE_ERROR
+create table STDDEV(a int);
+--error ER_PARSE_ERROR
+create table STDDEV (a int);
+
+--error ER_PARSE_ERROR
+create table STDDEV_POP(a int);
+--error ER_PARSE_ERROR
+create table STDDEV_POP (a int);
+
+--error ER_PARSE_ERROR
+create table STDDEV_SAMP(a int);
+--error ER_PARSE_ERROR
+create table STDDEV_SAMP (a int);
+
+create table SUBDATE(a int);
+drop table SUBDATE;
+create table SUBDATE (a int);
+drop table SUBDATE;
+
+--error ER_PARSE_ERROR
+create table SUBSTR(a int);
+--error ER_PARSE_ERROR
+create table SUBSTR (a int);
+
+--error ER_PARSE_ERROR
+create table SUBSTRING(a int);
+--error ER_PARSE_ERROR
+create table SUBSTRING (a int);
+
+--error ER_PARSE_ERROR
+create table SUM(a int);
+--error ER_PARSE_ERROR
+create table SUM (a int);
+
+--error ER_PARSE_ERROR
+create table SYSDATE(a int);
+--error ER_PARSE_ERROR
+create table SYSDATE (a int);
+
+create table SYSTEM_USER(a int);
+drop table SYSTEM_USER;
+create table SYSTEM_USER (a int);
+drop table SYSTEM_USER;
+
+--error ER_PARSE_ERROR
+create table TRIM(a int);
+--error ER_PARSE_ERROR
+create table TRIM (a int);
+
+--error ER_PARSE_ERROR
+create table UNIQUE_USERS(a int);
+--error ER_PARSE_ERROR
+create table UNIQUE_USERS (a int);
+
+--error ER_PARSE_ERROR
+create table VARIANCE(a int);
+--error ER_PARSE_ERROR
+create table VARIANCE (a int);
+
+--error ER_PARSE_ERROR
+create table VAR_POP(a int);
+--error ER_PARSE_ERROR
+create table VAR_POP (a int);
+
+--error ER_PARSE_ERROR
+create table VAR_SAMP(a int);
+--error ER_PARSE_ERROR
+create table VAR_SAMP (a int);
+
+SET @@sql_mode=@save_sql_mode;
+
+#=============================================================================
+# SYNTACTIC PARSER (bison)
+#=============================================================================
+
+#
+#
+# Bug#21114 (Foreign key creation fails to table with name format)
+# 
+
+# Test coverage with edge conditions
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select pi(3.14);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select tan();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select tan(1, 2);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select makedate(1);
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select makedate(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select maketime();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select maketime(1);
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select maketime(1, 2);
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select maketime(1, 2, 3, 4);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select atan();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select atan2(1, 2, 3);
+
+select benchmark(10, 1+1);
+
+-- error ER_WRONG_PARAMETERS_TO_NATIVE_FCT
+select benchmark(5+5, 2);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select concat();
+select concat("foo");
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select concat_ws();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select concat_ws("foo");
+
+set @pwd="my password";
+-- error ER_WRONG_PARAMETERS_TO_NATIVE_FCT
+select encode("secret", @pwd);
+-- error ER_WRONG_PARAMETERS_TO_NATIVE_FCT
+select decode("encoded-secret", @pwd);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select encrypt();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select encrypt(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select des_encrypt("p1", "p2", "not expected");
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select des_decrypt("p1", "p2", "not expected");
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select elt();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select elt(1);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select export_set();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select export_set("p1");
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select export_set("p1", "p2");
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select export_set("p1", "p2", "p3", "p4", "p5", "p6");
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select field();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select field("p1");
+
+set @dec=2;
+-- error ER_WRONG_PARAMETERS_TO_NATIVE_FCT
+select format(pi(), @dec);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select from_unixtime();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select from_unixtime(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select unix_timestamp(1, 2);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select greatest();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select greatest(12);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select last_insert_id(1, 2);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select least();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select least(12);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select locate();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select locate(1);
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select locate(1, 2, 3, 4);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select log();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select log(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select make_set();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select make_set(1);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select master_pos_wait();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select master_pos_wait(1);
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select master_pos_wait(1, 2, 3, 4);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select rand(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select round(1, 2, 3);
+
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select yearweek();
+-- error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
+select yearweek(1, 2, 3);
+
diff --git a/mysql-test/t/parser_bug21114_innodb.test b/mysql-test/t/parser_bug21114_innodb.test
new file mode 100644
index 00000000000..d2101e2a28d
--- /dev/null
+++ b/mysql-test/t/parser_bug21114_innodb.test
@@ -0,0 +1,422 @@
+-- source include/have_innodb.inc
+
+let $engine_type=InnoDb;
+
+#
+# Bug#21114 (Foreign key creation fails to table with name format)
+# 
+
+# Testing with the full log for only a few functions,
+# including FORMAT for witch the bug was reported.
+
+let $verbose=1;
+
+let $FCT=ABS;
+-- source include/parser_bug21114.inc
+let $FCT=FIELD;
+-- source include/parser_bug21114.inc
+let $FCT=FORMAT;
+-- source include/parser_bug21114.inc
+
+# Ignoring the result of SHOW CREATE (this generates too much noise)
+# Tests will fail if the create table statement can not be parsed
+
+let verbose=0;
+
+let $FCT=ACOS;
+-- source include/parser_bug21114.inc
+let $FCT=ADDDATE;
+-- source include/parser_bug21114.inc
+let $FCT=ADDTIME;
+-- source include/parser_bug21114.inc
+let $FCT=AES_DECRYPT;
+-- source include/parser_bug21114.inc
+let $FCT=AES_ENCRYPT;
+-- source include/parser_bug21114.inc
+let $FCT=AREA;
+-- source include/parser_bug21114.inc
+let $FCT=ASBINARY;
+-- source include/parser_bug21114.inc
+let $FCT=ASIN;
+-- source include/parser_bug21114.inc
+let $FCT=ASTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=ASWKB;
+-- source include/parser_bug21114.inc
+let $FCT=ASWKT;
+-- source include/parser_bug21114.inc
+let $FCT=ATAN;
+-- source include/parser_bug21114.inc
+let $FCT=ATAN2;
+-- source include/parser_bug21114.inc
+let $FCT=BENCHMARK;
+-- source include/parser_bug21114.inc
+let $FCT=BIN;
+-- source include/parser_bug21114.inc
+let $FCT=BIT_COUNT;
+-- source include/parser_bug21114.inc
+let $FCT=BIT_LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=CEIL;
+-- source include/parser_bug21114.inc
+let $FCT=CEILING;
+-- source include/parser_bug21114.inc
+let $FCT=CENTROID;
+-- source include/parser_bug21114.inc
+let $FCT=CHARACTER_LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=CHAR_LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=COERCIBILITY;
+-- source include/parser_bug21114.inc
+let $FCT=COMPRESS;
+-- source include/parser_bug21114.inc
+let $FCT=CONCAT;
+-- source include/parser_bug21114.inc
+let $FCT=CONCAT_WS;
+-- source include/parser_bug21114.inc
+let $FCT=CONNECTION_ID;
+-- source include/parser_bug21114.inc
+let $FCT=CONV;
+-- source include/parser_bug21114.inc
+let $FCT=CONVERT_TZ;
+-- source include/parser_bug21114.inc
+let $FCT=COS;
+-- source include/parser_bug21114.inc
+let $FCT=COT;
+-- source include/parser_bug21114.inc
+let $FCT=CRC32;
+-- source include/parser_bug21114.inc
+let $FCT=CROSSES;
+-- source include/parser_bug21114.inc
+let $FCT=DATEDIFF;
+-- source include/parser_bug21114.inc
+let $FCT=DATE_FORMAT;
+-- source include/parser_bug21114.inc
+let $FCT=DAYNAME;
+-- source include/parser_bug21114.inc
+let $FCT=DAYOFMONTH;
+-- source include/parser_bug21114.inc
+let $FCT=DAYOFWEEK;
+-- source include/parser_bug21114.inc
+let $FCT=DAYOFYEAR;
+-- source include/parser_bug21114.inc
+let $FCT=DECODE;
+-- source include/parser_bug21114.inc
+let $FCT=DEGREES;
+-- source include/parser_bug21114.inc
+let $FCT=DES_DECRYPT;
+-- source include/parser_bug21114.inc
+let $FCT=DES_ENCRYPT;
+-- source include/parser_bug21114.inc
+let $FCT=DIMENSION;
+-- source include/parser_bug21114.inc
+let $FCT=DISJOINT;
+-- source include/parser_bug21114.inc
+let $FCT=ELT;
+-- source include/parser_bug21114.inc
+let $FCT=ENCODE;
+-- source include/parser_bug21114.inc
+let $FCT=ENCRYPT;
+-- source include/parser_bug21114.inc
+let $FCT=ENDPOINT;
+-- source include/parser_bug21114.inc
+let $FCT=ENVELOPE;
+-- source include/parser_bug21114.inc
+let $FCT=EQUALS;
+-- source include/parser_bug21114.inc
+let $FCT=EXP;
+-- source include/parser_bug21114.inc
+let $FCT=EXPORT_SET;
+-- source include/parser_bug21114.inc
+let $FCT=EXTERIORRING;
+-- source include/parser_bug21114.inc
+let $FCT=EXTRACTVALUE;
+-- source include/parser_bug21114.inc
+let $FCT=FIND_IN_SET;
+-- source include/parser_bug21114.inc
+let $FCT=FLOOR;
+-- source include/parser_bug21114.inc
+let $FCT=FOUND_ROWS;
+-- source include/parser_bug21114.inc
+let $FCT=FROM_DAYS;
+-- source include/parser_bug21114.inc
+let $FCT=FROM_UNIXTIME;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMCOLLFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMCOLLFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYCOLLECTIONFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYCOLLECTIONFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYN;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMETRYTYPE;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=GEOMFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=GET_LOCK;
+-- source include/parser_bug21114.inc
+let $FCT=GLENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=GREATEST;
+-- source include/parser_bug21114.inc
+let $FCT=HEX;
+-- source include/parser_bug21114.inc
+let $FCT=IFNULL;
+-- source include/parser_bug21114.inc
+let $FCT=INET_ATON;
+-- source include/parser_bug21114.inc
+let $FCT=INET_NTOA;
+-- source include/parser_bug21114.inc
+let $FCT=INSTR;
+-- source include/parser_bug21114.inc
+let $FCT=INTERIORRINGN;
+-- source include/parser_bug21114.inc
+let $FCT=INTERSECTS;
+-- source include/parser_bug21114.inc
+let $FCT=ISCLOSED;
+-- source include/parser_bug21114.inc
+let $FCT=ISEMPTY;
+-- source include/parser_bug21114.inc
+let $FCT=ISNULL;
+-- source include/parser_bug21114.inc
+let $FCT=ISSIMPLE;
+-- source include/parser_bug21114.inc
+let $FCT=IS_FREE_LOCK;
+-- source include/parser_bug21114.inc
+let $FCT=IS_USED_LOCK;
+-- source include/parser_bug21114.inc
+let $FCT=LAST_DAY;
+-- source include/parser_bug21114.inc
+let $FCT=LAST_INSERT_ID;
+-- source include/parser_bug21114.inc
+let $FCT=LCASE;
+-- source include/parser_bug21114.inc
+let $FCT=LEAST;
+-- source include/parser_bug21114.inc
+let $FCT=LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=LINEFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=LINEFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=LINESTRINGFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=LINESTRINGFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=LN;
+-- source include/parser_bug21114.inc
+let $FCT=LOAD_FILE;
+-- source include/parser_bug21114.inc
+let $FCT=LOCATE;
+-- source include/parser_bug21114.inc
+let $FCT=LOG;
+-- source include/parser_bug21114.inc
+let $FCT=LOG10;
+-- source include/parser_bug21114.inc
+let $FCT=LOG2;
+-- source include/parser_bug21114.inc
+let $FCT=LOWER;
+-- source include/parser_bug21114.inc
+let $FCT=LPAD;
+-- source include/parser_bug21114.inc
+let $FCT=LTRIM;
+-- source include/parser_bug21114.inc
+let $FCT=MAKEDATE;
+-- source include/parser_bug21114.inc
+let $FCT=MAKETIME;
+-- source include/parser_bug21114.inc
+let $FCT=MAKE_SET;
+-- source include/parser_bug21114.inc
+let $FCT=MASTER_POS_WAIT;
+-- source include/parser_bug21114.inc
+let $FCT=MBRCONTAINS;
+-- source include/parser_bug21114.inc
+let $FCT=MBRDISJOINT;
+-- source include/parser_bug21114.inc
+let $FCT=MBREQUAL;
+-- source include/parser_bug21114.inc
+let $FCT=MBRINTERSECTS;
+-- source include/parser_bug21114.inc
+let $FCT=MBROVERLAPS;
+-- source include/parser_bug21114.inc
+let $FCT=MBRTOUCHES;
+-- source include/parser_bug21114.inc
+let $FCT=MBRWITHIN;
+-- source include/parser_bug21114.inc
+let $FCT=MD5;
+-- source include/parser_bug21114.inc
+let $FCT=MLINEFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MLINEFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=MONTHNAME;
+-- source include/parser_bug21114.inc
+let $FCT=MPOINTFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MPOINTFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=MPOLYFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MPOLYFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=MULTILINESTRINGFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MULTILINESTRINGFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=MULTIPOINTFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MULTIPOINTFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=MULTIPOLYGONFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=MULTIPOLYGONFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=NAME_CONST;
+-- source include/parser_bug21114.inc
+let $FCT=NULLIF;
+-- source include/parser_bug21114.inc
+let $FCT=NUMGEOMETRIES;
+-- source include/parser_bug21114.inc
+let $FCT=NUMINTERIORRINGS;
+-- source include/parser_bug21114.inc
+let $FCT=NUMPOINTS;
+-- source include/parser_bug21114.inc
+let $FCT=OCT;
+-- source include/parser_bug21114.inc
+let $FCT=OCTET_LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=ORD;
+-- source include/parser_bug21114.inc
+let $FCT=OVERLAPS;
+-- source include/parser_bug21114.inc
+let $FCT=PERIOD_ADD;
+-- source include/parser_bug21114.inc
+let $FCT=PERIOD_DIFF;
+-- source include/parser_bug21114.inc
+let $FCT=PI;
+-- source include/parser_bug21114.inc
+let $FCT=POINTFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=POINTFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=POINTN;
+-- source include/parser_bug21114.inc
+let $FCT=POLYFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=POLYFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=POLYGONFROMTEXT;
+-- source include/parser_bug21114.inc
+let $FCT=POLYGONFROMWKB;
+-- source include/parser_bug21114.inc
+let $FCT=POW;
+-- source include/parser_bug21114.inc
+let $FCT=POWER;
+-- source include/parser_bug21114.inc
+let $FCT=QUOTE;
+-- source include/parser_bug21114.inc
+let $FCT=RADIANS;
+-- source include/parser_bug21114.inc
+let $FCT=RAND;
+-- source include/parser_bug21114.inc
+let $FCT=RELEASE_LOCK;
+-- source include/parser_bug21114.inc
+let $FCT=REVERSE;
+-- source include/parser_bug21114.inc
+let $FCT=ROUND;
+-- source include/parser_bug21114.inc
+let $FCT=ROW_COUNT;
+-- source include/parser_bug21114.inc
+let $FCT=RPAD;
+-- source include/parser_bug21114.inc
+let $FCT=RTRIM;
+-- source include/parser_bug21114.inc
+let $FCT=SEC_TO_TIME;
+-- source include/parser_bug21114.inc
+let $FCT=SESSION_USER;
+-- source include/parser_bug21114.inc
+let $FCT=SHA;
+-- source include/parser_bug21114.inc
+let $FCT=SHA1;
+-- source include/parser_bug21114.inc
+let $FCT=SIGN;
+-- source include/parser_bug21114.inc
+let $FCT=SIN;
+-- source include/parser_bug21114.inc
+let $FCT=SLEEP;
+-- source include/parser_bug21114.inc
+let $FCT=SOUNDEX;
+-- source include/parser_bug21114.inc
+let $FCT=SPACE;
+-- source include/parser_bug21114.inc
+let $FCT=SQRT;
+-- source include/parser_bug21114.inc
+let $FCT=SRID;
+-- source include/parser_bug21114.inc
+let $FCT=STARTPOINT;
+-- source include/parser_bug21114.inc
+let $FCT=STRCMP;
+-- source include/parser_bug21114.inc
+let $FCT=STR_TO_DATE;
+-- source include/parser_bug21114.inc
+let $FCT=SUBDATE;
+-- source include/parser_bug21114.inc
+let $FCT=SUBSTRING_INDEX;
+-- source include/parser_bug21114.inc
+let $FCT=SUBTIME;
+-- source include/parser_bug21114.inc
+let $FCT=SYSTEM_USER;
+-- source include/parser_bug21114.inc
+let $FCT=TAN;
+-- source include/parser_bug21114.inc
+let $FCT=TIMEDIFF;
+-- source include/parser_bug21114.inc
+let $FCT=TIME_FORMAT;
+-- source include/parser_bug21114.inc
+let $FCT=TIME_TO_SEC;
+-- source include/parser_bug21114.inc
+let $FCT=TOUCHES;
+-- source include/parser_bug21114.inc
+let $FCT=TO_DAYS;
+-- source include/parser_bug21114.inc
+let $FCT=UCASE;
+-- source include/parser_bug21114.inc
+let $FCT=UNCOMPRESS;
+-- source include/parser_bug21114.inc
+let $FCT=UNCOMPRESSED_LENGTH;
+-- source include/parser_bug21114.inc
+let $FCT=UNHEX;
+-- source include/parser_bug21114.inc
+let $FCT=UNIX_TIMESTAMP;
+-- source include/parser_bug21114.inc
+let $FCT=UPDATEXML;
+-- source include/parser_bug21114.inc
+let $FCT=UPPER;
+-- source include/parser_bug21114.inc
+let $FCT=UUID;
+-- source include/parser_bug21114.inc
+let $FCT=VERSION;
+-- source include/parser_bug21114.inc
+let $FCT=WEEKDAY;
+-- source include/parser_bug21114.inc
+let $FCT=WEEKOFYEAR;
+-- source include/parser_bug21114.inc
+let $FCT=WITHIN;
+-- source include/parser_bug21114.inc
+let $FCT=X;
+-- source include/parser_bug21114.inc
+let $FCT=Y;
+-- source include/parser_bug21114.inc
+let $FCT=YEARWEEK;
+-- source include/parser_bug21114.inc
+
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index 2446bedfc14..86cd5994346 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -698,11 +698,11 @@ drop function `f``1`;
 #
 # tested problem when function name length close to ALIGN_SIZE
 #
-create function x () returns int return 5;
-create view v1 as select x ();
+create function a() returns int return 5;
+create view v1 as select a();
 select * from v1;
 drop view v1;
-drop function x;
+drop function a;
 
 #
 # VIEW with collation
diff --git a/sql/item_create.cc b/sql/item_create.cc
index 3a93ec6e516..7722ce28d4a 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -14,728 +14,4926 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Functions to create an item. Used by lex.h */
+/* Functions to create an item. Used by sql_yacc.yy */
 
 #include "mysql_priv.h"
+#include "item_create.h"
+#include "sp_head.h"
+#include "sp.h"
+
+/*
+=============================================================================
+  LOCAL DECLARATIONS
+=============================================================================
+*/
+
+/**
+  Adapter for functions that takes exactly zero arguments.
+*/
+
+class Create_func_arg0 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with no arguments.
+    @param thd The current thread
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg0() {}
+  /** Destructor. */
+  virtual ~Create_func_arg0() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly one argument.
+*/
+
+class Create_func_arg1 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with one argument.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg1() {}
+  /** Destructor. */
+  virtual ~Create_func_arg1() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly two arguments.
+*/
+
+class Create_func_arg2 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with two arguments.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @param arg2 The second argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg2() {}
+  /** Destructor. */
+  virtual ~Create_func_arg2() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly three arguments.
+*/
+
+class Create_func_arg3 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with three arguments.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @param arg2 The second argument of the function
+    @param arg3 The third argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg3() {}
+  /** Destructor. */
+  virtual ~Create_func_arg3() {}
+};
+
+
+/**
+  Function builder for Stored Functions.
+*/
+
+class Create_sp_func : public Create_qfunc
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list);
+
+  static Create_sp_func s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_sp_func() {}
+  /** Destructor. */
+  virtual ~Create_sp_func() {}
+};
 
-Item *create_func_abs(Item* a)
+
+#ifndef HAVE_SPATIAL
+/**
+  Common (non) builder for geometry functions.
+  This builder is used in <code>--without-geometry</code> builds only,
+  to report an error.
+*/
+
+class Create_func_no_geom : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /** Singleton. */
+  static Create_func_no_geom s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_func_no_geom() {}
+  /** Destructor. */
+  virtual ~Create_func_no_geom() {}
+};
+#endif
+
+
+/*
+  Concrete functions builders (native functions).
+  Please keep this list sorted in alphabetical order,
+  it helps to compare code between versions, and helps with merges conflicts.
+*/
+
+class Create_func_abs : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_abs s_singleton;
+
+protected:
+  Create_func_abs() {}
+  virtual ~Create_func_abs() {}
+};
+
+
+class Create_func_acos : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_acos s_singleton;
+
+protected:
+  Create_func_acos() {}
+  virtual ~Create_func_acos() {}
+};
+
+
+class Create_func_addtime : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_addtime s_singleton;
+
+protected:
+  Create_func_addtime() {}
+  virtual ~Create_func_addtime() {}
+};
+
+
+class Create_func_aes_encrypt : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_aes_encrypt s_singleton;
+
+protected:
+  Create_func_aes_encrypt() {}
+  virtual ~Create_func_aes_encrypt() {}
+};
+
+
+class Create_func_aes_decrypt : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_aes_decrypt s_singleton;
+
+protected:
+  Create_func_aes_decrypt() {}
+  virtual ~Create_func_aes_decrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_area : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_area s_singleton;
+
+protected:
+  Create_func_area() {}
+  virtual ~Create_func_area() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_as_wkb : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_as_wkb s_singleton;
+
+protected:
+  Create_func_as_wkb() {}
+  virtual ~Create_func_as_wkb() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_as_wkt : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_as_wkt s_singleton;
+
+protected:
+  Create_func_as_wkt() {}
+  virtual ~Create_func_as_wkt() {}
+};
+#endif
+
+
+class Create_func_asin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_asin s_singleton;
+
+protected:
+  Create_func_asin() {}
+  virtual ~Create_func_asin() {}
+};
+
+
+class Create_func_atan : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_atan s_singleton;
+
+protected:
+  Create_func_atan() {}
+  virtual ~Create_func_atan() {}
+};
+
+
+class Create_func_benchmark : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_benchmark s_singleton;
+
+protected:
+  Create_func_benchmark() {}
+  virtual ~Create_func_benchmark() {}
+};
+
+
+class Create_func_bin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bin s_singleton;
+
+protected:
+  Create_func_bin() {}
+  virtual ~Create_func_bin() {}
+};
+
+
+class Create_func_bit_count : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bit_count s_singleton;
+
+protected:
+  Create_func_bit_count() {}
+  virtual ~Create_func_bit_count() {}
+};
+
+
+class Create_func_bit_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bit_length s_singleton;
+
+protected:
+  Create_func_bit_length() {}
+  virtual ~Create_func_bit_length() {}
+};
+
+
+class Create_func_ceiling : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg);
+
+  static Create_func_ceiling s_singleton;
+
+protected:
+  Create_func_ceiling() {}
+  virtual ~Create_func_ceiling() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_centroid : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_centroid s_singleton;
+
+protected:
+  Create_func_centroid() {}
+  virtual ~Create_func_centroid() {}
+};
+#endif
+
+
+class Create_func_char_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_char_length s_singleton;
+
+protected:
+  Create_func_char_length() {}
+  virtual ~Create_func_char_length() {}
+};
+
+
+class Create_func_coercibility : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_coercibility s_singleton;
+
+protected:
+  Create_func_coercibility() {}
+  virtual ~Create_func_coercibility() {}
+};
+
+
+class Create_func_compress : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_compress s_singleton;
+
+protected:
+  Create_func_compress() {}
+  virtual ~Create_func_compress() {}
+};
+
+
+class Create_func_concat : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_concat s_singleton;
+
+protected:
+  Create_func_concat() {}
+  virtual ~Create_func_concat() {}
+};
+
+
+class Create_func_concat_ws : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_concat_ws s_singleton;
+
+protected:
+  Create_func_concat_ws() {}
+  virtual ~Create_func_concat_ws() {}
+};
+
+
+class Create_func_connection_id : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_connection_id s_singleton;
+
+protected:
+  Create_func_connection_id() {}
+  virtual ~Create_func_connection_id() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_contains : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_contains s_singleton;
+
+protected:
+  Create_func_contains() {}
+  virtual ~Create_func_contains() {}
+};
+#endif
+
+
+class Create_func_conv : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_conv s_singleton;
+
+protected:
+  Create_func_conv() {}
+  virtual ~Create_func_conv() {}
+};
+
+
+class Create_func_convert_tz : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_convert_tz s_singleton;
+
+protected:
+  Create_func_convert_tz() {}
+  virtual ~Create_func_convert_tz() {}
+};
+
+
+class Create_func_cos : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_cos s_singleton;
+
+protected:
+  Create_func_cos() {}
+  virtual ~Create_func_cos() {}
+};
+
+
+class Create_func_cot : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_cot s_singleton;
+
+protected:
+  Create_func_cot() {}
+  virtual ~Create_func_cot() {}
+};
+
+
+class Create_func_crc32 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_crc32 s_singleton;
+
+protected:
+  Create_func_crc32() {}
+  virtual ~Create_func_crc32() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_crosses : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_crosses s_singleton;
+
+protected:
+  Create_func_crosses() {}
+  virtual ~Create_func_crosses() {}
+};
+#endif
+
+
+class Create_func_date_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_date_format s_singleton;
+
+protected:
+  Create_func_date_format() {}
+  virtual ~Create_func_date_format() {}
+};
+
+
+class Create_func_datediff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_datediff s_singleton;
+
+protected:
+  Create_func_datediff() {}
+  virtual ~Create_func_datediff() {}
+};
+
+
+class Create_func_dayname : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayname s_singleton;
+
+protected:
+  Create_func_dayname() {}
+  virtual ~Create_func_dayname() {}
+};
+
+
+class Create_func_dayofmonth : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofmonth s_singleton;
+
+protected:
+  Create_func_dayofmonth() {}
+  virtual ~Create_func_dayofmonth() {}
+};
+
+
+class Create_func_dayofweek : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofweek s_singleton;
+
+protected:
+  Create_func_dayofweek() {}
+  virtual ~Create_func_dayofweek() {}
+};
+
+
+class Create_func_dayofyear : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofyear s_singleton;
+
+protected:
+  Create_func_dayofyear() {}
+  virtual ~Create_func_dayofyear() {}
+};
+
+
+class Create_func_decode : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_decode s_singleton;
+
+protected:
+  Create_func_decode() {}
+  virtual ~Create_func_decode() {}
+};
+
+
+class Create_func_degrees : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_degrees s_singleton;
+
+protected:
+  Create_func_degrees() {}
+  virtual ~Create_func_degrees() {}
+};
+
+
+class Create_func_des_decrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_des_decrypt s_singleton;
+
+protected:
+  Create_func_des_decrypt() {}
+  virtual ~Create_func_des_decrypt() {}
+};
+
+
+class Create_func_des_encrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_des_encrypt s_singleton;
+
+protected:
+  Create_func_des_encrypt() {}
+  virtual ~Create_func_des_encrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_dimension : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dimension s_singleton;
+
+protected:
+  Create_func_dimension() {}
+  virtual ~Create_func_dimension() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_disjoint : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_disjoint s_singleton;
+
+protected:
+  Create_func_disjoint() {}
+  virtual ~Create_func_disjoint() {}
+};
+#endif
+
+
+class Create_func_elt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_elt s_singleton;
+
+protected:
+  Create_func_elt() {}
+  virtual ~Create_func_elt() {}
+};
+
+
+class Create_func_encode : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_encode s_singleton;
+
+protected:
+  Create_func_encode() {}
+  virtual ~Create_func_encode() {}
+};
+
+
+class Create_func_encrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_encrypt s_singleton;
+
+protected:
+  Create_func_encrypt() {}
+  virtual ~Create_func_encrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_endpoint : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_endpoint s_singleton;
+
+protected:
+  Create_func_endpoint() {}
+  virtual ~Create_func_endpoint() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_envelope : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_envelope s_singleton;
+
+protected:
+  Create_func_envelope() {}
+  virtual ~Create_func_envelope() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_equals : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_equals s_singleton;
+
+protected:
+  Create_func_equals() {}
+  virtual ~Create_func_equals() {}
+};
+#endif
+
+
+class Create_func_exp : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_exp s_singleton;
+
+protected:
+  Create_func_exp() {}
+  virtual ~Create_func_exp() {}
+};
+
+
+class Create_func_export_set : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_export_set s_singleton;
+
+protected:
+  Create_func_export_set() {}
+  virtual ~Create_func_export_set() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_exteriorring : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_exteriorring s_singleton;
+
+protected:
+  Create_func_exteriorring() {}
+  virtual ~Create_func_exteriorring() {}
+};
+#endif
+
+
+class Create_func_field : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_field s_singleton;
+
+protected:
+  Create_func_field() {}
+  virtual ~Create_func_field() {}
+};
+
+
+class Create_func_find_in_set : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_find_in_set s_singleton;
+
+protected:
+  Create_func_find_in_set() {}
+  virtual ~Create_func_find_in_set() {}
+};
+
+
+class Create_func_floor : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_floor s_singleton;
+
+protected:
+  Create_func_floor() {}
+  virtual ~Create_func_floor() {}
+};
+
+
+class Create_func_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_format s_singleton;
+
+protected:
+  Create_func_format() {}
+  virtual ~Create_func_format() {}
+};
+
+
+class Create_func_found_rows : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_found_rows s_singleton;
+
+protected:
+  Create_func_found_rows() {}
+  virtual ~Create_func_found_rows() {}
+};
+
+
+class Create_func_from_days : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_from_days s_singleton;
+
+protected:
+  Create_func_from_days() {}
+  virtual ~Create_func_from_days() {}
+};
+
+
+class Create_func_from_unixtime : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_from_unixtime s_singleton;
+
+protected:
+  Create_func_from_unixtime() {}
+  virtual ~Create_func_from_unixtime() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_from_text : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_geometry_from_text s_singleton;
+
+protected:
+  Create_func_geometry_from_text() {}
+  virtual ~Create_func_geometry_from_text() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_from_wkb : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_geometry_from_wkb s_singleton;
+
+protected:
+  Create_func_geometry_from_wkb() {}
+  virtual ~Create_func_geometry_from_wkb() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_type : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_geometry_type s_singleton;
+
+protected:
+  Create_func_geometry_type() {}
+  virtual ~Create_func_geometry_type() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometryn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_geometryn s_singleton;
+
+protected:
+  Create_func_geometryn() {}
+  virtual ~Create_func_geometryn() {}
+};
+#endif
+
+
+class Create_func_get_lock : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_get_lock s_singleton;
+
+protected:
+  Create_func_get_lock() {}
+  virtual ~Create_func_get_lock() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_glength : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_glength s_singleton;
+
+protected:
+  Create_func_glength() {}
+  virtual ~Create_func_glength() {}
+};
+#endif
+
+
+class Create_func_greatest : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_greatest s_singleton;
+
+protected:
+  Create_func_greatest() {}
+  virtual ~Create_func_greatest() {}
+};
+
+
+class Create_func_hex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_hex s_singleton;
+
+protected:
+  Create_func_hex() {}
+  virtual ~Create_func_hex() {}
+};
+
+
+class Create_func_ifnull : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_ifnull s_singleton;
+
+protected:
+  Create_func_ifnull() {}
+  virtual ~Create_func_ifnull() {}
+};
+
+
+class Create_func_inet_ntoa : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_inet_ntoa s_singleton;
+
+protected:
+  Create_func_inet_ntoa() {}
+  virtual ~Create_func_inet_ntoa() {}
+};
+
+
+class Create_func_inet_aton : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_inet_aton s_singleton;
+
+protected:
+  Create_func_inet_aton() {}
+  virtual ~Create_func_inet_aton() {}
+};
+
+
+class Create_func_instr : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_instr s_singleton;
+
+protected:
+  Create_func_instr() {}
+  virtual ~Create_func_instr() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_interiorringn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_interiorringn s_singleton;
+
+protected:
+  Create_func_interiorringn() {}
+  virtual ~Create_func_interiorringn() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_intersects : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_intersects s_singleton;
+
+protected:
+  Create_func_intersects() {}
+  virtual ~Create_func_intersects() {}
+};
+#endif
+
+
+class Create_func_is_free_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_is_free_lock s_singleton;
+
+protected:
+  Create_func_is_free_lock() {}
+  virtual ~Create_func_is_free_lock() {}
+};
+
+
+class Create_func_is_used_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_is_used_lock s_singleton;
+
+protected:
+  Create_func_is_used_lock() {}
+  virtual ~Create_func_is_used_lock() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_isclosed : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isclosed s_singleton;
+
+protected:
+  Create_func_isclosed() {}
+  virtual ~Create_func_isclosed() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_isempty : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isempty s_singleton;
+
+protected:
+  Create_func_isempty() {}
+  virtual ~Create_func_isempty() {}
+};
+#endif
+
+
+class Create_func_isnull : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isnull s_singleton;
+
+protected:
+  Create_func_isnull() {}
+  virtual ~Create_func_isnull() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_issimple : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_issimple s_singleton;
+
+protected:
+  Create_func_issimple() {}
+  virtual ~Create_func_issimple() {}
+};
+#endif
+
+
+class Create_func_last_day : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_last_day s_singleton;
+
+protected:
+  Create_func_last_day() {}
+  virtual ~Create_func_last_day() {}
+};
+
+
+class Create_func_last_insert_id : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_last_insert_id s_singleton;
+
+protected:
+  Create_func_last_insert_id() {}
+  virtual ~Create_func_last_insert_id() {}
+};
+
+
+class Create_func_lcase : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_lcase s_singleton;
+
+protected:
+  Create_func_lcase() {}
+  virtual ~Create_func_lcase() {}
+};
+
+
+class Create_func_least : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_least s_singleton;
+
+protected:
+  Create_func_least() {}
+  virtual ~Create_func_least() {}
+};
+
+
+class Create_func_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_length s_singleton;
+
+protected:
+  Create_func_length() {}
+  virtual ~Create_func_length() {}
+};
+
+
+class Create_func_ln : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ln s_singleton;
+
+protected:
+  Create_func_ln() {}
+  virtual ~Create_func_ln() {}
+};
+
+
+class Create_func_load_file : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_load_file s_singleton;
+
+protected:
+  Create_func_load_file() {}
+  virtual ~Create_func_load_file() {}
+};
+
+
+class Create_func_locate : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_locate s_singleton;
+
+protected:
+  Create_func_locate() {}
+  virtual ~Create_func_locate() {}
+};
+
+
+class Create_func_log : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_log s_singleton;
+
+protected:
+  Create_func_log() {}
+  virtual ~Create_func_log() {}
+};
+
+
+class Create_func_log10 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_log10 s_singleton;
+
+protected:
+  Create_func_log10() {}
+  virtual ~Create_func_log10() {}
+};
+
+
+class Create_func_log2 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_log2 s_singleton;
+
+protected:
+  Create_func_log2() {}
+  virtual ~Create_func_log2() {}
+};
+
+
+class Create_func_lpad : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_lpad s_singleton;
+
+protected:
+  Create_func_lpad() {}
+  virtual ~Create_func_lpad() {}
+};
+
+
+class Create_func_ltrim : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ltrim s_singleton;
+
+protected:
+  Create_func_ltrim() {}
+  virtual ~Create_func_ltrim() {}
+};
+
+
+class Create_func_makedate : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_makedate s_singleton;
+
+protected:
+  Create_func_makedate() {}
+  virtual ~Create_func_makedate() {}
+};
+
+
+class Create_func_maketime : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_maketime s_singleton;
+
+protected:
+  Create_func_maketime() {}
+  virtual ~Create_func_maketime() {}
+};
+
+
+class Create_func_make_set : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_make_set s_singleton;
+
+protected:
+  Create_func_make_set() {}
+  virtual ~Create_func_make_set() {}
+};
+
+
+class Create_func_master_pos_wait : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_master_pos_wait s_singleton;
+
+protected:
+  Create_func_master_pos_wait() {}
+  virtual ~Create_func_master_pos_wait() {}
+};
+
+
+class Create_func_md5 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_md5 s_singleton;
+
+protected:
+  Create_func_md5() {}
+  virtual ~Create_func_md5() {}
+};
+
+
+class Create_func_monthname : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_monthname s_singleton;
+
+protected:
+  Create_func_monthname() {}
+  virtual ~Create_func_monthname() {}
+};
+
+
+class Create_func_name_const : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_name_const s_singleton;
+
+protected:
+  Create_func_name_const() {}
+  virtual ~Create_func_name_const() {}
+};
+
+
+class Create_func_nullif : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_nullif s_singleton;
+
+protected:
+  Create_func_nullif() {}
+  virtual ~Create_func_nullif() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numgeometries : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numgeometries s_singleton;
+
+protected:
+  Create_func_numgeometries() {}
+  virtual ~Create_func_numgeometries() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numinteriorring : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numinteriorring s_singleton;
+
+protected:
+  Create_func_numinteriorring() {}
+  virtual ~Create_func_numinteriorring() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numpoints : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numpoints s_singleton;
+
+protected:
+  Create_func_numpoints() {}
+  virtual ~Create_func_numpoints() {}
+};
+#endif
+
+
+class Create_func_oct : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_oct s_singleton;
+
+protected:
+  Create_func_oct() {}
+  virtual ~Create_func_oct() {}
+};
+
+
+class Create_func_ord : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ord s_singleton;
+
+protected:
+  Create_func_ord() {}
+  virtual ~Create_func_ord() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_overlaps : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_overlaps s_singleton;
+
+protected:
+  Create_func_overlaps() {}
+  virtual ~Create_func_overlaps() {}
+};
+#endif
+
+
+class Create_func_period_add : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_period_add s_singleton;
+
+protected:
+  Create_func_period_add() {}
+  virtual ~Create_func_period_add() {}
+};
+
+
+class Create_func_period_diff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_period_diff s_singleton;
+
+protected:
+  Create_func_period_diff() {}
+  virtual ~Create_func_period_diff() {}
+};
+
+
+class Create_func_pi : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_pi s_singleton;
+
+protected:
+  Create_func_pi() {}
+  virtual ~Create_func_pi() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_pointn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_pointn s_singleton;
+
+protected:
+  Create_func_pointn() {}
+  virtual ~Create_func_pointn() {}
+};
+#endif
+
+
+class Create_func_pow : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_pow s_singleton;
+
+protected:
+  Create_func_pow() {}
+  virtual ~Create_func_pow() {}
+};
+
+
+class Create_func_quote : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_quote s_singleton;
+
+protected:
+  Create_func_quote() {}
+  virtual ~Create_func_quote() {}
+};
+
+
+class Create_func_radians : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_radians s_singleton;
+
+protected:
+  Create_func_radians() {}
+  virtual ~Create_func_radians() {}
+};
+
+
+class Create_func_rand : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_rand s_singleton;
+
+protected:
+  Create_func_rand() {}
+  virtual ~Create_func_rand() {}
+};
+
+
+class Create_func_release_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_release_lock s_singleton;
+
+protected:
+  Create_func_release_lock() {}
+  virtual ~Create_func_release_lock() {}
+};
+
+
+class Create_func_reverse : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_reverse s_singleton;
+
+protected:
+  Create_func_reverse() {}
+  virtual ~Create_func_reverse() {}
+};
+
+
+class Create_func_round : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_round s_singleton;
+
+protected:
+  Create_func_round() {}
+  virtual ~Create_func_round() {}
+};
+
+
+class Create_func_row_count : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_row_count s_singleton;
+
+protected:
+  Create_func_row_count() {}
+  virtual ~Create_func_row_count() {}
+};
+
+
+class Create_func_rpad : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_rpad s_singleton;
+
+protected:
+  Create_func_rpad() {}
+  virtual ~Create_func_rpad() {}
+};
+
+
+class Create_func_rtrim : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_rtrim s_singleton;
+
+protected:
+  Create_func_rtrim() {}
+  virtual ~Create_func_rtrim() {}
+};
+
+
+class Create_func_sec_to_time : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sec_to_time s_singleton;
+
+protected:
+  Create_func_sec_to_time() {}
+  virtual ~Create_func_sec_to_time() {}
+};
+
+
+class Create_func_sha : public Create_func_arg1
 {
-  return new Item_func_abs(a);
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sha s_singleton;
+
+protected:
+  Create_func_sha() {}
+  virtual ~Create_func_sha() {}
+};
+
+
+class Create_func_sign : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sign s_singleton;
+
+protected:
+  Create_func_sign() {}
+  virtual ~Create_func_sign() {}
+};
+
+
+class Create_func_sin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sin s_singleton;
+
+protected:
+  Create_func_sin() {}
+  virtual ~Create_func_sin() {}
+};
+
+
+class Create_func_sleep : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sleep s_singleton;
+
+protected:
+  Create_func_sleep() {}
+  virtual ~Create_func_sleep() {}
+};
+
+
+class Create_func_soundex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_soundex s_singleton;
+
+protected:
+  Create_func_soundex() {}
+  virtual ~Create_func_soundex() {}
+};
+
+
+class Create_func_space : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_space s_singleton;
+
+protected:
+  Create_func_space() {}
+  virtual ~Create_func_space() {}
+};
+
+
+class Create_func_sqrt : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sqrt s_singleton;
+
+protected:
+  Create_func_sqrt() {}
+  virtual ~Create_func_sqrt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_srid : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_srid s_singleton;
+
+protected:
+  Create_func_srid() {}
+  virtual ~Create_func_srid() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_startpoint : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_startpoint s_singleton;
+
+protected:
+  Create_func_startpoint() {}
+  virtual ~Create_func_startpoint() {}
+};
+#endif
+
+
+class Create_func_str_to_date : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_str_to_date s_singleton;
+
+protected:
+  Create_func_str_to_date() {}
+  virtual ~Create_func_str_to_date() {}
+};
+
+
+class Create_func_strcmp : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_strcmp s_singleton;
+
+protected:
+  Create_func_strcmp() {}
+  virtual ~Create_func_strcmp() {}
+};
+
+
+class Create_func_substr_index : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_substr_index s_singleton;
+
+protected:
+  Create_func_substr_index() {}
+  virtual ~Create_func_substr_index() {}
+};
+
+
+class Create_func_subtime : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_subtime s_singleton;
+
+protected:
+  Create_func_subtime() {}
+  virtual ~Create_func_subtime() {}
+};
+
+
+class Create_func_tan : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_tan s_singleton;
+
+protected:
+  Create_func_tan() {}
+  virtual ~Create_func_tan() {}
+};
+
+
+class Create_func_time_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_time_format s_singleton;
+
+protected:
+  Create_func_time_format() {}
+  virtual ~Create_func_time_format() {}
+};
+
+
+class Create_func_time_to_sec : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_time_to_sec s_singleton;
+
+protected:
+  Create_func_time_to_sec() {}
+  virtual ~Create_func_time_to_sec() {}
+};
+
+
+class Create_func_timediff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_timediff s_singleton;
+
+protected:
+  Create_func_timediff() {}
+  virtual ~Create_func_timediff() {}
+};
+
+
+class Create_func_to_days : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_to_days s_singleton;
+
+protected:
+  Create_func_to_days() {}
+  virtual ~Create_func_to_days() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_touches : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_touches s_singleton;
+
+protected:
+  Create_func_touches() {}
+  virtual ~Create_func_touches() {}
+};
+#endif
+
+
+class Create_func_ucase : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ucase s_singleton;
+
+protected:
+  Create_func_ucase() {}
+  virtual ~Create_func_ucase() {}
+};
+
+
+class Create_func_uncompress : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_uncompress s_singleton;
+
+protected:
+  Create_func_uncompress() {}
+  virtual ~Create_func_uncompress() {}
+};
+
+
+class Create_func_uncompressed_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_uncompressed_length s_singleton;
+
+protected:
+  Create_func_uncompressed_length() {}
+  virtual ~Create_func_uncompressed_length() {}
+};
+
+
+class Create_func_unhex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_unhex s_singleton;
+
+protected:
+  Create_func_unhex() {}
+  virtual ~Create_func_unhex() {}
+};
+
+
+class Create_func_unix_timestamp : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_unix_timestamp s_singleton;
+
+protected:
+  Create_func_unix_timestamp() {}
+  virtual ~Create_func_unix_timestamp() {}
+};
+
+
+class Create_func_uuid : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_uuid s_singleton;
+
+protected:
+  Create_func_uuid() {}
+  virtual ~Create_func_uuid() {}
+};
+
+
+class Create_func_version : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_version s_singleton;
+
+protected:
+  Create_func_version() {}
+  virtual ~Create_func_version() {}
+};
+
+
+class Create_func_weekday : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_weekday s_singleton;
+
+protected:
+  Create_func_weekday() {}
+  virtual ~Create_func_weekday() {}
+};
+
+
+class Create_func_weekofyear : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_weekofyear s_singleton;
+
+protected:
+  Create_func_weekofyear() {}
+  virtual ~Create_func_weekofyear() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_within : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_within s_singleton;
+
+protected:
+  Create_func_within() {}
+  virtual ~Create_func_within() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_x : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_x s_singleton;
+
+protected:
+  Create_func_x() {}
+  virtual ~Create_func_x() {}
+};
+#endif
+
+
+class Create_func_xml_extractvalue : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_xml_extractvalue s_singleton;
+
+protected:
+  Create_func_xml_extractvalue() {}
+  virtual ~Create_func_xml_extractvalue() {}
+};
+
+
+class Create_func_xml_update : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_xml_update s_singleton;
+
+protected:
+  Create_func_xml_update() {}
+  virtual ~Create_func_xml_update() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_y : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_y s_singleton;
+
+protected:
+  Create_func_y() {}
+  virtual ~Create_func_y() {}
+};
+#endif
+
+
+class Create_func_year_week : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_year_week s_singleton;
+
+protected:
+  Create_func_year_week() {}
+  virtual ~Create_func_year_week() {}
+};
+
+
+/*
+=============================================================================
+  IMPLEMENTATION
+=============================================================================
+*/
+
+#ifndef HAVE_SPATIAL
+Create_func_no_geom Create_func_no_geom::s_singleton;
+
+Item*
+Create_func_no_geom::create(THD * /* unused */,
+                            LEX_STRING /* unused */,
+                            List<Item> * /* unused */)
+{
+  /* FIXME: error message can't be translated. */
+  my_error(ER_FEATURE_DISABLED, MYF(0),
+           sym_group_geom.name, sym_group_geom.needed_define);
+  return NULL;
 }
+#endif
 
-Item *create_func_acos(Item* a)
+
+Item*
+Create_qfunc::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_acos(a);
+  LEX_STRING db;
+  if (thd->copy_db_to(&db.str, &db.length))
+    return NULL;
+
+  return create(thd, db, name, item_list);
 }
 
-Item *create_func_aes_encrypt(Item* a, Item* b)
+
+#ifdef HAVE_DLOPEN
+Create_udf_func Create_udf_func::s_singleton;
+
+Item*
+Create_udf_func::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_aes_encrypt(a, b);
+  udf_func *udf= find_udf(name.str, name.length);
+  DBUG_ASSERT(udf);
+  return create(thd, udf, item_list);
 }
 
-Item *create_func_aes_decrypt(Item* a, Item* b)
+
+Item*
+Create_udf_func::create(THD *thd, udf_func *udf, List<Item> *item_list)
 {
-  return new Item_func_aes_decrypt(a, b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+#ifdef HAVE_ROW_BASED_REPLICATION
+  thd->lex->binlog_row_based_if_mixed= TRUE;
+#endif
+
+  DBUG_ASSERT(   (udf->type == UDFTYPE_FUNCTION)
+              || (udf->type == UDFTYPE_AGGREGATE));
+
+  switch(udf->returns) {
+  case STRING_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_str(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_str(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_str(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_str(udf);
+    }
+    break;
+  }
+  case REAL_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_float(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_float(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_float(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_float(udf);
+    }
+    break;
+  }
+  case INT_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_int(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_int(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_int(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_int(udf);
+    }
+    break;
+  }
+  case DECIMAL_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_decimal(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_decimal(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_decimal(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_decimal(udf);
+    }
+    break;
+  }
+  default:
+  {
+    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "UDF return type");
+  }
+  }
+  return func;
 }
+#endif
+
+
+Create_sp_func Create_sp_func::s_singleton;
 
-Item *create_func_ascii(Item* a)
+Item*
+Create_sp_func::create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list)
 {
-  return new Item_func_ascii(a);
+  int arg_count= 0;
+  Item *func= NULL;
+  LEX *lex= thd->lex;
+  sp_name *qname= new (thd->mem_root) sp_name(db, name);
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  qname->init_qname(thd);
+  sp_add_used_routine(lex, thd, qname, TYPE_ENUM_FUNCTION);
+
+  if (arg_count > 0)
+    func= new (thd->mem_root) Item_func_sp(lex->current_context(), qname,
+                                           *item_list);
+  else
+    func= new (thd->mem_root) Item_func_sp(lex->current_context(), qname);
+
+  lex->safe_to_cache_query= 0;
+  return func;
 }
 
-Item *create_func_ord(Item* a)
+
+Item*
+Create_func_arg0::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_ord(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count != 0)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return create(thd);
 }
 
-Item *create_func_asin(Item* a)
+
+Item*
+Create_func_arg1::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_asin(a);
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 1)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  return create(thd, param_1);
 }
 
-Item *create_func_bin(Item* a)
+
+Item*
+Create_func_arg2::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_conv(a,new Item_int((int32) 10,2),
-			    new Item_int((int32) 2,1));
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  Item *param_2= item_list->pop();
+  return create(thd, param_1, param_2);
 }
 
-Item *create_func_bit_count(Item* a)
+
+Item*
+Create_func_arg3::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_bit_count(a);
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 3)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  Item *param_2= item_list->pop();
+  Item *param_3= item_list->pop();
+  return create(thd, param_1, param_2, param_3);
 }
 
-Item *create_func_ceiling(Item* a)
+
+Create_func_abs Create_func_abs::s_singleton;
+
+Item*
+Create_func_abs::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ceiling(a);
+  return new (thd->mem_root) Item_func_abs(arg1);
 }
 
-Item *create_func_connection_id(void)
+
+Create_func_acos Create_func_acos::s_singleton;
+
+Item*
+Create_func_acos::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->safe_to_cache_query= 0;
-  return new Item_func_connection_id();
+  return new (thd->mem_root) Item_func_acos(arg1);
 }
 
-Item *create_func_conv(Item* a, Item *b, Item *c)
+
+Create_func_addtime Create_func_addtime::s_singleton;
+
+Item*
+Create_func_addtime::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_conv(a,b,c);
+  return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 0);
 }
 
-Item *create_func_cos(Item* a)
+
+Create_func_aes_encrypt Create_func_aes_encrypt::s_singleton;
+
+Item*
+Create_func_aes_encrypt::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_cos(a);
+  return new (thd->mem_root) Item_func_aes_encrypt(arg1, arg2);
 }
 
-Item *create_func_cot(Item* a)
+
+Create_func_aes_decrypt Create_func_aes_decrypt::s_singleton;
+
+Item*
+Create_func_aes_decrypt::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_div(new Item_int((char*) "1",1,1),
-			   new Item_func_tan(a));
+  return new (thd->mem_root) Item_func_aes_decrypt(arg1, arg2);
 }
 
-Item *create_func_date_format(Item* a,Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_area Create_func_area::s_singleton;
+
+Item*
+Create_func_area::create(THD *thd, Item *arg1)
 {
-  return new Item_func_date_format(a,b,0);
+  return new (thd->mem_root) Item_func_area(arg1);
 }
+#endif
 
-Item *create_func_dayofmonth(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_as_wkb Create_func_as_wkb::s_singleton;
+
+Item*
+Create_func_as_wkb::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dayofmonth(a);
+  return new (thd->mem_root) Item_func_as_wkb(arg1);
 }
+#endif
+
 
-Item *create_func_dayofweek(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_as_wkt Create_func_as_wkt::s_singleton;
+
+Item*
+Create_func_as_wkt::create(THD *thd, Item *arg1)
 {
-  return new Item_func_weekday(a, 1);
+  return new (thd->mem_root) Item_func_as_wkt(arg1);
+}
+#endif
+
+
+Create_func_asin Create_func_asin::s_singleton;
+
+Item*
+Create_func_asin::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_asin(arg1);
+}
+
+
+Create_func_atan Create_func_atan::s_singleton;
+
+Item*
+Create_func_atan::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item* func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_atan(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_atan(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_dayofyear(Item* a)
+
+Create_func_benchmark Create_func_benchmark::s_singleton;
+
+Item*
+Create_func_benchmark::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_dayofyear(a);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg1->type() != Item::INT_ITEM) || ! arg1->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "BENCHMARK");
+    return NULL;
+  }
+
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_benchmark(arg1->val_int(), arg2);
 }
 
-Item *create_func_dayname(Item* a)
+
+Create_func_bin Create_func_bin::s_singleton;
+
+Item*
+Create_func_bin::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dayname(a);
+  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
+  Item *i2= new (thd->mem_root) Item_int((int32) 2,1);
+  return new (thd->mem_root) Item_func_conv(arg1, i10, i2);
 }
 
-Item *create_func_degrees(Item *a)
+
+Create_func_bit_count Create_func_bit_count::s_singleton;
+
+Item*
+Create_func_bit_count::create(THD *thd, Item *arg1)
 {
-  return new Item_func_units((char*) "degrees",a,180/M_PI,0.0);
+  return new (thd->mem_root) Item_func_bit_count(arg1);
 }
 
-Item *create_func_exp(Item* a)
+
+Create_func_bit_length Create_func_bit_length::s_singleton;
+
+Item*
+Create_func_bit_length::create(THD *thd, Item *arg1)
 {
-  return new Item_func_exp(a);
+  return new (thd->mem_root) Item_func_bit_length(arg1);
 }
 
-Item *create_func_find_in_set(Item* a, Item *b)
+
+Create_func_ceiling Create_func_ceiling::s_singleton;
+
+Item*
+Create_func_ceiling::create(THD *thd, Item *arg1)
 {
-  return new Item_func_find_in_set(a, b);
+  return new (thd->mem_root) Item_func_ceiling(arg1);
 }
 
-Item *create_func_floor(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_centroid Create_func_centroid::s_singleton;
+
+Item*
+Create_func_centroid::create(THD *thd, Item *arg1)
 {
-  return new Item_func_floor(a);
+  return new (thd->mem_root) Item_func_centroid(arg1);
 }
+#endif
 
-Item *create_func_found_rows(void)
+
+Create_func_char_length Create_func_char_length::s_singleton;
+
+Item*
+Create_func_char_length::create(THD *thd, Item *arg1)
 {
-  THD *thd=current_thd;
-  thd->lex->safe_to_cache_query= 0;
-  return new Item_func_found_rows();
+  return new (thd->mem_root) Item_func_char_length(arg1);
 }
 
-Item *create_func_from_days(Item* a)
+
+Create_func_coercibility Create_func_coercibility::s_singleton;
+
+Item*
+Create_func_coercibility::create(THD *thd, Item *arg1)
 {
-  return new Item_func_from_days(a);
+  return new (thd->mem_root) Item_func_coercibility(arg1);
 }
 
-Item *create_func_get_lock(Item* a, Item *b)
+
+Create_func_concat Create_func_concat::s_singleton;
+
+Item*
+Create_func_concat::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_get_lock(a, b);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 1)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_concat(*item_list);
 }
 
-Item *create_func_hex(Item *a)
+
+Create_func_concat_ws Create_func_concat_ws::s_singleton;
+
+Item*
+Create_func_concat_ws::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_hex(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  /* "WS" stands for "With Separator": this function takes 2+ arguments */
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_concat_ws(*item_list);
 }
 
-Item *create_func_inet_ntoa(Item* a)
+
+Create_func_compress Create_func_compress::s_singleton;
+
+Item*
+Create_func_compress::create(THD *thd, Item *arg1)
 {
-  return new Item_func_inet_ntoa(a);
+  return new (thd->mem_root) Item_func_compress(arg1);
 }
 
-Item *create_func_inet_aton(Item* a)
+
+Create_func_connection_id Create_func_connection_id::s_singleton;
+
+Item*
+Create_func_connection_id::create(THD *thd)
 {
-  return new Item_func_inet_aton(a);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_connection_id();
 }
 
 
-Item *create_func_ifnull(Item* a, Item *b)
+#ifdef HAVE_SPATIAL
+Create_func_contains Create_func_contains::s_singleton;
+
+Item*
+Create_func_contains::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_ifnull(a,b);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_CONTAINS_FUNC);
 }
+#endif
+
 
-Item *create_func_nullif(Item* a, Item *b)
+Create_func_conv Create_func_conv::s_singleton;
+
+Item*
+Create_func_conv::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_nullif(a,b);
+  return new (thd->mem_root) Item_func_conv(arg1, arg2, arg3);
 }
 
-Item *create_func_locate(Item* a, Item *b)
+
+Create_func_convert_tz Create_func_convert_tz::s_singleton;
+
+Item*
+Create_func_convert_tz::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_locate(b,a);
+  if (thd->lex->add_time_zone_tables_to_query_tables(thd))
+    return NULL;
+
+  return new (thd->mem_root) Item_func_convert_tz(arg1, arg2, arg3);
 }
 
-Item *create_func_instr(Item* a, Item *b)
+
+Create_func_cos Create_func_cos::s_singleton;
+
+Item*
+Create_func_cos::create(THD *thd, Item *arg1)
 {
-  return new Item_func_locate(a,b);
+  return new (thd->mem_root) Item_func_cos(arg1);
 }
 
-Item *create_func_isnull(Item* a)
+
+Create_func_cot Create_func_cot::s_singleton;
+
+Item*
+Create_func_cot::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isnull(a);
+  Item *i1= new (thd->mem_root) Item_int((char*) "1", 1, 1);
+  Item *i2= new (thd->mem_root) Item_func_tan(arg1);
+  return new (thd->mem_root) Item_func_div(i1, i2);
 }
 
-Item *create_func_lcase(Item* a)
+
+Create_func_crc32 Create_func_crc32::s_singleton;
+
+Item*
+Create_func_crc32::create(THD *thd, Item *arg1)
 {
-  return new Item_func_lcase(a);
+  return new (thd->mem_root) Item_func_crc32(arg1);
 }
 
-Item *create_func_length(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_crosses Create_func_crosses::s_singleton;
+
+Item*
+Create_func_crosses::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_length(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_CROSSES_FUNC);
 }
+#endif
 
-Item *create_func_bit_length(Item* a)
+
+Create_func_date_format Create_func_date_format::s_singleton;
+
+Item*
+Create_func_date_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_bit_length(a);
+  return new (thd->mem_root) Item_func_date_format(arg1, arg2, 0);
 }
 
-Item *create_func_coercibility(Item* a)
+
+Create_func_datediff Create_func_datediff::s_singleton;
+
+Item*
+Create_func_datediff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_coercibility(a);
+  Item *i1= new (thd->mem_root) Item_func_to_days(arg1);
+  Item *i2= new (thd->mem_root) Item_func_to_days(arg2);
+
+  return new (thd->mem_root) Item_func_minus(i1, i2);
 }
 
-Item *create_func_char_length(Item* a)
+
+Create_func_dayname Create_func_dayname::s_singleton;
+
+Item*
+Create_func_dayname::create(THD *thd, Item *arg1)
 {
-  return new Item_func_char_length(a);
+  return new (thd->mem_root) Item_func_dayname(arg1);
 }
 
-Item *create_func_ln(Item* a)
+
+Create_func_dayofmonth Create_func_dayofmonth::s_singleton;
+
+Item*
+Create_func_dayofmonth::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ln(a);
+  return new (thd->mem_root) Item_func_dayofmonth(arg1);
 }
 
-Item *create_func_log2(Item* a)
+
+Create_func_dayofweek Create_func_dayofweek::s_singleton;
+
+Item*
+Create_func_dayofweek::create(THD *thd, Item *arg1)
 {
-  return new Item_func_log2(a);
+  return new (thd->mem_root) Item_func_weekday(arg1, 1);
 }
 
-Item *create_func_log10(Item* a)
+
+Create_func_dayofyear Create_func_dayofyear::s_singleton;
+
+Item*
+Create_func_dayofyear::create(THD *thd, Item *arg1)
 {
-  return new Item_func_log10(a);
+  return new (thd->mem_root) Item_func_dayofyear(arg1);
 }
 
-Item *create_func_lpad(Item* a, Item *b, Item *c)
+
+Create_func_decode Create_func_decode::s_singleton;
+
+Item*
+Create_func_decode::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_lpad(a,b,c);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "DECODE");
+    return NULL;
+  }
+
+  String dummy;
+  String *val = arg2->val_str(& dummy);
+  DBUG_ASSERT(val);
+  return new (thd->mem_root) Item_func_decode(arg1, val->c_ptr());
 }
 
-Item *create_func_ltrim(Item* a)
+
+Create_func_degrees Create_func_degrees::s_singleton;
+
+Item*
+Create_func_degrees::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ltrim(a);
+  return new (thd->mem_root) Item_func_units((char*) "degrees", arg1,
+                                             180/M_PI, 0.0);
 }
 
-Item *create_func_md5(Item* a)
+
+Create_func_des_decrypt Create_func_des_decrypt::s_singleton;
+
+Item*
+Create_func_des_decrypt::create(THD *thd, LEX_STRING name,
+                                List<Item> *item_list)
 {
-  return new Item_func_md5(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_decrypt(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_decrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_mod(Item* a, Item *b)
+
+Create_func_des_encrypt Create_func_des_encrypt::s_singleton;
+
+Item*
+Create_func_des_encrypt::create(THD *thd, LEX_STRING name,
+                                List<Item> *item_list)
 {
-  return new Item_func_mod(a,b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_encrypt(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_encrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_name_const(Item *a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_dimension Create_func_dimension::s_singleton;
+
+Item*
+Create_func_dimension::create(THD *thd, Item *arg1)
 {
-  return new Item_name_const(a,b);
+  return new (thd->mem_root) Item_func_dimension(arg1);
 }
+#endif
+
 
-Item *create_func_monthname(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_disjoint Create_func_disjoint::s_singleton;
+
+Item*
+Create_func_disjoint::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_monthname(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_DISJOINT_FUNC);
 }
+#endif
+
 
-Item *create_func_month(Item* a)
+Create_func_elt Create_func_elt::s_singleton;
+
+Item*
+Create_func_elt::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_month(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_elt(*item_list);
 }
 
-Item *create_func_oct(Item *a)
+
+Create_func_encode Create_func_encode::s_singleton;
+
+Item*
+Create_func_encode::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_conv(a,new Item_int((int32) 10,2),
-			    new Item_int((int32) 8,1));
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "ENCODE");
+    return NULL;
+  }
+
+  String dummy;
+  String *val = arg2->val_str(& dummy);
+  DBUG_ASSERT(val);
+  return new (thd->mem_root) Item_func_encode(arg1, val->c_ptr());
 }
 
-Item *create_func_period_add(Item* a, Item *b)
+
+Create_func_encrypt Create_func_encrypt::s_singleton;
+
+Item*
+Create_func_encrypt::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_period_add(a,b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_encrypt(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_encrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_period_diff(Item* a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_endpoint Create_func_endpoint::s_singleton;
+
+Item*
+Create_func_endpoint::create(THD *thd, Item *arg1)
 {
-  return new Item_func_period_diff(a,b);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_ENDPOINT);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_envelope Create_func_envelope::s_singleton;
 
-Item *create_func_pi(void)
+Item*
+Create_func_envelope::create(THD *thd, Item *arg1)
 {
-  return new Item_static_float_func("pi()", M_PI, 6, 8);
+  return new (thd->mem_root) Item_func_envelope(arg1);
 }
+#endif
+
 
-Item *create_func_pow(Item* a, Item *b)
+#ifdef HAVE_SPATIAL
+Create_func_equals Create_func_equals::s_singleton;
+
+Item*
+Create_func_equals::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_pow(a,b);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_EQUALS_FUNC);
 }
+#endif
+
+
+Create_func_exp Create_func_exp::s_singleton;
 
-Item *create_func_radians(Item *a)
+Item*
+Create_func_exp::create(THD *thd, Item *arg1)
 {
-  return new Item_func_units((char*) "radians",a,M_PI/180,0.0);
+  return new (thd->mem_root) Item_func_exp(arg1);
 }
 
-Item *create_func_release_lock(Item* a)
+
+Create_func_export_set Create_func_export_set::s_singleton;
+
+Item*
+Create_func_export_set::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_release_lock(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3);
+    break;
+  }
+  case 4:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    Item *param_4= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3,
+                                                   param_4);
+    break;
+  }
+  case 5:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    Item *param_4= item_list->pop();
+    Item *param_5= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3,
+                                                   param_4, param_5);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_repeat(Item* a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_exteriorring Create_func_exteriorring::s_singleton;
+
+Item*
+Create_func_exteriorring::create(THD *thd, Item *arg1)
 {
-  return new Item_func_repeat(a,b);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_EXTERIORRING);
 }
+#endif
 
-Item *create_func_reverse(Item* a)
+
+Create_func_field Create_func_field::s_singleton;
+
+Item*
+Create_func_field::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_reverse(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_field(*item_list);
 }
 
-Item *create_func_rpad(Item* a, Item *b, Item *c)
+
+Create_func_find_in_set Create_func_find_in_set::s_singleton;
+
+Item*
+Create_func_find_in_set::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_rpad(a,b,c);
+  return new (thd->mem_root) Item_func_find_in_set(arg1, arg2);
 }
 
-Item *create_func_rtrim(Item* a)
+
+Create_func_floor Create_func_floor::s_singleton;
+
+Item*
+Create_func_floor::create(THD *thd, Item *arg1)
 {
-  return new Item_func_rtrim(a);
+  return new (thd->mem_root) Item_func_floor(arg1);
 }
 
-Item *create_func_sec_to_time(Item* a)
+
+Create_func_format Create_func_format::s_singleton;
+
+Item*
+Create_func_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_sec_to_time(a);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::INT_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "FORMAT");
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_format(arg1, arg2->val_int());
 }
 
-Item *create_func_sign(Item* a)
+
+Create_func_found_rows Create_func_found_rows::s_singleton;
+
+Item*
+Create_func_found_rows::create(THD *thd)
 {
-  return new Item_func_sign(a);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_found_rows();
 }
 
-Item *create_func_sin(Item* a)
+
+Create_func_from_days Create_func_from_days::s_singleton;
+
+Item*
+Create_func_from_days::create(THD *thd, Item *arg1)
 {
-  return new Item_func_sin(a);
+  return new (thd->mem_root) Item_func_from_days(arg1);
 }
 
-Item *create_func_sha(Item* a)
+
+Create_func_from_unixtime Create_func_from_unixtime::s_singleton;
+
+Item*
+Create_func_from_unixtime::create(THD *thd, LEX_STRING name,
+                                  List<Item> *item_list)
 {
-  return new Item_func_sha(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_from_unixtime(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *ut= new (thd->mem_root) Item_func_from_unixtime(param_1);
+    func= new (thd->mem_root) Item_func_date_format(ut, param_2, 0);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_sleep(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_from_text Create_func_geometry_from_text::s_singleton;
+
+Item*
+Create_func_geometry_from_text::create(THD *thd, LEX_STRING name,
+                                       List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_sleep(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_text(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_text(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_from_wkb Create_func_geometry_from_wkb::s_singleton;
 
-Item *create_func_space(Item *a)
+Item*
+Create_func_geometry_from_wkb::create(THD *thd, LEX_STRING name,
+                                      List<Item> *item_list)
 {
-  CHARSET_INFO *cs= current_thd->variables.collation_connection;
-  Item *sp;
+  Item *func= NULL;
+  int arg_count= 0;
 
-  if (cs->mbminlen > 1)
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
   {
-    uint dummy_errors;
-    sp= new Item_string("",0,cs);
-    if (sp)
-      sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors);
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_wkb(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
   }
-  else
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_wkb(param_1, param_2);
+    break;
+  }
+  default:
   {
-    sp= new Item_string(" ",1,cs);
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
   }
-  return sp ? new Item_func_repeat(sp, a) : 0;
+
+  return func;
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_type Create_func_geometry_type::s_singleton;
 
-Item *create_func_soundex(Item* a)
+Item*
+Create_func_geometry_type::create(THD *thd, Item *arg1)
 {
-  return new Item_func_soundex(a);
+  return new (thd->mem_root) Item_func_geometry_type(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometryn Create_func_geometryn::s_singleton;
 
-Item *create_func_sqrt(Item* a)
+Item*
+Create_func_geometryn::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_sqrt(a);
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_GEOMETRYN);
 }
+#endif
+
+
+Create_func_get_lock Create_func_get_lock::s_singleton;
 
-Item *create_func_strcmp(Item* a, Item *b)
+Item*
+Create_func_get_lock::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_strcmp(a,b);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_get_lock(arg1, arg2);
 }
 
-Item *create_func_tan(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_glength Create_func_glength::s_singleton;
+
+Item*
+Create_func_glength::create(THD *thd, Item *arg1)
 {
-  return new Item_func_tan(a);
+  return new (thd->mem_root) Item_func_glength(arg1);
 }
+#endif
 
-Item *create_func_time_format(Item *a, Item *b)
+
+Create_func_greatest Create_func_greatest::s_singleton;
+
+Item*
+Create_func_greatest::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_date_format(a,b,1);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_max(*item_list);
 }
 
-Item *create_func_time_to_sec(Item* a)
+
+Create_func_hex Create_func_hex::s_singleton;
+
+Item*
+Create_func_hex::create(THD *thd, Item *arg1)
 {
-  return new Item_func_time_to_sec(a);
+  return new (thd->mem_root) Item_func_hex(arg1);
 }
 
-Item *create_func_to_days(Item* a)
+
+Create_func_ifnull Create_func_ifnull::s_singleton;
+
+Item*
+Create_func_ifnull::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_to_days(a);
+  return new (thd->mem_root) Item_func_ifnull(arg1, arg2);
 }
 
-Item *create_func_ucase(Item* a)
+
+Create_func_inet_ntoa Create_func_inet_ntoa::s_singleton;
+
+Item*
+Create_func_inet_ntoa::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ucase(a);
+  return new (thd->mem_root) Item_func_inet_ntoa(arg1);
 }
 
-Item *create_func_unhex(Item* a)
+
+Create_func_inet_aton Create_func_inet_aton::s_singleton;
+
+Item*
+Create_func_inet_aton::create(THD *thd, Item *arg1)
 {
-  return new Item_func_unhex(a);
+  return new (thd->mem_root) Item_func_inet_aton(arg1);
 }
 
-Item *create_func_uuid(void)
+
+Create_func_instr Create_func_instr::s_singleton;
+
+Item*
+Create_func_instr::create(THD *thd, Item *arg1, Item *arg2)
 {
-  THD *thd= current_thd;
-#ifdef HAVE_ROW_BASED_REPLICATION
-  thd->lex->binlog_row_based_if_mixed= TRUE;
+  return new (thd->mem_root) Item_func_locate(arg1, arg2);
+}
+
+
+#ifdef HAVE_SPATIAL
+Create_func_interiorringn Create_func_interiorringn::s_singleton;
+
+Item*
+Create_func_interiorringn::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_INTERIORRINGN);
+}
 #endif
-  return new(thd->mem_root) Item_func_uuid();
+
+
+#ifdef HAVE_SPATIAL
+Create_func_intersects Create_func_intersects::s_singleton;
+
+Item*
+Create_func_intersects::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_INTERSECTS_FUNC);
 }
+#endif
+
+
+Create_func_is_free_lock Create_func_is_free_lock::s_singleton;
 
-Item *create_func_version(void)
+Item*
+Create_func_is_free_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_static_string_func("version()", server_version,
-			 (uint) strlen(server_version),
-			 system_charset_info, DERIVATION_SYSCONST);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_is_free_lock(arg1);
 }
 
-Item *create_func_weekday(Item* a)
+
+Create_func_is_used_lock Create_func_is_used_lock::s_singleton;
+
+Item*
+Create_func_is_used_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_func_weekday(a, 0);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_is_used_lock(arg1);
 }
 
-Item *create_func_year(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_isclosed Create_func_isclosed::s_singleton;
+
+Item*
+Create_func_isclosed::create(THD *thd, Item *arg1)
 {
-  return new Item_func_year(a);
+  return new (thd->mem_root) Item_func_isclosed(arg1);
 }
+#endif
+
 
-Item *create_load_file(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_isempty Create_func_isempty::s_singleton;
+
+Item*
+Create_func_isempty::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_load_file(a);
+  return new (thd->mem_root) Item_func_isempty(arg1);
 }
+#endif
 
 
-Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec,
-		       CHARSET_INFO *cs)
+Create_func_isnull Create_func_isnull::s_singleton;
+
+Item*
+Create_func_isnull::create(THD *thd, Item *arg1)
 {
-  Item *res;
-  int tmp_len;
-  LINT_INIT(res);
+  return new (thd->mem_root) Item_func_isnull(arg1);
+}
 
-  switch (cast_type) {
-  case ITEM_CAST_BINARY: 	res= new Item_func_binary(a); break;
-  case ITEM_CAST_SIGNED_INT:	res= new Item_func_signed(a); break;
-  case ITEM_CAST_UNSIGNED_INT:  res= new Item_func_unsigned(a); break;
-  case ITEM_CAST_DATE:		res= new Item_date_typecast(a); break;
-  case ITEM_CAST_TIME:		res= new Item_time_typecast(a); break;
-  case ITEM_CAST_DATETIME:	res= new Item_datetime_typecast(a); break;
-  case ITEM_CAST_DECIMAL:
-    tmp_len= (len>0) ? len : 10;
-    if (tmp_len < dec)
-    {
-      my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
-      return 0;
-    }
-    res= new Item_decimal_typecast(a, tmp_len, dec);
+
+#ifdef HAVE_SPATIAL
+Create_func_issimple Create_func_issimple::s_singleton;
+
+Item*
+Create_func_issimple::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_issimple(arg1);
+}
+#endif
+
+
+Create_func_last_day Create_func_last_day::s_singleton;
+
+Item*
+Create_func_last_day::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_last_day(arg1);
+}
+
+
+Create_func_last_insert_id Create_func_last_insert_id::s_singleton;
+
+Item*
+Create_func_last_insert_id::create(THD *thd, LEX_STRING name,
+                                   List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_last_insert_id();
+    thd->lex->safe_to_cache_query= 0;
     break;
-  case ITEM_CAST_CHAR:
-    res= new Item_char_typecast(a, len, cs ? cs : 
-				current_thd->variables.collation_connection);
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_last_insert_id(param_1);
+    thd->lex->safe_to_cache_query= 0;
     break;
+  }
   default:
-    DBUG_ASSERT(0);
-    res= 0;
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
     break;
   }
-  return res;
+  }
+
+  return func;
+}
+
+
+Create_func_lcase Create_func_lcase::s_singleton;
+
+Item*
+Create_func_lcase::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_lcase(arg1);
+}
+
+
+Create_func_least Create_func_least::s_singleton;
+
+Item*
+Create_func_least::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_min(*item_list);
+}
+
+
+Create_func_length Create_func_length::s_singleton;
+
+Item*
+Create_func_length::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_length(arg1);
+}
+
+
+Create_func_ln Create_func_ln::s_singleton;
+
+Item*
+Create_func_ln::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ln(arg1);
+}
+
+
+Create_func_load_file Create_func_load_file::s_singleton;
+
+Item*
+Create_func_load_file::create(THD *thd, Item *arg1)
+{
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_load_file(arg1);
+}
+
+
+Create_func_locate Create_func_locate::s_singleton;
+
+Item*
+Create_func_locate::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    /* Yes, parameters in that order : 2, 1 */
+    func= new (thd->mem_root) Item_func_locate(param_2, param_1);
+    break;
+  }
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    /* Yes, parameters in that order : 2, 1, 3 */
+    func= new (thd->mem_root) Item_func_locate(param_2, param_1, param_3);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_log Create_func_log::s_singleton;
+
+Item*
+Create_func_log::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_log(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_log(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_log10 Create_func_log10::s_singleton;
+
+Item*
+Create_func_log10::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_log10(arg1);
+}
+
+
+Create_func_log2 Create_func_log2::s_singleton;
+
+Item*
+Create_func_log2::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_log2(arg1);
+}
+
+
+Create_func_lpad Create_func_lpad::s_singleton;
+
+Item*
+Create_func_lpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_lpad(arg1, arg2, arg3);
+}
+
+
+Create_func_ltrim Create_func_ltrim::s_singleton;
+
+Item*
+Create_func_ltrim::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ltrim(arg1);
+}
+
+
+Create_func_makedate Create_func_makedate::s_singleton;
+
+Item*
+Create_func_makedate::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_makedate(arg1, arg2);
+}
+
+
+Create_func_maketime Create_func_maketime::s_singleton;
+
+Item*
+Create_func_maketime::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_maketime(arg1, arg2, arg3);
+}
+
+
+Create_func_make_set Create_func_make_set::s_singleton;
+
+Item*
+Create_func_make_set::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  return new (thd->mem_root) Item_func_make_set(param_1, *item_list);
 }
 
-Item *create_func_is_free_lock(Item* a)
+
+Create_func_master_pos_wait Create_func_master_pos_wait::s_singleton;
+
+Item*
+Create_func_master_pos_wait::create(THD *thd, LEX_STRING name,
+                                    List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_is_free_lock(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2);
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2, param_3);
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_is_used_lock(Item* a)
+
+Create_func_md5 Create_func_md5::s_singleton;
+
+Item*
+Create_func_md5::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_is_used_lock(a);
+  return new (thd->mem_root) Item_func_md5(arg1);
 }
 
-Item *create_func_quote(Item* a)
+
+Create_func_monthname Create_func_monthname::s_singleton;
+
+Item*
+Create_func_monthname::create(THD *thd, Item *arg1)
 {
-  return new Item_func_quote(a);
+  return new (thd->mem_root) Item_func_monthname(arg1);
 }
 
-Item *create_func_xml_extractvalue(Item *a, Item *b)
+
+Create_func_name_const Create_func_name_const::s_singleton;
+
+Item*
+Create_func_name_const::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_xml_extractvalue(a, b);
+  return new (thd->mem_root) Item_name_const(arg1, arg2);
 }
 
-Item *create_func_xml_update(Item *a, Item *b, Item *c)
+
+Create_func_nullif Create_func_nullif::s_singleton;
+
+Item*
+Create_func_nullif::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_xml_update(a, b, c);
+  return new (thd->mem_root) Item_func_nullif(arg1, arg2);
 }
 
+
 #ifdef HAVE_SPATIAL
-Item *create_func_as_wkt(Item *a)
+Create_func_numgeometries Create_func_numgeometries::s_singleton;
+
+Item*
+Create_func_numgeometries::create(THD *thd, Item *arg1)
 {
-  return new Item_func_as_wkt(a);
+  return new (thd->mem_root) Item_func_numgeometries(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_numinteriorring Create_func_numinteriorring::s_singleton;
 
-Item *create_func_as_wkb(Item *a)
+Item*
+Create_func_numinteriorring::create(THD *thd, Item *arg1)
 {
-  return new Item_func_as_wkb(a);
+  return new (thd->mem_root) Item_func_numinteriorring(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_numpoints Create_func_numpoints::s_singleton;
 
-Item *create_func_srid(Item *a)
+Item*
+Create_func_numpoints::create(THD *thd, Item *arg1)
 {
-  return new Item_func_srid(a);
+  return new (thd->mem_root) Item_func_numpoints(arg1);
 }
+#endif
+
+
+Create_func_oct Create_func_oct::s_singleton;
 
-Item *create_func_startpoint(Item *a)
+Item*
+Create_func_oct::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT);
+  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
+  Item *i8= new (thd->mem_root) Item_int((int32) 8,1);
+  return new (thd->mem_root) Item_func_conv(arg1, i10, i8);
 }
 
-Item *create_func_endpoint(Item *a)
+
+Create_func_ord Create_func_ord::s_singleton;
+
+Item*
+Create_func_ord::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT);
+  return new (thd->mem_root) Item_func_ord(arg1);
 }
 
-Item *create_func_exteriorring(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_overlaps Create_func_overlaps::s_singleton;
+
+Item*
+Create_func_overlaps::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_OVERLAPS_FUNC);
 }
+#endif
+
 
-Item *create_func_pointn(Item *a, Item *b)
+Create_func_period_add Create_func_period_add::s_singleton;
+
+Item*
+Create_func_period_add::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN);
+  return new (thd->mem_root) Item_func_period_add(arg1, arg2);
 }
 
-Item *create_func_interiorringn(Item *a, Item *b)
+
+Create_func_period_diff Create_func_period_diff::s_singleton;
+
+Item*
+Create_func_period_diff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN);
+  return new (thd->mem_root) Item_func_period_diff(arg1, arg2);
 }
 
-Item *create_func_geometryn(Item *a, Item *b)
+
+Create_func_pi Create_func_pi::s_singleton;
+
+Item*
+Create_func_pi::create(THD *thd)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN);
+  return new (thd->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
 }
 
-Item *create_func_centroid(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_pointn Create_func_pointn::s_singleton;
+
+Item*
+Create_func_pointn::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_centroid(a);
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_POINTN);
 }
+#endif
+
 
-Item *create_func_envelope(Item *a)
+Create_func_pow Create_func_pow::s_singleton;
+
+Item*
+Create_func_pow::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_envelope(a);
+  return new (thd->mem_root) Item_func_pow(arg1, arg2);
 }
 
-Item *create_func_equals(Item *a, Item *b)
+
+Create_func_quote Create_func_quote::s_singleton;
+
+Item*
+Create_func_quote::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC);
+  return new (thd->mem_root) Item_func_quote(arg1);
 }
 
-Item *create_func_disjoint(Item *a, Item *b)
+
+Create_func_radians Create_func_radians::s_singleton;
+
+Item*
+Create_func_radians::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC);
+  return new (thd->mem_root) Item_func_units((char*) "radians", arg1,
+                                             M_PI/180, 0.0);
 }
 
-Item *create_func_intersects(Item *a, Item *b)
+
+Create_func_rand Create_func_rand::s_singleton;
+
+Item*
+Create_func_rand::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_rand();
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_rand(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_touches(Item *a, Item *b)
+
+Create_func_release_lock Create_func_release_lock::s_singleton;
+
+Item*
+Create_func_release_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_release_lock(arg1);
 }
 
-Item *create_func_crosses(Item *a, Item *b)
+
+Create_func_reverse Create_func_reverse::s_singleton;
+
+Item*
+Create_func_reverse::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC);
+  return new (thd->mem_root) Item_func_reverse(arg1);
 }
 
-Item *create_func_within(Item *a, Item *b)
+
+Create_func_round Create_func_round::s_singleton;
+
+Item*
+Create_func_round::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    Item *i0 = new (thd->mem_root) Item_int((char*)"0", 0, 1);
+    func= new (thd->mem_root) Item_func_round(param_1, i0, 0);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_round(param_1, param_2, 0);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_contains(Item *a, Item *b)
+
+Create_func_row_count Create_func_row_count::s_singleton;
+
+Item*
+Create_func_row_count::create(THD *thd)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_row_count();
 }
 
-Item *create_func_overlaps(Item *a, Item *b)
+
+Create_func_rpad Create_func_rpad::s_singleton;
+
+Item*
+Create_func_rpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC);
+  return new (thd->mem_root) Item_func_rpad(arg1, arg2, arg3);
 }
 
-Item *create_func_isempty(Item *a)
+
+Create_func_rtrim Create_func_rtrim::s_singleton;
+
+Item*
+Create_func_rtrim::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isempty(a);
+  return new (thd->mem_root) Item_func_rtrim(arg1);
 }
 
-Item *create_func_issimple(Item *a)
+
+Create_func_sec_to_time Create_func_sec_to_time::s_singleton;
+
+Item*
+Create_func_sec_to_time::create(THD *thd, Item *arg1)
 {
-  return new Item_func_issimple(a);
+  return new (thd->mem_root) Item_func_sec_to_time(arg1);
 }
 
-Item *create_func_isclosed(Item *a)
+
+Create_func_sha Create_func_sha::s_singleton;
+
+Item*
+Create_func_sha::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isclosed(a);
+  return new (thd->mem_root) Item_func_sha(arg1);
 }
 
-Item *create_func_geometry_type(Item *a)
+
+Create_func_sign Create_func_sign::s_singleton;
+
+Item*
+Create_func_sign::create(THD *thd, Item *arg1)
 {
-  return new Item_func_geometry_type(a);
+  return new (thd->mem_root) Item_func_sign(arg1);
 }
 
-Item *create_func_dimension(Item *a)
+
+Create_func_sin Create_func_sin::s_singleton;
+
+Item*
+Create_func_sin::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dimension(a);
+  return new (thd->mem_root) Item_func_sin(arg1);
 }
 
-Item *create_func_x(Item *a)
+
+Create_func_sleep Create_func_sleep::s_singleton;
+
+Item*
+Create_func_sleep::create(THD *thd, Item *arg1)
 {
-  return new Item_func_x(a);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_sleep(arg1);
 }
 
-Item *create_func_y(Item *a)
+
+Create_func_soundex Create_func_soundex::s_singleton;
+
+Item*
+Create_func_soundex::create(THD *thd, Item *arg1)
 {
-  return new Item_func_y(a);
+  return new (thd->mem_root) Item_func_soundex(arg1);
 }
 
-Item *create_func_numpoints(Item *a)
+
+Create_func_space Create_func_space::s_singleton;
+
+Item*
+Create_func_space::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numpoints(a);
+  /**
+    TODO: Fix Bug#23637
+    The parsed item tree should not depend on
+    <code>thd->variables.collation_connection</code>.
+  */
+  CHARSET_INFO *cs= thd->variables.collation_connection;
+  Item *sp;
+
+  if (cs->mbminlen > 1)
+  {
+    uint dummy_errors;
+    sp= new (thd->mem_root) Item_string("", 0, cs);
+    sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors);
+  }
+  else
+  {
+    sp= new (thd->mem_root) Item_string(" ", 1, cs);
+  }
+
+  return new (thd->mem_root) Item_func_repeat(sp, arg1);
 }
 
-Item *create_func_numinteriorring(Item *a)
+
+Create_func_sqrt Create_func_sqrt::s_singleton;
+
+Item*
+Create_func_sqrt::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numinteriorring(a);
+  return new (thd->mem_root) Item_func_sqrt(arg1);
 }
 
-Item *create_func_numgeometries(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_srid Create_func_srid::s_singleton;
+
+Item*
+Create_func_srid::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numgeometries(a);
+  return new (thd->mem_root) Item_func_srid(arg1);
 }
+#endif
 
-Item *create_func_area(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_startpoint Create_func_startpoint::s_singleton;
+
+Item*
+Create_func_startpoint::create(THD *thd, Item *arg1)
 {
-  return new Item_func_area(a);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_STARTPOINT);
 }
+#endif
 
-Item *create_func_glength(Item *a)
+
+Create_func_str_to_date Create_func_str_to_date::s_singleton;
+
+Item*
+Create_func_str_to_date::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_glength(a);
+  return new (thd->mem_root) Item_func_str_to_date(arg1, arg2);
 }
 
-Item *create_func_point(Item *a, Item *b)
+
+Create_func_strcmp Create_func_strcmp::s_singleton;
+
+Item*
+Create_func_strcmp::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_point(a, b);
+  return new (thd->mem_root) Item_func_strcmp(arg1, arg2);
 }
-#endif /*HAVE_SPATIAL*/
 
-Item *create_func_crc32(Item* a)
+
+Create_func_substr_index Create_func_substr_index::s_singleton;
+
+Item*
+Create_func_substr_index::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_crc32(a);
+  return new (thd->mem_root) Item_func_substr_index(arg1, arg2, arg3);
 }
 
-Item *create_func_compress(Item* a)
+
+Create_func_subtime Create_func_subtime::s_singleton;
+
+Item*
+Create_func_subtime::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_compress(a);
+  return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 1);
 }
 
-Item *create_func_uncompress(Item* a)
+
+Create_func_tan Create_func_tan::s_singleton;
+
+Item*
+Create_func_tan::create(THD *thd, Item *arg1)
 {
-  return new Item_func_uncompress(a);
+  return new (thd->mem_root) Item_func_tan(arg1);
 }
 
-Item *create_func_uncompressed_length(Item* a)
+
+Create_func_time_format Create_func_time_format::s_singleton;
+
+Item*
+Create_func_time_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_uncompressed_length(a);
+  return new (thd->mem_root) Item_func_date_format(arg1, arg2, 1);
 }
 
-Item *create_func_datediff(Item *a, Item *b)
+
+Create_func_time_to_sec Create_func_time_to_sec::s_singleton;
+
+Item*
+Create_func_time_to_sec::create(THD *thd, Item *arg1)
 {
-  return new Item_func_minus(new Item_func_to_days(a),
-			     new Item_func_to_days(b));
+  return new (thd->mem_root) Item_func_time_to_sec(arg1);
 }
 
-Item *create_func_weekofyear(Item *a)
+
+Create_func_timediff Create_func_timediff::s_singleton;
+
+Item*
+Create_func_timediff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_week(a, new Item_int((char*) "0", 3, 1));
+  return new (thd->mem_root) Item_func_timediff(arg1, arg2);
 }
 
-Item *create_func_makedate(Item* a,Item* b)
+
+Create_func_to_days Create_func_to_days::s_singleton;
+
+Item*
+Create_func_to_days::create(THD *thd, Item *arg1)
 {
-  return new Item_func_makedate(a, b);
+  return new (thd->mem_root) Item_func_to_days(arg1);
 }
 
-Item *create_func_addtime(Item* a,Item* b)
+
+#ifdef HAVE_SPATIAL
+Create_func_touches Create_func_touches::s_singleton;
+
+Item*
+Create_func_touches::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_add_time(a, b, 0, 0);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_TOUCHES_FUNC);
 }
+#endif
+
 
-Item *create_func_subtime(Item* a,Item* b)
+Create_func_ucase Create_func_ucase::s_singleton;
+
+Item*
+Create_func_ucase::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ucase(arg1);
+}
+
+
+Create_func_uncompress Create_func_uncompress::s_singleton;
+
+Item*
+Create_func_uncompress::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_uncompress(arg1);
+}
+
+
+Create_func_uncompressed_length Create_func_uncompressed_length::s_singleton;
+
+Item*
+Create_func_uncompressed_length::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_uncompressed_length(arg1);
+}
+
+
+Create_func_unhex Create_func_unhex::s_singleton;
+
+Item*
+Create_func_unhex::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_unhex(arg1);
+}
+
+
+Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;
+
+Item*
+Create_func_unix_timestamp::create(THD *thd, LEX_STRING name,
+                                   List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_unix_timestamp();
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_unix_timestamp(param_1);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_uuid Create_func_uuid::s_singleton;
+
+Item*
+Create_func_uuid::create(THD *thd)
 {
-  return new Item_func_add_time(a, b, 0, 1);
+#ifdef HAVE_ROW_BASED_REPLICATION
+  thd->lex->binlog_row_based_if_mixed= TRUE;
+#endif
+  return new (thd->mem_root) Item_func_uuid();
 }
 
-Item *create_func_timediff(Item* a,Item* b)
+
+Create_func_version Create_func_version::s_singleton;
+
+Item*
+Create_func_version::create(THD *thd)
 {
-  return new Item_func_timediff(a, b);
+  return new (thd->mem_root) Item_static_string_func("version()",
+                                                     server_version,
+                                                     (uint) strlen(server_version),
+                                                     system_charset_info,
+                                                     DERIVATION_SYSCONST);
 }
 
-Item *create_func_maketime(Item* a,Item* b,Item* c)
+
+Create_func_weekday Create_func_weekday::s_singleton;
+
+Item*
+Create_func_weekday::create(THD *thd, Item *arg1)
 {
-  return new Item_func_maketime(a, b, c);
+  return new (thd->mem_root) Item_func_weekday(arg1, 0);
 }
 
-Item *create_func_str_to_date(Item* a,Item* b)
+
+Create_func_weekofyear Create_func_weekofyear::s_singleton;
+
+Item*
+Create_func_weekofyear::create(THD *thd, Item *arg1)
 {
-  return new Item_func_str_to_date(a, b);
+  Item *i1= new (thd->mem_root) Item_int((char*) "0", 3, 1);
+  return new (thd->mem_root) Item_func_week(arg1, i1);
 }
 
-Item *create_func_last_day(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_within Create_func_within::s_singleton;
+
+Item*
+Create_func_within::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_last_day(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_WITHIN_FUNC);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_x Create_func_x::s_singleton;
+
+Item*
+Create_func_x::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_x(arg1);
+}
+#endif
+
+
+Create_func_xml_extractvalue Create_func_xml_extractvalue::s_singleton;
+
+Item*
+Create_func_xml_extractvalue::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_xml_extractvalue(arg1, arg2);
+}
+
+
+Create_func_xml_update Create_func_xml_update::s_singleton;
+
+Item*
+Create_func_xml_update::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_xml_update(arg1, arg2, arg3);
+}
+
+
+#ifdef HAVE_SPATIAL
+Create_func_y Create_func_y::s_singleton;
+
+Item*
+Create_func_y::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_y(arg1);
+}
+#endif
+
+
+Create_func_year_week Create_func_year_week::s_singleton;
+
+Item*
+Create_func_year_week::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    Item *i0= new (thd->mem_root) Item_int((char*) "0", 0, 1);
+    func= new (thd->mem_root) Item_func_yearweek(param_1, i0);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_yearweek(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+struct Native_func_registry
+{
+  LEX_STRING name;
+  Create_func *builder;
+};
+
+#define BUILDER(F) & F::s_singleton
+
+#ifdef HAVE_SPATIAL
+  #define GEOM_BUILDER(F) & F::s_singleton
+#else
+  #define GEOM_BUILDER(F) & Create_func_no_geom::s_singleton
+#endif
+
+/*
+  MySQL native functions.
+  MAINTAINER:
+  - Keep sorted for human lookup. At runtime, a hash table is used.
+  - do **NOT** conditionally (#ifdef, #ifndef) define a function *NAME*:
+    doing so will cause user code that works against a --without-XYZ binary
+    to fail with name collisions against a --with-XYZ binary.
+    Use something similar to GEOM_BUILDER instead.
+  - keep 1 line per entry, it makes grep | sort easier
+*/
+
+static Native_func_registry func_array[] =
+{
+  { C_STRING_WITH_LEN("ABS"), BUILDER(Create_func_abs)},
+  { C_STRING_WITH_LEN("ACOS"), BUILDER(Create_func_acos)},
+  { C_STRING_WITH_LEN("ADDTIME"), BUILDER(Create_func_addtime)},
+  { C_STRING_WITH_LEN("AES_DECRYPT"), BUILDER(Create_func_aes_decrypt)},
+  { C_STRING_WITH_LEN("AES_ENCRYPT"), BUILDER(Create_func_aes_encrypt)},
+  { C_STRING_WITH_LEN("AREA"), GEOM_BUILDER(Create_func_area)},
+  { C_STRING_WITH_LEN("ASBINARY"), GEOM_BUILDER(Create_func_as_wkb)},
+  { C_STRING_WITH_LEN("ASIN"), BUILDER(Create_func_asin)},
+  { C_STRING_WITH_LEN("ASTEXT"), GEOM_BUILDER(Create_func_as_wkt)},
+  { C_STRING_WITH_LEN("ASWKB"), GEOM_BUILDER(Create_func_as_wkb)},
+  { C_STRING_WITH_LEN("ASWKT"), GEOM_BUILDER(Create_func_as_wkt)},
+  { C_STRING_WITH_LEN("ATAN"), BUILDER(Create_func_atan)},
+  { C_STRING_WITH_LEN("ATAN2"), BUILDER(Create_func_atan)},
+  { C_STRING_WITH_LEN("BENCHMARK"), BUILDER(Create_func_benchmark)},
+  { C_STRING_WITH_LEN("BIN"), BUILDER(Create_func_bin)},
+  { C_STRING_WITH_LEN("BIT_COUNT"), BUILDER(Create_func_bit_count)},
+  { C_STRING_WITH_LEN("BIT_LENGTH"), BUILDER(Create_func_bit_length)},
+  { C_STRING_WITH_LEN("CEIL"), BUILDER(Create_func_ceiling)},
+  { C_STRING_WITH_LEN("CEILING"), BUILDER(Create_func_ceiling)},
+  { C_STRING_WITH_LEN("CENTROID"), GEOM_BUILDER(Create_func_centroid)},
+  { C_STRING_WITH_LEN("CHARACTER_LENGTH"), BUILDER(Create_func_char_length)},
+  { C_STRING_WITH_LEN("CHAR_LENGTH"), BUILDER(Create_func_char_length)},
+  { C_STRING_WITH_LEN("COERCIBILITY"), BUILDER(Create_func_coercibility)},
+  { C_STRING_WITH_LEN("COMPRESS"), BUILDER(Create_func_compress)},
+  { C_STRING_WITH_LEN("CONCAT"), BUILDER(Create_func_concat)},
+  { C_STRING_WITH_LEN("CONCAT_WS"), BUILDER(Create_func_concat_ws)},
+  { C_STRING_WITH_LEN("CONNECTION_ID"), BUILDER(Create_func_connection_id)},
+  { C_STRING_WITH_LEN("CONV"), BUILDER(Create_func_conv)},
+  { C_STRING_WITH_LEN("CONVERT_TZ"), BUILDER(Create_func_convert_tz)},
+  { C_STRING_WITH_LEN("COS"), BUILDER(Create_func_cos)},
+  { C_STRING_WITH_LEN("COT"), BUILDER(Create_func_cot)},
+  { C_STRING_WITH_LEN("CRC32"), BUILDER(Create_func_crc32)},
+  { C_STRING_WITH_LEN("CROSSES"), GEOM_BUILDER(Create_func_crosses)},
+  { C_STRING_WITH_LEN("DATEDIFF"), BUILDER(Create_func_datediff)},
+  { C_STRING_WITH_LEN("DATE_FORMAT"), BUILDER(Create_func_date_format)},
+  { C_STRING_WITH_LEN("DAYNAME"), BUILDER(Create_func_dayname)},
+  { C_STRING_WITH_LEN("DAYOFMONTH"), BUILDER(Create_func_dayofmonth)},
+  { C_STRING_WITH_LEN("DAYOFWEEK"), BUILDER(Create_func_dayofweek)},
+  { C_STRING_WITH_LEN("DAYOFYEAR"), BUILDER(Create_func_dayofyear)},
+  { C_STRING_WITH_LEN("DECODE"), BUILDER(Create_func_decode)},
+  { C_STRING_WITH_LEN("DEGREES"), BUILDER(Create_func_degrees)},
+  { C_STRING_WITH_LEN("DES_DECRYPT"), BUILDER(Create_func_des_decrypt)},
+  { C_STRING_WITH_LEN("DES_ENCRYPT"), BUILDER(Create_func_des_encrypt)},
+  { C_STRING_WITH_LEN("DIMENSION"), GEOM_BUILDER(Create_func_dimension)},
+  { C_STRING_WITH_LEN("DISJOINT"), GEOM_BUILDER(Create_func_disjoint)},
+  { C_STRING_WITH_LEN("ELT"), BUILDER(Create_func_elt)},
+  { C_STRING_WITH_LEN("ENCODE"), BUILDER(Create_func_encode)},
+  { C_STRING_WITH_LEN("ENCRYPT"), BUILDER(Create_func_encrypt)},
+  { C_STRING_WITH_LEN("ENDPOINT"), GEOM_BUILDER(Create_func_endpoint)},
+  { C_STRING_WITH_LEN("ENVELOPE"), GEOM_BUILDER(Create_func_envelope)},
+  { C_STRING_WITH_LEN("EQUALS"), GEOM_BUILDER(Create_func_equals)},
+  { C_STRING_WITH_LEN("EXP"), BUILDER(Create_func_exp)},
+  { C_STRING_WITH_LEN("EXPORT_SET"), BUILDER(Create_func_export_set)},
+  { C_STRING_WITH_LEN("EXTERIORRING"), GEOM_BUILDER(Create_func_exteriorring)},
+  { C_STRING_WITH_LEN("EXTRACTVALUE"), BUILDER(Create_func_xml_extractvalue)},
+  { C_STRING_WITH_LEN("FIELD"), BUILDER(Create_func_field)},
+  { C_STRING_WITH_LEN("FIND_IN_SET"), BUILDER(Create_func_find_in_set)},
+  { C_STRING_WITH_LEN("FLOOR"), BUILDER(Create_func_floor)},
+  { C_STRING_WITH_LEN("FORMAT"), BUILDER(Create_func_format)},
+  { C_STRING_WITH_LEN("FOUND_ROWS"), BUILDER(Create_func_found_rows)},
+  { C_STRING_WITH_LEN("FROM_DAYS"), BUILDER(Create_func_from_days)},
+  { C_STRING_WITH_LEN("FROM_UNIXTIME"), BUILDER(Create_func_from_unixtime)},
+  { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMCOLLFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMETRYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYN"), GEOM_BUILDER(Create_func_geometryn)},
+  { C_STRING_WITH_LEN("GEOMETRYTYPE"), GEOM_BUILDER(Create_func_geometry_type)},
+  { C_STRING_WITH_LEN("GEOMFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GET_LOCK"), BUILDER(Create_func_get_lock)},
+  { C_STRING_WITH_LEN("GLENGTH"), GEOM_BUILDER(Create_func_glength)},
+  { C_STRING_WITH_LEN("GREATEST"), BUILDER(Create_func_greatest)},
+  { C_STRING_WITH_LEN("HEX"), BUILDER(Create_func_hex)},
+  { C_STRING_WITH_LEN("IFNULL"), BUILDER(Create_func_ifnull)},
+  { C_STRING_WITH_LEN("INET_ATON"), BUILDER(Create_func_inet_aton)},
+  { C_STRING_WITH_LEN("INET_NTOA"), BUILDER(Create_func_inet_ntoa)},
+  { C_STRING_WITH_LEN("INSTR"), BUILDER(Create_func_instr)},
+  { C_STRING_WITH_LEN("INTERIORRINGN"), GEOM_BUILDER(Create_func_interiorringn)},
+  { C_STRING_WITH_LEN("INTERSECTS"), GEOM_BUILDER(Create_func_intersects)},
+  { C_STRING_WITH_LEN("ISCLOSED"), GEOM_BUILDER(Create_func_isclosed)},
+  { C_STRING_WITH_LEN("ISEMPTY"), GEOM_BUILDER(Create_func_isempty)},
+  { C_STRING_WITH_LEN("ISNULL"), BUILDER(Create_func_isnull)},
+  { C_STRING_WITH_LEN("ISSIMPLE"), GEOM_BUILDER(Create_func_issimple)},
+  { C_STRING_WITH_LEN("IS_FREE_LOCK"), BUILDER(Create_func_is_free_lock)},
+  { C_STRING_WITH_LEN("IS_USED_LOCK"), BUILDER(Create_func_is_used_lock)},
+  { C_STRING_WITH_LEN("LAST_DAY"), BUILDER(Create_func_last_day)},
+  { C_STRING_WITH_LEN("LAST_INSERT_ID"), BUILDER(Create_func_last_insert_id)},
+  { C_STRING_WITH_LEN("LCASE"), BUILDER(Create_func_lcase)},
+  { C_STRING_WITH_LEN("LEAST"), BUILDER(Create_func_least)},
+  { C_STRING_WITH_LEN("LENGTH"), BUILDER(Create_func_length)},
+  { C_STRING_WITH_LEN("LINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("LINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("LINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("LINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("LN"), BUILDER(Create_func_ln)},
+  { C_STRING_WITH_LEN("LOAD_FILE"), BUILDER(Create_func_load_file)},
+  { C_STRING_WITH_LEN("LOCATE"), BUILDER(Create_func_locate)},
+  { C_STRING_WITH_LEN("LOG"), BUILDER(Create_func_log)},
+  { C_STRING_WITH_LEN("LOG10"), BUILDER(Create_func_log10)},
+  { C_STRING_WITH_LEN("LOG2"), BUILDER(Create_func_log2)},
+  { C_STRING_WITH_LEN("LOWER"), BUILDER(Create_func_lcase)},
+  { C_STRING_WITH_LEN("LPAD"), BUILDER(Create_func_lpad)},
+  { C_STRING_WITH_LEN("LTRIM"), BUILDER(Create_func_ltrim)},
+  { C_STRING_WITH_LEN("MAKEDATE"), BUILDER(Create_func_makedate)},
+  { C_STRING_WITH_LEN("MAKETIME"), BUILDER(Create_func_maketime)},
+  { C_STRING_WITH_LEN("MAKE_SET"), BUILDER(Create_func_make_set)},
+  { C_STRING_WITH_LEN("MASTER_POS_WAIT"), BUILDER(Create_func_master_pos_wait)},
+  { C_STRING_WITH_LEN("MBRCONTAINS"), GEOM_BUILDER(Create_func_contains)},
+  { C_STRING_WITH_LEN("MD5"), BUILDER(Create_func_md5)},
+  { C_STRING_WITH_LEN("MLINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MLINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MONTHNAME"), BUILDER(Create_func_monthname)},
+  { C_STRING_WITH_LEN("MPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MPOLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MPOLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTIPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("NAME_CONST"), BUILDER(Create_func_name_const)},
+  { C_STRING_WITH_LEN("NULLIF"), BUILDER(Create_func_nullif)},
+  { C_STRING_WITH_LEN("NUMGEOMETRIES"), GEOM_BUILDER(Create_func_numgeometries)},
+  { C_STRING_WITH_LEN("NUMINTERIORRINGS"), GEOM_BUILDER(Create_func_numinteriorring)},
+  { C_STRING_WITH_LEN("NUMPOINTS"), GEOM_BUILDER(Create_func_numpoints)},
+  { C_STRING_WITH_LEN("OCT"), BUILDER(Create_func_oct)},
+  { C_STRING_WITH_LEN("OCTET_LENGTH"), BUILDER(Create_func_length)},
+  { C_STRING_WITH_LEN("ORD"), BUILDER(Create_func_ord)},
+  { C_STRING_WITH_LEN("OVERLAPS"), GEOM_BUILDER(Create_func_overlaps)},
+  { C_STRING_WITH_LEN("PERIOD_ADD"), BUILDER(Create_func_period_add)},
+  { C_STRING_WITH_LEN("PERIOD_DIFF"), BUILDER(Create_func_period_diff)},
+  { C_STRING_WITH_LEN("PI"), BUILDER(Create_func_pi)},
+  { C_STRING_WITH_LEN("POINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POINTN"), GEOM_BUILDER(Create_func_pointn)},
+  { C_STRING_WITH_LEN("POLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POW"), BUILDER(Create_func_pow)},
+  { C_STRING_WITH_LEN("POWER"), BUILDER(Create_func_pow)},
+  { C_STRING_WITH_LEN("QUOTE"), BUILDER(Create_func_quote)},
+  { C_STRING_WITH_LEN("RADIANS"), BUILDER(Create_func_radians)},
+  { C_STRING_WITH_LEN("RAND"), BUILDER(Create_func_rand)},
+  { C_STRING_WITH_LEN("RELEASE_LOCK"), BUILDER(Create_func_release_lock)},
+  { C_STRING_WITH_LEN("REVERSE"), BUILDER(Create_func_reverse)},
+  { C_STRING_WITH_LEN("ROUND"), BUILDER(Create_func_round)},
+  { C_STRING_WITH_LEN("ROW_COUNT"), BUILDER(Create_func_row_count)},
+  { C_STRING_WITH_LEN("RPAD"), BUILDER(Create_func_rpad)},
+  { C_STRING_WITH_LEN("RTRIM"), BUILDER(Create_func_rtrim)},
+  { C_STRING_WITH_LEN("SEC_TO_TIME"), BUILDER(Create_func_sec_to_time)},
+  { C_STRING_WITH_LEN("SHA"), BUILDER(Create_func_sha)},
+  { C_STRING_WITH_LEN("SHA1"), BUILDER(Create_func_sha)},
+  { C_STRING_WITH_LEN("SIGN"), BUILDER(Create_func_sign)},
+  { C_STRING_WITH_LEN("SIN"), BUILDER(Create_func_sin)},
+  { C_STRING_WITH_LEN("SLEEP"), BUILDER(Create_func_sleep)},
+  { C_STRING_WITH_LEN("SOUNDEX"), BUILDER(Create_func_soundex)},
+  { C_STRING_WITH_LEN("SPACE"), BUILDER(Create_func_space)},
+  { C_STRING_WITH_LEN("SQRT"), BUILDER(Create_func_sqrt)},
+  { C_STRING_WITH_LEN("SRID"), GEOM_BUILDER(Create_func_srid)},
+  { C_STRING_WITH_LEN("STARTPOINT"), GEOM_BUILDER(Create_func_startpoint)},
+  { C_STRING_WITH_LEN("STRCMP"), BUILDER(Create_func_strcmp)},
+  { C_STRING_WITH_LEN("STR_TO_DATE"), BUILDER(Create_func_str_to_date)},
+  { C_STRING_WITH_LEN("SUBSTRING_INDEX"), BUILDER(Create_func_substr_index)},
+  { C_STRING_WITH_LEN("SUBTIME"), BUILDER(Create_func_subtime)},
+  { C_STRING_WITH_LEN("TAN"), BUILDER(Create_func_tan)},
+  { C_STRING_WITH_LEN("TIMEDIFF"), BUILDER(Create_func_timediff)},
+  { C_STRING_WITH_LEN("TIME_FORMAT"), BUILDER(Create_func_time_format)},
+  { C_STRING_WITH_LEN("TIME_TO_SEC"), BUILDER(Create_func_time_to_sec)},
+  { C_STRING_WITH_LEN("TOUCHES"), GEOM_BUILDER(Create_func_touches)},
+  { C_STRING_WITH_LEN("TO_DAYS"), BUILDER(Create_func_to_days)},
+  { C_STRING_WITH_LEN("UCASE"), BUILDER(Create_func_ucase)},
+  { C_STRING_WITH_LEN("UNCOMPRESS"), BUILDER(Create_func_uncompress)},
+  { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH"), BUILDER(Create_func_uncompressed_length)},
+  { C_STRING_WITH_LEN("UNHEX"), BUILDER(Create_func_unhex)},
+  { C_STRING_WITH_LEN("UNIX_TIMESTAMP"), BUILDER(Create_func_unix_timestamp)},
+  { C_STRING_WITH_LEN("UPDATEXML"), BUILDER(Create_func_xml_update)},
+  { C_STRING_WITH_LEN("UPPER"), BUILDER(Create_func_ucase)},
+  { C_STRING_WITH_LEN("UUID"), BUILDER(Create_func_uuid)},
+  { C_STRING_WITH_LEN("VERSION"), BUILDER(Create_func_version)},
+  { C_STRING_WITH_LEN("WEEKDAY"), BUILDER(Create_func_weekday)},
+  { C_STRING_WITH_LEN("WEEKOFYEAR"), BUILDER(Create_func_weekofyear)},
+  { C_STRING_WITH_LEN("WITHIN"), GEOM_BUILDER(Create_func_within)},
+  { C_STRING_WITH_LEN("X"), GEOM_BUILDER(Create_func_x)},
+  { C_STRING_WITH_LEN("Y"), GEOM_BUILDER(Create_func_y)},
+  { C_STRING_WITH_LEN("YEARWEEK"), BUILDER(Create_func_year_week)},
+
+  { {0, 0}, NULL}
+};
+
+static HASH native_functions_hash;
+
+extern "C" byte*
+get_native_fct_hash_key(const byte *buff, uint *length, my_bool /* unused */)
+{
+  Native_func_registry *func= (Native_func_registry*) buff;
+  *length= func->name.length;
+  return (byte*) func->name.str;
+}
+
+/*
+  Load the hash table for native functions.
+  Note: this code is not thread safe, and is intended to be used at server
+  startup only (before going multi-threaded)
+*/
+
+int item_create_init()
+{
+  Native_func_registry *func;
+
+  DBUG_ENTER("item_create_init");
+
+  if (hash_init(& native_functions_hash,
+                system_charset_info,
+                array_elements(func_array),
+                0,
+                0,
+                (hash_get_key) get_native_fct_hash_key,
+                NULL,                          /* Nothing to free */
+                MYF(0)))
+    DBUG_RETURN(1);
+
+  for (func= func_array; func->builder != NULL; func++)
+  {
+    if (my_hash_insert(& native_functions_hash, (byte*) func))
+      DBUG_RETURN(1);
+  }
+
+#ifndef DBUG_OFF
+  for (uint i=0 ; i < native_functions_hash.records ; i++)
+  {
+    func= (Native_func_registry*) hash_element(& native_functions_hash, i);
+    DBUG_PRINT("info", ("native function %s, length %d",
+                        func->name.str, func->name.length));
+  }
+#endif
+
+  DBUG_RETURN(0);
+}
+
+/*
+  Empty the hash table for native functions.
+  Note: this code is not thread safe, and is intended to be used at server
+  shutdown only (after thread requests have been executed).
+*/
+
+void item_create_cleanup()
+{
+  DBUG_ENTER("item_create_cleanup");
+  hash_free(& native_functions_hash);
+  DBUG_VOID_RETURN;
+}
+
+Create_func *
+find_native_function_builder(THD *thd, LEX_STRING name)
+{
+  Native_func_registry *func;
+  Create_func *builder= NULL;
+
+  /* Thread safe */
+  func= (Native_func_registry*) hash_search(& native_functions_hash,
+                                            (byte*) name.str,
+                                             name.length);
+
+  if (func)
+  {
+    builder= func->builder;
+  }
+
+  return builder;
+}
+
+Create_qfunc *
+find_qualified_function_builder(THD *thd)
+{
+  return & Create_sp_func::s_singleton;
+}
+
+Item*
+create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec,
+                 CHARSET_INFO *cs)
+{
+  Item *res;
+  LINT_INIT(res);
+
+  switch (cast_type) {
+  case ITEM_CAST_BINARY:
+    res= new (thd->mem_root) Item_func_binary(a);
+    break;
+  case ITEM_CAST_SIGNED_INT:
+    res= new (thd->mem_root) Item_func_signed(a);
+    break;
+  case ITEM_CAST_UNSIGNED_INT:
+    res= new (thd->mem_root) Item_func_unsigned(a);
+    break;
+  case ITEM_CAST_DATE:
+    res= new (thd->mem_root) Item_date_typecast(a);
+    break;
+  case ITEM_CAST_TIME:
+    res= new (thd->mem_root) Item_time_typecast(a);
+    break;
+  case ITEM_CAST_DATETIME:
+    res= new (thd->mem_root) Item_datetime_typecast(a);
+    break;
+  case ITEM_CAST_DECIMAL:
+  {
+    int tmp_len= (len>0) ? len : 10;
+    if (tmp_len < dec)
+    {
+      my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
+      return 0;
+    }
+    res= new (thd->mem_root) Item_decimal_typecast(a, tmp_len, dec);
+    break;
+  }
+  case ITEM_CAST_CHAR:
+  {
+    CHARSET_INFO *real_cs= (cs ? cs : thd->variables.collation_connection);
+    res= new (thd->mem_root) Item_char_typecast(a, len, real_cs);
+    break;
+  }
+  default:
+  {
+    DBUG_ASSERT(0);
+    res= 0;
+    break;
+  }
+  }
+  return res;
+}
+
diff --git a/sql/item_create.h b/sql/item_create.h
index 9b6a74b5bdd..c20e36af04f 100644
--- a/sql/item_create.h
+++ b/sql/item_create.h
@@ -14,148 +14,154 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Functions to create an item. Used by lex.h */
-
-Item *create_func_abs(Item* a);
-Item *create_func_acos(Item* a);
-Item *create_func_aes_encrypt(Item* a, Item* b);
-Item *create_func_aes_decrypt(Item* a, Item* b);
-Item *create_func_ascii(Item* a);
-Item *create_func_asin(Item* a);
-Item *create_func_bin(Item* a);
-Item *create_func_bit_count(Item* a);
-Item *create_func_bit_length(Item* a);
-Item *create_func_coercibility(Item* a);
-Item *create_func_ceiling(Item* a);
-Item *create_func_char_length(Item* a);
-Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec,
-                       CHARSET_INFO *cs);
-Item *create_func_connection_id(void);
-Item *create_func_conv(Item* a, Item *b, Item *c);
-Item *create_func_cos(Item* a);
-Item *create_func_cot(Item* a);
-Item *create_func_crc32(Item* a);
-Item *create_func_date_format(Item* a,Item *b);
-Item *create_func_dayname(Item* a);
-Item *create_func_dayofmonth(Item* a);
-Item *create_func_dayofweek(Item* a);
-Item *create_func_dayofyear(Item* a);
-Item *create_func_degrees(Item *);
-Item *create_func_exp(Item* a);
-Item *create_func_find_in_set(Item* a, Item *b);
-Item *create_func_floor(Item* a);
-Item *create_func_found_rows(void);
-Item *create_func_from_days(Item* a);
-Item *create_func_get_lock(Item* a, Item *b);
-Item *create_func_hex(Item *a);
-Item *create_func_inet_aton(Item* a);
-Item *create_func_inet_ntoa(Item* a);
-
-Item *create_func_ifnull(Item* a, Item *b);
-Item *create_func_instr(Item* a, Item *b);
-Item *create_func_isnull(Item* a);
-Item *create_func_lcase(Item* a);
-Item *create_func_length(Item* a);
-Item *create_func_ln(Item* a);
-Item *create_func_locate(Item* a, Item *b);
-Item *create_func_log2(Item* a);
-Item *create_func_log10(Item* a);
-Item *create_func_lpad(Item* a, Item *b, Item *c);
-Item *create_func_ltrim(Item* a);
-Item *create_func_md5(Item* a);
-Item *create_func_mod(Item* a, Item *b);
-Item *create_func_monthname(Item* a);
-Item *create_func_name_const(Item *a, Item *b);
-Item *create_func_nullif(Item* a, Item *b);
-Item *create_func_oct(Item *);
-Item *create_func_ord(Item* a);
-Item *create_func_period_add(Item* a, Item *b);
-Item *create_func_period_diff(Item* a, Item *b);
-Item *create_func_pi(void);
-Item *create_func_pow(Item* a, Item *b);
-Item *create_func_radians(Item *a);
-Item *create_func_release_lock(Item* a);
-Item *create_func_repeat(Item* a, Item *b);
-Item *create_func_reverse(Item* a);
-Item *create_func_rpad(Item* a, Item *b, Item *c);
-Item *create_func_rtrim(Item* a);
-Item *create_func_sec_to_time(Item* a);
-Item *create_func_sign(Item* a);
-Item *create_func_sin(Item* a);
-Item *create_func_sha(Item* a);
-Item *create_func_sleep(Item* a);
-Item *create_func_soundex(Item* a);
-Item *create_func_space(Item *);
-Item *create_func_sqrt(Item* a);
-Item *create_func_strcmp(Item* a, Item *b);
-Item *create_func_tan(Item* a);
-Item *create_func_time_format(Item *a, Item *b);
-Item *create_func_time_to_sec(Item* a);
-Item *create_func_to_days(Item* a);
-Item *create_func_ucase(Item* a);
-Item *create_func_unhex(Item* a);
-Item *create_func_uuid(void);
-Item *create_func_version(void);
-Item *create_func_weekday(Item* a);
-Item *create_load_file(Item* a);
-Item *create_func_is_free_lock(Item* a);
-Item *create_func_is_used_lock(Item* a);
-Item *create_func_quote(Item* a);
-Item *create_func_xml_extractvalue(Item *a, Item *b);
-Item *create_func_xml_update(Item *a, Item *b, Item *c);
-#ifdef HAVE_SPATIAL
-
-Item *create_func_geometry_from_text(Item *a);
-Item *create_func_as_wkt(Item *a);
-Item *create_func_as_wkb(Item *a);
-Item *create_func_srid(Item *a);
-Item *create_func_startpoint(Item *a);
-Item *create_func_endpoint(Item *a);
-Item *create_func_exteriorring(Item *a);
-Item *create_func_centroid(Item *a);
-Item *create_func_envelope(Item *a);
-Item *create_func_pointn(Item *a, Item *b);
-Item *create_func_interiorringn(Item *a, Item *b);
-Item *create_func_geometryn(Item *a, Item *b);
-
-Item *create_func_equals(Item *a, Item *b);
-Item *create_func_disjoint(Item *a, Item *b);
-Item *create_func_intersects(Item *a, Item *b);
-Item *create_func_touches(Item *a, Item *b);
-Item *create_func_crosses(Item *a, Item *b);
-Item *create_func_within(Item *a, Item *b);
-Item *create_func_contains(Item *a, Item *b);
-Item *create_func_overlaps(Item *a, Item *b);
-
-Item *create_func_isempty(Item *a);
-Item *create_func_issimple(Item *a);
-Item *create_func_isclosed(Item *a);
-
-Item *create_func_geometry_type(Item *a);
-Item *create_func_dimension(Item *a);
-Item *create_func_x(Item *a);
-Item *create_func_y(Item *a);
-Item *create_func_area(Item *a);
-Item *create_func_glength(Item *a);
-
-Item *create_func_numpoints(Item *a);
-Item *create_func_numinteriorring(Item *a);
-Item *create_func_numgeometries(Item *a);
-
-Item *create_func_point(Item *a, Item *b);
-
-#endif /*HAVE_SPATIAL*/
-
-Item *create_func_compress(Item *a);
-Item *create_func_uncompress(Item *a);
-Item *create_func_uncompressed_length(Item *a);
-
-Item *create_func_datediff(Item *a, Item *b);
-Item *create_func_weekofyear(Item *a);
-Item *create_func_makedate(Item* a,Item* b);
-Item *create_func_addtime(Item* a,Item* b);
-Item *create_func_subtime(Item* a,Item* b);
-Item *create_func_timediff(Item* a,Item* b);
-Item *create_func_maketime(Item* a,Item* b,Item* c);
-Item *create_func_str_to_date(Item* a,Item* b);
-Item *create_func_last_day(Item *a);
+/* Functions to create an item. Used by sql/sql_yacc.yy */
+
+#ifndef ITEM_CREATE_H
+#define ITEM_CREATE_H
+
+/**
+  Public function builder interface.
+  The parser (sql/sql_yacc.yy) uses a factory / builder pattern to
+  construct an <code>Item</code> object for each function call.
+  All the concrete function builders implements this interface,
+  either directly or indirectly with some adapter helpers.
+  Keeping the function creation separated from the bison grammar allows
+  to simplify the parser, and avoid the need to introduce a new token
+  for each function, which has undesirable side effects in the grammar.
+*/
+
+class Create_func
+{
+public:
+  /**
+    The builder create method.
+    Given the function name and list or arguments, this method creates
+    an <code>Item</code> that represents the function call.
+    In case or errors, a NULL item is returned, and an error is reported.
+    Note that the <code>thd</code> object may be modified by the builder.
+    In particular, the following members/methods can be set/called,
+    depending on the function called and the function possible side effects.
+    <ul>
+      <li><code>thd->lex->binlog_row_based_if_mixed</code></li>
+      <li><code>thd->lex->current_context()</code></li>
+      <li><code>thd->lex->safe_to_cache_query</code></li>
+      <li><code>thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT)</code></li>
+      <li><code>thd->lex->uncacheable(UNCACHEABLE_RAND)</code></li>
+      <li><code>thd->lex->add_time_zone_tables_to_query_tables(thd)</code></li>
+    </ul>
+    @param thd The current thread
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call, or NULL
+  */
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list) = 0;
+
+protected:
+  /** Constructor */
+  Create_func() {}
+  /** Destructor */
+  virtual ~Create_func() {}
+};
+
+
+/**
+  Function builder for qualified functions.
+  This builder is used with functions call using a qualified function name
+  syntax, as in <code>db.func(expr, expr, ...)</code>.
+*/
+
+class Create_qfunc : public Create_func
+{
+public:
+  /**
+    The builder create method, for unqualified functions.
+    This builder will use the current database for the database name.
+    @param thd The current thread
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    The builder create method, for qualified functions.
+    @param thd The current thread
+    @param db The database name
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list) = 0;
+
+protected:
+  /** Constructor. */
+  Create_qfunc() {}
+  /** Destructor. */
+  virtual ~Create_qfunc() {}
+};
+
+
+/**
+  Find the native function builder associated with a given function name.
+  @param thd The current thread
+  @param name The native function name
+  @return The native function builder associated with the name, or NULL
+*/
+extern Create_func * find_native_function_builder(THD *thd, LEX_STRING name);
+
+
+/**
+  Find the function builder for qualified functions.
+  @param thd The current thread
+  @return A function builder for qualified functions
+*/
+extern Create_qfunc * find_qualified_function_builder(THD *thd);
+
+
+#ifdef HAVE_DLOPEN
+/**
+  Function builder for User Defined Functions.
+*/
+
+class Create_udf_func : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    The builder create method, for User Defined Functions.
+    @param thd The current thread
+    @param fct The User Defined Function metadata
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  Item* create(THD *thd, udf_func *fct, List<Item> *item_list);
+
+  /** Singleton. */
+  static Create_udf_func s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_udf_func() {}
+  /** Destructor. */
+  virtual ~Create_udf_func() {}
+};
+#endif
+
+
+/**
+  Builder for cast expressions.
+  @param thd The current thread
+  @param a The item to cast
+  @param cast_type the type casted into
+  @param len TODO
+  @param dec TODO
+  @param cs The character set
+*/
+Item*
+create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec,
+                 CHARSET_INFO *cs);
+
+#endif
+
diff --git a/sql/item_geofunc.h b/sql/item_geofunc.h
index 4848f59301d..42f11820869 100644
--- a/sql/item_geofunc.h
+++ b/sql/item_geofunc.h
@@ -348,11 +348,11 @@ public:
   void fix_length_and_dec() { max_length= 10; }
 };
 
-#define GEOM_NEW(obj_constructor) new obj_constructor
+#define GEOM_NEW(thd, obj_constructor) new (thd->mem_root) obj_constructor
 
 #else /*HAVE_SPATIAL*/
 
-#define GEOM_NEW(obj_constructor) NULL
+#define GEOM_NEW(thd, obj_constructor) NULL
 
 #endif
 
diff --git a/sql/lex.h b/sql/lex.h
index f19c9413e0e..97b097148aa 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -30,16 +30,7 @@ SYM_GROUP sym_group_rtree= {"RTree keys", "HAVE_RTREE_KEYS"};
 #define SYM_OR_NULL(A) A
 #endif
 
-#define SYM(A) SYM_OR_NULL(A),0,0,&sym_group_common
-#define F_SYM(A) SYM_OR_NULL(A)
-
-#define CREATE_FUNC(A) (void *)(SYM_OR_NULL(A)), &sym_group_common
-
-#ifdef HAVE_SPATIAL
-#define CREATE_FUNC_GEOM(A) (void *)(SYM_OR_NULL(A)), &sym_group_geom
-#else
-#define CREATE_FUNC_GEOM(A) 0, &sym_group_geom
-#endif
+#define SYM(A) SYM_OR_NULL(A),0,&sym_group_common
 
 /*
   Symbols are broken into separated arrays to allow field names with
@@ -588,235 +579,38 @@ static SYMBOL symbols[] = {
 
 
 static SYMBOL sql_functions[] = {
-  { "ABS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_abs)},
-  { "ACOS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_acos)},
   { "ADDDATE",		SYM(ADDDATE_SYM)},
-  { "ADDTIME",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_addtime)},
-  { "AES_ENCRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_encrypt)},
-  { "AES_DECRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_decrypt)},
-  { "AREA",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_area)},
-  { "ASIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_asin)},
-  { "ASBINARY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
-  { "ASTEXT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
-  { "ASWKB",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
-  { "ASWKT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
-  { "ATAN",		SYM(ATAN)},
-  { "ATAN2",		SYM(ATAN)},
-  { "BENCHMARK",	SYM(BENCHMARK_SYM)},
-  { "BIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bin)},
-  { "BIT_COUNT",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_count)},
-  { "BIT_OR",		SYM(BIT_OR)},
   { "BIT_AND",		SYM(BIT_AND)},
+  { "BIT_OR",		SYM(BIT_OR)},
   { "BIT_XOR",		SYM(BIT_XOR)},
   { "CAST",		SYM(CAST_SYM)},
-  { "CEIL",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "CEILING",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "BIT_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_length)},
-  { "CENTROID",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_centroid)},
-  { "CHAR_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "CHARACTER_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "COERCIBILITY",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_coercibility)},
-  { "COMPRESS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_compress)},
-  { "CONCAT",		SYM(CONCAT)},
-  { "CONCAT_WS",	SYM(CONCAT_WS)},
-  { "CONNECTION_ID",	F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_connection_id)},
-  { "CONV",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_conv)},
-  { "CONVERT_TZ",	SYM(CONVERT_TZ_SYM)},
   { "COUNT",		SYM(COUNT_SYM)},
-  { "COS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cos)},
-  { "COT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cot)},
-  { "CRC32",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_crc32)},
-  { "CROSSES",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_crosses)},
   { "CURDATE",		SYM(CURDATE)},
   { "CURTIME",		SYM(CURTIME)},
   { "DATE_ADD",		SYM(DATE_ADD_INTERVAL)},
-  { "DATEDIFF",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_datediff)},
-  { "DATE_FORMAT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_date_format)},
   { "DATE_SUB",		SYM(DATE_SUB_INTERVAL)},
-  { "DAYNAME",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayname)},
-  { "DAYOFMONTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofmonth)},
-  { "DAYOFWEEK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofweek)},
-  { "DAYOFYEAR",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofyear)},
-  { "DECODE",		SYM(DECODE_SYM)},
-  { "DEGREES",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_degrees)},
-  { "DES_ENCRYPT",	SYM(DES_ENCRYPT_SYM)},
-  { "DES_DECRYPT",	SYM(DES_DECRYPT_SYM)},
-  { "DIMENSION",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_dimension)},
-  { "DISJOINT",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
-  { "ELT",		SYM(ELT_FUNC)},
-  { "ENCODE",		SYM(ENCODE_SYM)},
-  { "ENCRYPT",		SYM(ENCRYPT)},
-  { "ENDPOINT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_endpoint)},
-  { "ENVELOPE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_envelope)},
-  { "EQUALS",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
-  { "EXTERIORRING",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_exteriorring)},
   { "EXTRACT",		SYM(EXTRACT_SYM)},
-  { "EXTRACTVALUE",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_xml_extractvalue)},
-  { "EXP",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_exp)},
-  { "EXPORT_SET",	SYM(EXPORT_SET)},
-  { "FIELD",		SYM(FIELD_FUNC)},	/* For compability */
-  { "FIND_IN_SET",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_find_in_set)},
-  { "FLOOR",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_floor)},
-  { "FORMAT",		SYM(FORMAT_SYM)},
-  { "FOUND_ROWS",	F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_found_rows)},
-  { "FROM_DAYS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_from_days)},
-  { "FROM_UNIXTIME",	SYM(FROM_UNIXTIME)},
-  { "GET_LOCK",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_get_lock)},
-  { "GEOMETRYN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_geometryn)},
-  { "GEOMETRYTYPE",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_geometry_type)},
-  { "GEOMCOLLFROMTEXT",	SYM(GEOMCOLLFROMTEXT)},
-  { "GEOMCOLLFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GEOMETRYCOLLECTIONFROMTEXT",SYM(GEOMCOLLFROMTEXT)},
-  { "GEOMETRYCOLLECTIONFROMWKB",SYM(GEOMFROMWKB)},
-  { "GEOMETRYFROMTEXT", SYM(GEOMFROMTEXT)},
-  { "GEOMETRYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GEOMFROMTEXT",	SYM(GEOMFROMTEXT)},
-  { "GEOMFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GLENGTH",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_glength)},
-  { "GREATEST",		SYM(GREATEST_SYM)},
   { "GROUP_CONCAT",	SYM(GROUP_CONCAT_SYM)},
   { "GROUP_UNIQUE_USERS",	SYM(GROUP_UNIQUE_USERS)},
-  { "HEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_hex)},
-  { "IFNULL",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_ifnull)},
-  { "INET_ATON",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_aton)},
-  { "INET_NTOA",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_ntoa)},
-  { "INSTR",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_instr)},
-  { "INTERIORRINGN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_interiorringn)},
-  { "INTERSECTS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
-  { "ISCLOSED",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isclosed)},
-  { "ISEMPTY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isempty)},
-  { "ISNULL",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isnull)},
-  { "IS_FREE_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_free_lock)},
-  { "IS_USED_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_used_lock)},
-  { "LAST_INSERT_ID",	SYM(LAST_INSERT_ID)},
-  { "ISSIMPLE",         F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_issimple)},
-  { "LAST_DAY",         F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_last_day)},
-  { "LCASE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LEAST",		SYM(LEAST_SYM)},
-  { "LENGTH",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "LN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ln)},
-  { "LINEFROMTEXT",	SYM(LINEFROMTEXT)},
-  { "LINEFROMWKB",	SYM(GEOMFROMWKB)},
-  { "LINESTRINGFROMTEXT",SYM(LINEFROMTEXT)},
-  { "LINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
-  { "LOAD_FILE",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_load_file)},
-  { "LOCATE",		SYM(LOCATE)},
-  { "LOG",		SYM(LOG_SYM)},
-  { "LOG2",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log2)},
-  { "LOG10",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log10)},
-  { "LOWER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LPAD",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_lpad)},
-  { "LTRIM",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ltrim)},
-  { "MAKE_SET",		SYM(MAKE_SET_SYM)},
-  { "MAKEDATE",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_makedate)},
-  { "MAKETIME",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_maketime)},
-  { "MASTER_POS_WAIT",	SYM(MASTER_POS_WAIT)},
   { "MAX",		SYM(MAX_SYM)},
-  { "MBRCONTAINS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_contains)},
-  { "MBRDISJOINT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
-  { "MBREQUAL",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
-  { "MBRINTERSECTS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
-  { "MBROVERLAPS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
-  { "MBRTOUCHES",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
-  { "MBRWITHIN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
-  { "MD5",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_md5)},
   { "MID",		SYM(SUBSTRING)},	/* unireg function */
   { "MIN",		SYM(MIN_SYM)},
-  { "MLINEFROMTEXT",	SYM(MLINEFROMTEXT)},
-  { "MLINEFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MPOINTFROMTEXT",	SYM(MPOINTFROMTEXT)},
-  { "MPOINTFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MPOLYFROMTEXT",	SYM(MPOLYFROMTEXT)},
-  { "MPOLYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MONTHNAME",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_monthname)},
-  { "MULTILINESTRINGFROMTEXT",SYM(MLINEFROMTEXT)},
-  { "MULTILINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
-  { "MULTIPOINTFROMTEXT",SYM(MPOINTFROMTEXT)},
-  { "MULTIPOINTFROMWKB",SYM(GEOMFROMWKB)},
-  { "MULTIPOLYGONFROMTEXT",SYM(MPOLYFROMTEXT)},
-  { "MULTIPOLYGONFROMWKB",SYM(GEOMFROMWKB)},
-  { "NAME_CONST",       F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_name_const)},
   { "NOW",		SYM(NOW_SYM)},
-  { "NULLIF",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_nullif)},
-  { "NUMGEOMETRIES",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numgeometries)},
-  { "NUMINTERIORRINGS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numinteriorring)},
-  { "NUMPOINTS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numpoints)},
-  { "OCTET_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "OCT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_oct)},
-  { "ORD",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ord)},
-  { "OVERLAPS",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
-  { "PERIOD_ADD",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_add)},
-  { "PERIOD_DIFF",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_diff)},
-  { "PI",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_pi)},
-  { "POINTFROMTEXT",	SYM(POINTFROMTEXT)},
-  { "POINTFROMWKB",	SYM(GEOMFROMWKB)},
-  { "POINTN",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_pointn)},
-  { "POLYFROMTEXT",	SYM(POLYFROMTEXT)},
-  { "POLYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "POLYGONFROMTEXT",	SYM(POLYFROMTEXT)},
-  { "POLYGONFROMWKB",	SYM(GEOMFROMWKB)},
   { "POSITION",		SYM(POSITION_SYM)},
-  { "POW",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "POWER",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "QUOTE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quote)},
-  { "RADIANS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_radians)},
-  { "RAND",		SYM(RAND)},
-  { "RELEASE_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_release_lock)},
-  { "REVERSE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_reverse)},
-  { "ROUND",		SYM(ROUND)},
-  { "ROW_COUNT",	SYM(ROW_COUNT_SYM)},
-  { "RPAD",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_rpad)},
-  { "RTRIM",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_rtrim)},
-  { "SEC_TO_TIME",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sec_to_time)},
-  { "SESSION_USER",	SYM(USER)},
-  { "SUBDATE",		SYM(SUBDATE_SYM)},
-  { "SIGN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sign)},
-  { "SIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sin)},
-  { "SHA",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SHA1",             F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SLEEP",            F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sleep)},
-  { "SOUNDEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_soundex)},
-  { "SPACE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_space)},
-  { "SQRT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sqrt)},
-  { "SRID",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_srid)},
-  { "STARTPOINT",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_startpoint)},
+  { "SESSION_USER",     SYM(USER)},
   { "STD",		SYM(STD_SYM)},
   { "STDDEV",		SYM(STD_SYM)},
   { "STDDEV_POP",	SYM(STD_SYM)},
   { "STDDEV_SAMP",	SYM(STDDEV_SAMP_SYM)},
-  { "STR_TO_DATE",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_str_to_date)},
-  { "STRCMP",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_strcmp)},
+  { "SUBDATE",		SYM(SUBDATE_SYM)},
   { "SUBSTR",		SYM(SUBSTRING)},
   { "SUBSTRING",	SYM(SUBSTRING)},
-  { "SUBSTRING_INDEX",	SYM(SUBSTRING_INDEX)},
-  { "SUBTIME",          F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_subtime)},
   { "SUM",		SYM(SUM_SYM)},
   { "SYSDATE",		SYM(SYSDATE)},
-  { "SYSTEM_USER",	SYM(USER)},
-  { "TAN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_tan)},
-  { "TIME_FORMAT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_time_format)},
-  { "TIME_TO_SEC",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_time_to_sec)},
-  { "TIMEDIFF",         F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_timediff)},
-  { "TO_DAYS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_to_days)},
-  { "TOUCHES",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
+  { "SYSTEM_USER",      SYM(USER)},
   { "TRIM",		SYM(TRIM)},
-  { "UCASE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "UNCOMPRESS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompress)},
-  { "UNCOMPRESSED_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompressed_length)},
-  { "UNHEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_unhex)},
   { "UNIQUE_USERS",	SYM(UNIQUE_USERS)},
-  { "UNIX_TIMESTAMP",	SYM(UNIX_TIMESTAMP)},
-  { "UPDATEXML",	F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_xml_update)},
-  { "UPPER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "UUID",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_uuid)},
   { "VARIANCE",		SYM(VARIANCE_SYM)},
   { "VAR_POP",		SYM(VARIANCE_SYM)},
   { "VAR_SAMP",		SYM(VAR_SAMP_SYM)},
-  { "VERSION",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)},
-  { "WEEKDAY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekday)},
-  { "WEEKOFYEAR",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekofyear)},
-  { "WITHIN",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
-  { "X",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_x)},
-  { "Y",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_y)},
-  { "YEARWEEK",		SYM(YEARWEEK)}
 };
diff --git a/sql/lex_symbol.h b/sql/lex_symbol.h
index 3074a489b6a..5ba785d16f3 100644
--- a/sql/lex_symbol.h
+++ b/sql/lex_symbol.h
@@ -26,7 +26,6 @@ typedef struct st_symbol {
   const char *name;
   uint	tok;
   uint length;
-  void *create_func;
   struct st_sym_group *group;
 } SYMBOL;
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 6ddec155edb..ba69a574b55 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -2011,6 +2011,10 @@ inline void kill_delayed_threads(void) {}
 /* Used by handlers to store things in schema tables */
 bool schema_table_store_record(THD *thd, TABLE *table);
 
+/* sql/item_create.cc */
+int item_create_init();
+void item_create_cleanup();
+
 #endif /* MYSQL_SERVER */
 #endif /* MYSQL_CLIENT */
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 6674dd87757..745c837c01b 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1184,6 +1184,7 @@ void clean_up(bool print_message)
   hostname_cache_free();
   item_user_lock_free();
   lex_free();				/* Free some memory */
+  item_create_cleanup();
   set_var_free();
   free_charsets();
   (void) ha_panic(HA_PANIC_CLOSE);	/* close all tables and logs */
@@ -2693,6 +2694,8 @@ static int init_common_variables(const char *conf_file_name, int argc,
     return 1;
   init_client_errs();
   lex_init();
+  if (item_create_init())
+    return 1;
   item_init();
   set_var_init();
   mysys_uses_curses=0;
diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt
index 3b64684b5da..3022967eeeb 100644
--- a/sql/share/errmsg.txt
+++ b/sql/share/errmsg.txt
@@ -6006,4 +6006,8 @@ ER_NON_INSERTABLE_TABLE
         eng "The target table %-.100s of the %s is not insertable-into"
 ER_CANT_RENAME_LOG_TABLE
         eng "Cannot rename '%s'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to '%s'"
+ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT 42000
+        eng "Incorrect parameter count in the call to native function '%-.64s'"
+ER_WRONG_PARAMETERS_TO_NATIVE_FCT 42000
+        eng "Incorrect parameters in the call to native function '%-.64s'"
 
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index a6ae102fa0c..8062381e813 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -56,12 +56,17 @@ const LEX_STRING null_lex_str={0,0};
   }
 
 /* Helper for parsing "IS [NOT] truth_value" */
-inline Item *is_truth_value(Item *A, bool v1, bool v2)
+inline Item *is_truth_value(THD *thd, Item *A, bool v1, bool v2)
 {
-  return new Item_func_if(create_func_ifnull(A,
-	new Item_int((char *) (v2 ? "TRUE" : "FALSE"), v2, 1)),
-	new Item_int((char *) (v1 ? "TRUE" : "FALSE"), v1, 1),
-	new Item_int((char *) (v1 ? "FALSE" : "TRUE"),!v1, 1));
+  Item *v1_t= new (thd->mem_root) Item_int((char *) (v1 ? "TRUE" : "FALSE"),
+                                           v1, 1);
+  Item *v1_f= new (thd->mem_root) Item_int((char *) (v1 ? "FALSE" : "TRUE"),
+                                           !v1, 1);
+  Item *v2_t= new (thd->mem_root) Item_int((char *) (v2 ? "TRUE" : "FALSE"),
+                                           v2, 1);
+  Item *ifnull= new (thd->mem_root) Item_func_ifnull(A, v2_t);
+
+  return new (thd->mem_root) Item_func_if(ifnull, v1_t, v1_f);
 }
 
 #ifndef DBUG_OFF
@@ -142,213 +147,209 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %pure_parser					/* We have threads */
 
-%token  END_OF_INPUT
+/*
+   Comments for TOKENS.
+   For each token, please include in the same line a comment that contains
+   the following tags:
+   SQL-2003-R : Reserved keyword as per SQL-2003
+   SQL-2003-N : Non Reserved keyword as per SQL-2003
+   SQL-1999-R : Reserved keyword as per SQL-1999
+   SQL-1999-N : Non Reserved keyword as per SQL-1999
+   MYSQL      : MySQL extention (unspecified)
+   MYSQL-FUNC : MySQL extention, function
+   INTERNAL   : Not a real token, lex optimization
+   OPERATOR   : SQL operator
+   FUTURE-USE : Reserved for futur use
+
+   This makes the code grep-able, and helps maintenance.
+*/
 
-%token  ABORT_SYM
+%token  ABORT_SYM                     /* INTERNAL (used in lex) */
 %token  ACCESSIBLE_SYM
-%token  ACTION
-%token  ADD
-%token  ADDDATE_SYM
-%token  AFTER_SYM
+%token  ACTION                        /* SQL-2003-N */
+%token  ADD                           /* SQL-2003-R */
+%token  ADDDATE_SYM                   /* MYSQL-FUNC */
+%token  AFTER_SYM                     /* SQL-2003-N */
 %token  AGAINST
 %token  AGGREGATE_SYM
 %token  ALGORITHM_SYM
-%token  ALL
-%token  ALTER
+%token  ALL                           /* SQL-2003-R */
+%token  ALTER                         /* SQL-2003-R */
 %token  ANALYZE_SYM
-%token  AND_AND_SYM
-%token  AND_SYM
-%token  ANY_SYM
-%token  AS
-%token  ASC
-%token  ASCII_SYM
-%token  ASENSITIVE_SYM
-%token  AT_SYM
-%token  ATAN
+%token  AND_AND_SYM                   /* OPERATOR */
+%token  AND_SYM                       /* SQL-2003-R */
+%token  ANY_SYM                       /* SQL-2003-R */
+%token  AS                            /* SQL-2003-R */
+%token  ASC                           /* SQL-2003-N */
+%token  ASCII_SYM                     /* MYSQL-FUNC */
+%token  ASENSITIVE_SYM                /* FUTURE-USE */
+%token  AT_SYM                        /* SQL-2003-R */
 %token  AUTHORS_SYM
-%token  AUTO_INC
 %token  AUTOEXTEND_SIZE_SYM
+%token  AUTO_INC
 %token  AVG_ROW_LENGTH
-%token  AVG_SYM
+%token  AVG_SYM                       /* SQL-2003-N */
 %token  BACKUP_SYM
-%token  BEFORE_SYM
-%token  BEGIN_SYM
-%token  BENCHMARK_SYM
-%token  BIGINT
-%token  BINARY
+%token  BEFORE_SYM                    /* SQL-2003-N */
+%token  BEGIN_SYM                     /* SQL-2003-R */
+%token  BETWEEN_SYM                   /* SQL-2003-R */
+%token  BIGINT                        /* SQL-2003-R */
+%token  BINARY                        /* SQL-2003-R */
 %token  BINLOG_SYM
 %token  BIN_NUM
-%token  BIT_AND
-%token  BIT_OR
-%token  BIT_SYM
-%token  BIT_XOR
-%token  BLOB_SYM
-%token  BOOLEAN_SYM
+%token  BIT_AND                       /* MYSQL-FUNC */
+%token  BIT_OR                        /* MYSQL-FUNC */
+%token  BIT_SYM                       /* MYSQL-FUNC */
+%token  BIT_XOR                       /* MYSQL-FUNC */
+%token  BLOB_SYM                      /* SQL-2003-R */
+%token  BOOLEAN_SYM                   /* SQL-2003-R */
 %token  BOOL_SYM
-%token  BOTH
+%token  BOTH                          /* SQL-2003-R */
 %token  BTREE_SYM
-%token  BY
+%token  BY                            /* SQL-2003-R */
 %token  BYTE_SYM
 %token  CACHE_SYM
-%token  CALL_SYM
-%token  CASCADE
-%token  CASCADED
-%token  CAST_SYM
-%token  CHAIN_SYM
+%token  CALL_SYM                      /* SQL-2003-R */
+%token  CASCADE                       /* SQL-2003-N */
+%token  CASCADED                      /* SQL-2003-R */
+%token  CASE_SYM                      /* SQL-2003-R */
+%token  CAST_SYM                      /* SQL-2003-R */
+%token  CHAIN_SYM                     /* SQL-2003-N */
 %token  CHANGE
 %token  CHANGED
 %token  CHARSET
-%token  CHAR_SYM
+%token  CHAR_SYM                      /* SQL-2003-R */
 %token  CHECKSUM_SYM
-%token  CHECK_SYM
+%token  CHECK_SYM                     /* SQL-2003-R */
 %token  CIPHER_SYM
 %token  CLIENT_SYM
-%token  CLOSE_SYM
-%token  COALESCE
+%token  CLOSE_SYM                     /* SQL-2003-R */
+%token  COALESCE                      /* SQL-2003-N */
 %token  CODE_SYM
-%token  COLLATE_SYM
-%token  COLLATION_SYM
+%token  COLLATE_SYM                   /* SQL-2003-R */
+%token  COLLATION_SYM                 /* SQL-2003-N */
 %token  COLUMNS
-%token  COLUMN_SYM
+%token  COLUMN_SYM                    /* SQL-2003-R */
 %token  COMMENT_SYM
-%token  COMMITTED_SYM
-%token  COMMIT_SYM
+%token  COMMITTED_SYM                 /* SQL-2003-N */
+%token  COMMIT_SYM                    /* SQL-2003-R */
 %token  COMPACT_SYM
 %token  COMPLETION_SYM
 %token  COMPRESSED_SYM
-%token  CONCAT
-%token  CONCAT_WS
 %token  CONCURRENT
-%token  CONDITION_SYM
+%token  CONDITION_SYM                 /* SQL-2003-N */
 %token  CONNECTION_SYM
 %token  CONSISTENT_SYM
-%token  CONSTRAINT
-%token  CONTAINS_SYM
-%token  CONTINUE_SYM
+%token  CONSTRAINT                    /* SQL-2003-R */
+%token  CONTAINS_SYM                  /* SQL-2003-N */
+%token  CONTINUE_SYM                  /* SQL-2003-R */
 %token  CONTRIBUTORS_SYM
-%token  CONVERT_SYM
-%token  CONVERT_TZ_SYM
-%token  COUNT_SYM
-%token  CREATE
-%token  CROSS
-%token  CUBE_SYM
-%token  CURDATE
-%token  CURRENT_USER
-%token  CURSOR_SYM
-%token  CURTIME
+%token  CONVERT_SYM                   /* SQL-2003-N */
+%token  COUNT_SYM                     /* SQL-2003-N */
+%token  CREATE                        /* SQL-2003-R */
+%token  CROSS                         /* SQL-2003-R */
+%token  CUBE_SYM                      /* SQL-2003-R */
+%token  CURDATE                       /* MYSQL-FUNC */
+%token  CURRENT_USER                  /* SQL-2003-R */
+%token  CURSOR_SYM                    /* SQL-2003-R */
+%token  CURTIME                       /* MYSQL-FUNC */
 %token  DATABASE
 %token  DATABASES
 %token  DATAFILE_SYM
-%token  DATA_SYM
+%token  DATA_SYM                      /* SQL-2003-N */
 %token  DATETIME
-%token  DATE_ADD_INTERVAL
-%token  DATE_SUB_INTERVAL
-%token  DATE_SYM
+%token  DATE_ADD_INTERVAL             /* MYSQL-FUNC */
+%token  DATE_SUB_INTERVAL             /* MYSQL-FUNC */
+%token  DATE_SYM                      /* SQL-2003-R */
 %token  DAY_HOUR_SYM
 %token  DAY_MICROSECOND_SYM
 %token  DAY_MINUTE_SYM
 %token  DAY_SECOND_SYM
-%token  DAY_SYM
-%token  DEALLOCATE_SYM
+%token  DAY_SYM                       /* SQL-2003-R */
+%token  DEALLOCATE_SYM                /* SQL-2003-R */
 %token  DECIMAL_NUM
-%token  DECIMAL_SYM
-%token  DECLARE_SYM
-%token  DECODE_SYM
-%token  DEFAULT
+%token  DECIMAL_SYM                   /* SQL-2003-R */
+%token  DECLARE_SYM                   /* SQL-2003-R */
+%token  DEFAULT                       /* SQL-2003-R */
 %token  DEFINER_SYM
 %token  DELAYED_SYM
 %token  DELAY_KEY_WRITE_SYM
-%token  DELETE_SYM
-%token  DESC
-%token  DESCRIBE
-%token  DES_DECRYPT_SYM
-%token  DES_ENCRYPT_SYM
+%token  DELETE_SYM                    /* SQL-2003-R */
+%token  DESC                          /* SQL-2003-N */
+%token  DESCRIBE                      /* SQL-2003-R */
 %token  DES_KEY_FILE
-%token  DETERMINISTIC_SYM
+%token  DETERMINISTIC_SYM             /* SQL-2003-R */
 %token  DIRECTORY_SYM
 %token  DISABLE_SYM
 %token  DISCARD
 %token  DISK_SYM
-%token  DISTINCT
+%token  DISTINCT                      /* SQL-2003-R */
 %token  DIV_SYM
-%token  DOUBLE_SYM
+%token  DOUBLE_SYM                    /* SQL-2003-R */
 %token  DO_SYM
-%token  DROP
+%token  DROP                          /* SQL-2003-R */
 %token  DUAL_SYM
 %token  DUMPFILE
 %token  DUPLICATE_SYM
-%token  DYNAMIC_SYM
-%token  EACH_SYM
+%token  DYNAMIC_SYM                   /* SQL-2003-R */
+%token  EACH_SYM                      /* SQL-2003-R */
+%token  ELSE                          /* SQL-2003-R */
 %token  ELSEIF_SYM
-%token  ELT_FUNC
 %token  ENABLE_SYM
 %token  ENCLOSED
-%token  ENCODE_SYM
-%token  ENCRYPT
-%token  END
+%token  END                           /* SQL-2003-R */
 %token  ENDS_SYM
+%token  END_OF_INPUT                  /* INTERNAL */
 %token  ENGINES_SYM
 %token  ENGINE_SYM
 %token  ENUM
-%token  EQ
-%token  EQUAL_SYM
+%token  EQ                            /* OPERATOR */
+%token  EQUAL_SYM                     /* OPERATOR */
 %token  ERRORS
 %token  ESCAPED
-%token  ESCAPE_SYM
-%token  EVENT_SYM
+%token  ESCAPE_SYM                    /* SQL-2003-R */
 %token  EVENTS_SYM
-%token  EVERY_SYM
-%token  EXECUTE_SYM
-%token  EXISTS
+%token  EVENT_SYM
+%token  EVERY_SYM                     /* SQL-2003-N */
+%token  EXECUTE_SYM                   /* SQL-2003-R */
+%token  EXISTS                        /* SQL-2003-R */
 %token  EXIT_SYM
 %token  EXPANSION_SYM
-%token  EXPORT_SET
 %token  EXTENDED_SYM
 %token  EXTENT_SIZE_SYM
-%token  EXTRACT_SYM
-%token  FALSE_SYM
+%token  EXTRACT_SYM                   /* SQL-2003-N */
+%token  FALSE_SYM                     /* SQL-2003-R */
 %token  FAST_SYM
-%token  FETCH_SYM
-%token  FIELD_FUNC
+%token  FETCH_SYM                     /* SQL-2003-R */
 %token  FILE_SYM
-%token  FIRST_SYM
+%token  FIRST_SYM                     /* SQL-2003-N */
 %token  FIXED_SYM
 %token  FLOAT_NUM
-%token  FLOAT_SYM
+%token  FLOAT_SYM                     /* SQL-2003-R */
 %token  FLUSH_SYM
 %token  FORCE_SYM
-%token  FOREIGN
-%token  FORMAT_SYM
-%token  FOR_SYM
-%token  FOUND_SYM
+%token  FOREIGN                       /* SQL-2003-R */
+%token  FOR_SYM                       /* SQL-2003-R */
+%token  FOUND_SYM                     /* SQL-2003-R */
 %token  FRAC_SECOND_SYM
 %token  FROM
-%token  FROM_UNIXTIME
-%token  FULL
+%token  FULL                          /* SQL-2003-R */
 %token  FULLTEXT_SYM
-%token  FUNCTION_SYM
-%token  FUNC_ARG0
-%token  FUNC_ARG1
-%token  FUNC_ARG2
-%token  FUNC_ARG3
+%token  FUNCTION_SYM                  /* SQL-2003-R */
 %token  GE
-%token  GEOMCOLLFROMTEXT
 %token  GEOMETRYCOLLECTION
 %token  GEOMETRY_SYM
-%token  GEOMFROMTEXT
-%token  GEOMFROMWKB
-%token  GET_FORMAT
-%token  GLOBAL_SYM
-%token  GRANT
+%token  GET_FORMAT                    /* MYSQL-FUNC */
+%token  GLOBAL_SYM                    /* SQL-2003-R */
+%token  GRANT                         /* SQL-2003-R */
 %token  GRANTS
-%token  GREATEST_SYM
-%token  GROUP
+%token  GROUP                         /* SQL-2003-R */
 %token  GROUP_CONCAT_SYM
 %token  GROUP_UNIQUE_USERS
-%token  GT_SYM
+%token  GT_SYM                        /* OPERATOR */
 %token  HANDLER_SYM
 %token  HASH_SYM
-%token  HAVING
+%token  HAVING                        /* SQL-2003-R */
 %token  HELP_SYM
 %token  HEX_NUM
 %token  HIGH_PRIORITY
@@ -356,7 +357,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  HOUR_MICROSECOND_SYM
 %token  HOUR_MINUTE_SYM
 %token  HOUR_SECOND_SYM
-%token  HOUR_SYM
+%token  HOUR_SYM                      /* SQL-2003-R */
 %token  IDENT
 %token  IDENTIFIED_SYM
 %token  IDENT_QUOTED
@@ -367,70 +368,63 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  INDEX_SYM
 %token  INFILE
 %token  INITIAL_SIZE_SYM
-%token  INNER_SYM
+%token  INNER_SYM                     /* SQL-2003-R */
 %token  INNOBASE_SYM
-%token  INOUT_SYM
-%token  INSENSITIVE_SYM
-%token  INSERT
+%token  INOUT_SYM                     /* SQL-2003-R */
+%token  INSENSITIVE_SYM               /* SQL-2003-R */
+%token  INSERT                        /* SQL-2003-R */
 %token  INSERT_METHOD
 %token  INSTALL_SYM
-%token  INTERVAL_SYM
-%token  INTO
-%token  INT_SYM
+%token  INTERVAL_SYM                  /* SQL-2003-R */
+%token  INTO                          /* SQL-2003-R */
+%token  INT_SYM                       /* SQL-2003-R */
 %token  INVOKER_SYM
-%token  IN_SYM
-%token  IS
-%token  ISOLATION
+%token  IN_SYM                        /* SQL-2003-R */
+%token  IS                            /* SQL-2003-R */
+%token  ISOLATION                     /* SQL-2003-R */
 %token  ISSUER_SYM
 %token  ITERATE_SYM
-%token  JOIN_SYM
+%token  JOIN_SYM                      /* SQL-2003-R */
 %token  KEYS
-%token  KEY_SYM
 %token  KEY_BLOCK_SIZE
+%token  KEY_SYM                       /* SQL-2003-N */
 %token  KILL_SYM
-%token  LANGUAGE_SYM
-%token  LAST_INSERT_ID
-%token  LAST_SYM
-%token  LE
-%token  LEADING
-%token  LEAST_SYM
+%token  LANGUAGE_SYM                  /* SQL-2003-R */
+%token  LAST_SYM                      /* SQL-2003-N */
+%token  LE                            /* OPERATOR */
+%token  LEADING                       /* SQL-2003-R */
 %token  LEAVES
 %token  LEAVE_SYM
-%token  LEFT
+%token  LEFT                          /* SQL-2003-R */
 %token  LESS_SYM
 %token  LEVEL_SYM
 %token  LEX_HOSTNAME
-%token  LIKE
+%token  LIKE                          /* SQL-2003-R */
 %token  LIMIT
 %token  LINEAR_SYM
-%token  LINEFROMTEXT
 %token  LINES
 %token  LINESTRING
 %token  LIST_SYM
 %token  LOAD
-%token  LOCAL_SYM
-%token  LOCATE
-%token  LOCATOR_SYM
+%token  LOCAL_SYM                     /* SQL-2003-R */
+%token  LOCATOR_SYM                   /* SQL-2003-N */
 %token  LOCKS_SYM
 %token  LOCK_SYM
 %token  LOGFILE_SYM
 %token  LOGS_SYM
-%token  LOG_SYM
 %token  LONGBLOB
 %token  LONGTEXT
 %token  LONG_NUM
 %token  LONG_SYM
 %token  LOOP_SYM
 %token  LOW_PRIORITY
-%token  LT
-%token  MAKE_SET_SYM
+%token  LT                            /* OPERATOR */
 %token  MASTER_CONNECT_RETRY_SYM
 %token  MASTER_HOST_SYM
 %token  MASTER_LOG_FILE_SYM
 %token  MASTER_LOG_POS_SYM
 %token  MASTER_PASSWORD_SYM
 %token  MASTER_PORT_SYM
-%token  MASTER_POS_WAIT
 %token  MASTER_SERVER_ID_SYM
 %token  MASTER_SSL_CAPATH_SYM
 %token  MASTER_SSL_CA_SYM
@@ -440,134 +434,128 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  MASTER_SSL_SYM
 %token  MASTER_SYM
 %token  MASTER_USER_SYM
-%token  MATCH
+%token  MATCH                         /* SQL-2003-R */
 %token  MAX_CONNECTIONS_PER_HOUR
 %token  MAX_QUERIES_PER_HOUR
 %token  MAX_ROWS
 %token  MAX_SIZE_SYM
-%token  MAX_SYM
+%token  MAX_SYM                       /* SQL-2003-N */
 %token  MAX_UPDATES_PER_HOUR
 %token  MAX_USER_CONNECTIONS_SYM
-%token  MAX_VALUE_SYM
+%token  MAX_VALUE_SYM                 /* SQL-2003-N */
 %token  MEDIUMBLOB
 %token  MEDIUMINT
 %token  MEDIUMTEXT
 %token  MEDIUM_SYM
 %token  MEMORY_SYM
-%token  MERGE_SYM
-%token  MICROSECOND_SYM
+%token  MERGE_SYM                     /* SQL-2003-R */
+%token  MICROSECOND_SYM               /* MYSQL-FUNC */
 %token  MIGRATE_SYM
 %token  MINUTE_MICROSECOND_SYM
 %token  MINUTE_SECOND_SYM
-%token  MINUTE_SYM
+%token  MINUTE_SYM                    /* SQL-2003-R */
 %token  MIN_ROWS
-%token  MIN_SYM
-%token  MLINEFROMTEXT
+%token  MIN_SYM                       /* SQL-2003-N */
 %token  MODE_SYM
-%token  MODIFIES_SYM
+%token  MODIFIES_SYM                  /* SQL-2003-R */
 %token  MODIFY_SYM
-%token  MOD_SYM
-%token  MONTH_SYM
-%token  MPOINTFROMTEXT
-%token  MPOLYFROMTEXT
+%token  MOD_SYM                       /* SQL-2003-N */
+%token  MONTH_SYM                     /* SQL-2003-R */
 %token  MULTILINESTRING
 %token  MULTIPOINT
 %token  MULTIPOLYGON
 %token  MUTEX_SYM
-%token  NAMES_SYM
-%token  NAME_SYM
-%token  NATIONAL_SYM
-%token  NATURAL
+%token  NAMES_SYM                     /* SQL-2003-N */
+%token  NAME_SYM                      /* SQL-2003-N */
+%token  NATIONAL_SYM                  /* SQL-2003-R */
+%token  NATURAL                       /* SQL-2003-R */
 %token  NCHAR_STRING
-%token  NCHAR_SYM
+%token  NCHAR_SYM                     /* SQL-2003-R */
 %token  NDBCLUSTER_SYM
-%token  NE
-%token  NEW_SYM
-%token  NEXT_SYM
+%token  NE                            /* OPERATOR */
+%token  NEG
+%token  NEW_SYM                       /* SQL-2003-R */
+%token  NEXT_SYM                      /* SQL-2003-N */
 %token  NODEGROUP_SYM
-%token  NONE_SYM
+%token  NONE_SYM                      /* SQL-2003-R */
 %token  NOT2_SYM
-%token  NOT_SYM
+%token  NOT_SYM                       /* SQL-2003-R */
 %token  NOW_SYM
-%token  NO_SYM
+%token  NO_SYM                        /* SQL-2003-R */
 %token  NO_WAIT_SYM
 %token  NO_WRITE_TO_BINLOG
-%token  NULL_SYM
+%token  NULL_SYM                      /* SQL-2003-R */
 %token  NUM
-%token  NUMERIC_SYM
+%token  NUMERIC_SYM                   /* SQL-2003-R */
 %token  NVARCHAR_SYM
 %token  OFFSET_SYM
-%token  OJ_SYM
 %token  OLD_PASSWORD
-%token  ON
+%token  ON                            /* SQL-2003-R */
 %token  ONE_SHOT_SYM
 %token  ONE_SYM
-%token  OPEN_SYM
+%token  OPEN_SYM                      /* SQL-2003-R */
 %token  OPTIMIZE
-%token  OPTION
+%token  OPTION                        /* SQL-2003-N */
 %token  OPTIONALLY
 %token  OR2_SYM
-%token  ORDER_SYM
-%token  OR_OR_SYM
-%token  OR_SYM
+%token  ORDER_SYM                     /* SQL-2003-R */
+%token  OR_OR_SYM                     /* OPERATOR */
+%token  OR_SYM                        /* SQL-2003-R */
 %token  OUTER
 %token  OUTFILE
-%token  OUT_SYM
+%token  OUT_SYM                       /* SQL-2003-R */
 %token  PACK_KEYS_SYM
+%token  PARAM_MARKER
 %token  PARSER_SYM
-%token  PARTIAL
-%token  PARTITION_SYM
+%token  PARTIAL                       /* SQL-2003-N */
 %token  PARTITIONING_SYM
 %token  PARTITIONS_SYM
+%token  PARTITION_SYM                 /* SQL-2003-R */
 %token  PASSWORD
-%token  PARAM_MARKER
 %token  PHASE_SYM
-%token  PLUGIN_SYM
 %token  PLUGINS_SYM
-%token  POINTFROMTEXT
+%token  PLUGIN_SYM
 %token  POINT_SYM
-%token  POLYFROMTEXT
 %token  POLYGON
-%token  POSITION_SYM
-%token  PRECISION
-%token  PREPARE_SYM
+%token  POSITION_SYM                  /* SQL-2003-N */
+%token  PRECISION                     /* SQL-2003-R */
+%token  PREPARE_SYM                   /* SQL-2003-R */
 %token  PRESERVE_SYM
 %token  PREV_SYM
-%token  PRIMARY_SYM
-%token  PRIVILEGES
-%token  PROCEDURE
+%token  PRIMARY_SYM                   /* SQL-2003-R */
+%token  PRIVILEGES                    /* SQL-2003-N */
+%token  PROCEDURE                     /* SQL-2003-R */
 %token  PROCESS
 %token  PROCESSLIST_SYM
 %token  PURGE
 %token  QUARTER_SYM
 %token  QUERY_SYM
 %token  QUICK
-%token  RAND
-%token  RANGE_SYM
-%token  READS_SYM
+%token  RANGE_SYM                     /* SQL-2003-R */
+%token  READS_SYM                     /* SQL-2003-R */
 %token  READ_ONLY_SYM
-%token  READ_SYM
+%token  READ_SYM                      /* SQL-2003-N */
 %token  READ_WRITE_SYM
-%token  REAL
+%token  REAL                          /* SQL-2003-R */
 %token  REBUILD_SYM
 %token  RECOVER_SYM
-%token  REDO_BUFFER_SIZE_SYM
 %token  REDOFILE_SYM
+%token  REDO_BUFFER_SIZE_SYM
 %token  REDUNDANT_SYM
-%token  REFERENCES
+%token  REFERENCES                    /* SQL-2003-R */
 %token  REGEXP
 %token  RELAY_LOG_FILE_SYM
 %token  RELAY_LOG_POS_SYM
 %token  RELAY_THREAD
-%token  RELEASE_SYM
+%token  RELEASE_SYM                   /* SQL-2003-R */
 %token  RELOAD
 %token  REMOVE_SYM
 %token  RENAME
 %token  REORGANIZE_SYM
 %token  REPAIR
-%token  REPEATABLE_SYM
-%token  REPEAT_SYM
-%token  REPLACE
+%token  REPEATABLE_SYM                /* SQL-2003-N */
+%token  REPEAT_SYM                    /* MYSQL-FUNC */
+%token  REPLACE                       /* MYSQL-FUNC */
 %token  REPLICATION
 %token  REQUIRE_SYM
 %token  RESET_SYM
@@ -575,159 +563,155 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  RESTORE_SYM
 %token  RESTRICT
 %token  RESUME_SYM
-%token  RETURNS_SYM
-%token  RETURN_SYM
-%token  REVOKE
-%token  RIGHT
-%token  ROLLBACK_SYM
-%token  ROLLUP_SYM
-%token  ROUND
-%token  ROUTINE_SYM
-%token  ROWS_SYM
-%token  ROW_COUNT_SYM
+%token  RETURNS_SYM                   /* SQL-2003-R */
+%token  RETURN_SYM                    /* SQL-2003-R */
+%token  REVOKE                        /* SQL-2003-R */
+%token  RIGHT                         /* SQL-2003-R */
+%token  ROLLBACK_SYM                  /* SQL-2003-R */
+%token  ROLLUP_SYM                    /* SQL-2003-R */
+%token  ROUTINE_SYM                   /* SQL-2003-N */
+%token  ROWS_SYM                      /* SQL-2003-R */
 %token  ROW_FORMAT_SYM
-%token  ROW_SYM
+%token  ROW_SYM                       /* SQL-2003-R */
 %token  RTREE_SYM
-%token  SAVEPOINT_SYM
+%token  SAVEPOINT_SYM                 /* SQL-2003-R */
 %token  SCHEDULE_SYM
 %token  SECOND_MICROSECOND_SYM
-%token  SECOND_SYM
-%token  SECURITY_SYM
-%token  SELECT_SYM
-%token  SENSITIVE_SYM
+%token  SECOND_SYM                    /* SQL-2003-R */
+%token  SECURITY_SYM                  /* SQL-2003-N */
+%token  SELECT_SYM                    /* SQL-2003-R */
+%token  SENSITIVE_SYM                 /* FUTURE-USE */
 %token  SEPARATOR_SYM
-%token  SERIALIZABLE_SYM
+%token  SERIALIZABLE_SYM              /* SQL-2003-N */
 %token  SERIAL_SYM
-%token  SESSION_SYM
-%token  SET
+%token  SESSION_SYM                   /* SQL-2003-N */
+%token  SET                           /* SQL-2003-R */
 %token  SET_VAR
 %token  SHARE_SYM
-%token  SHIFT_LEFT
-%token  SHIFT_RIGHT
+%token  SHIFT_LEFT                    /* OPERATOR */
+%token  SHIFT_RIGHT                   /* OPERATOR */
 %token  SHOW
 %token  SHUTDOWN
 %token  SIGNED_SYM
-%token  SIMPLE_SYM
+%token  SIMPLE_SYM                    /* SQL-2003-N */
 %token  SLAVE
-%token  SMALLINT
+%token  SMALLINT                      /* SQL-2003-R */
 %token  SNAPSHOT_SYM
 %token  SONAME_SYM
 %token  SOUNDS_SYM
 %token  SPATIAL_SYM
-%token  SPECIFIC_SYM
-%token  SQLEXCEPTION_SYM
-%token  SQLSTATE_SYM
-%token  SQLWARNING_SYM
+%token  SPECIFIC_SYM                  /* SQL-2003-R */
+%token  SQLEXCEPTION_SYM              /* SQL-2003-R */
+%token  SQLSTATE_SYM                  /* SQL-2003-R */
+%token  SQLWARNING_SYM                /* SQL-2003-R */
 %token  SQL_BIG_RESULT
 %token  SQL_BUFFER_RESULT
 %token  SQL_CACHE_SYM
 %token  SQL_CALC_FOUND_ROWS
 %token  SQL_NO_CACHE_SYM
 %token  SQL_SMALL_RESULT
-%token  SQL_SYM
+%token  SQL_SYM                       /* SQL-2003-R */
 %token  SQL_THREAD
 %token  SSL_SYM
 %token  STARTING
-%token  START_SYM
 %token  STARTS_SYM
+%token  START_SYM                     /* SQL-2003-R */
 %token  STATUS_SYM
+%token  STDDEV_SAMP_SYM               /* SQL-2003-N */
 %token  STD_SYM
-%token  STDDEV_SAMP_SYM
 %token  STOP_SYM
 %token  STORAGE_SYM
 %token  STRAIGHT_JOIN
 %token  STRING_SYM
 %token  SUBDATE_SYM
 %token  SUBJECT_SYM
-%token  SUBPARTITION_SYM
 %token  SUBPARTITIONS_SYM
-%token  SUBSTRING
-%token  SUBSTRING_INDEX
-%token  SUM_SYM
+%token  SUBPARTITION_SYM
+%token  SUBSTRING                     /* SQL-2003-N */
+%token  SUM_SYM                       /* SQL-2003-N */
 %token  SUPER_SYM
 %token  SUSPEND_SYM
 %token  SYSDATE
 %token  TABLES
 %token  TABLESPACE
-%token  TABLE_SYM
-%token  TEMPORARY
+%token  TABLE_REF_PRIORITY
+%token  TABLE_SYM                     /* SQL-2003-R */
+%token  TEMPORARY                     /* SQL-2003-N */
 %token  TEMPTABLE_SYM
 %token  TERMINATED
 %token  TEXT_STRING
 %token  TEXT_SYM
-%token  TIMESTAMP
+%token  THAN_SYM
+%token  THEN_SYM                      /* SQL-2003-R */
+%token  TIMESTAMP                     /* SQL-2003-R */
 %token  TIMESTAMP_ADD
 %token  TIMESTAMP_DIFF
-%token  TIME_SYM
+%token  TIME_SYM                      /* SQL-2003-R */
 %token  TINYBLOB
 %token  TINYINT
 %token  TINYTEXT
-%token  THAN_SYM
-%token  TO_SYM
-%token  TRAILING
+%token  TO_SYM                        /* SQL-2003-R */
+%token  TRAILING                      /* SQL-2003-R */
 %token  TRANSACTION_SYM
-%token  TRIGGER_SYM
 %token  TRIGGERS_SYM
-%token  TRIM
-%token  TRUE_SYM
+%token  TRIGGER_SYM                   /* SQL-2003-R */
+%token  TRIM                          /* SQL-2003-N */
+%token  TRUE_SYM                      /* SQL-2003-R */
 %token  TRUNCATE_SYM
 %token  TYPES_SYM
-%token  TYPE_SYM
+%token  TYPE_SYM                      /* SQL-2003-N */
 %token  UDF_RETURNS_SYM
 %token  ULONGLONG_NUM
-%token  UNCOMMITTED_SYM
+%token  UNCOMMITTED_SYM               /* SQL-2003-N */
 %token  UNDEFINED_SYM
-%token  UNDO_BUFFER_SIZE_SYM
-%token  UNDOFILE_SYM
 %token  UNDERSCORE_CHARSET
-%token  UNDO_SYM
+%token  UNDOFILE_SYM
+%token  UNDO_BUFFER_SIZE_SYM
+%token  UNDO_SYM                      /* FUTURE-USE */
 %token  UNICODE_SYM
 %token  UNINSTALL_SYM
-%token  UNION_SYM
+%token  UNION_SYM                     /* SQL-2003-R */
 %token  UNIQUE_SYM
 %token  UNIQUE_USERS
-%token  UNIX_TIMESTAMP
-%token  UNKNOWN_SYM
+%token  UNKNOWN_SYM                   /* SQL-2003-R */
 %token  UNLOCK_SYM
 %token  UNSIGNED
 %token  UNTIL_SYM
-%token  UPDATE_SYM
+%token  UPDATE_SYM                    /* SQL-2003-R */
 %token  UPGRADE_SYM
-%token  USAGE
-%token  USER
+%token  USAGE                         /* SQL-2003-N */
+%token  USER                          /* SQL-2003-R */
 %token  USE_FRM
 %token  USE_SYM
-%token  USING
+%token  USING                         /* SQL-2003-R */
 %token  UTC_DATE_SYM
 %token  UTC_TIMESTAMP_SYM
 %token  UTC_TIME_SYM
-%token  VAR_SAMP_SYM
-%token  VALUES
-%token  VALUE_SYM
+%token  VALUES                        /* SQL-2003-R */
+%token  VALUE_SYM                     /* SQL-2003-R */
 %token  VARBINARY
-%token  VARCHAR
+%token  VARCHAR                       /* SQL-2003-R */
 %token  VARIABLES
 %token  VARIANCE_SYM
-%token  VARYING
-%token  VIEW_SYM
+%token  VARYING                       /* SQL-2003-R */
+%token  VAR_SAMP_SYM
+%token  VIEW_SYM                      /* SQL-2003-N */
 %token  WAIT_SYM
 %token  WARNINGS
 %token  WEEK_SYM
-%token  WHEN_SYM
-%token  WHERE
+%token  WHEN_SYM                      /* SQL-2003-R */
+%token  WHERE                         /* SQL-2003-R */
 %token  WHILE_SYM
-%token  WITH
-%token  WORK_SYM
-%token  WRITE_SYM
+%token  WITH                          /* SQL-2003-R */
+%token  WORK_SYM                      /* SQL-2003-N */
+%token  WRITE_SYM                     /* SQL-2003-N */
 %token  X509_SYM
 %token  XA_SYM
 %token  XOR
-%token  YEARWEEK
 %token  YEAR_MONTH_SYM
-%token  YEAR_SYM
+%token  YEAR_SYM                      /* SQL-2003-R */
 %token  ZEROFILL
 
-
 %left   JOIN_SYM INNER_SYM STRAIGHT_JOIN CROSS LEFT RIGHT
 /* A dummy token to force the priority of table_ref production in a join. */
 %left   TABLE_REF_PRIORITY
@@ -803,6 +787,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 	simple_ident_nospvar simple_ident_q
         field_or_var limit_option
         part_func_expr
+        function_call_keyword
+        function_call_nonkeyword
+        function_call_generic
+        function_call_conflict
 
 %type <item_num>
 	NUM_literal
@@ -810,6 +798,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <item_list>
 	expr_list udf_expr_list udf_expr_list2 when_list
 	ident_list ident_list_arg
+        expr_list_opt
 
 %type <var_type>
         option_type opt_var_type opt_var_ident_type
@@ -848,7 +837,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <udf_type> udf_func_type
 
-%type <symbol> FUNC_ARG0 FUNC_ARG1 FUNC_ARG2 FUNC_ARG3 keyword keyword_sp
+%type <symbol> keyword keyword_sp
 
 %type <lex_user> user grant_user
 
@@ -5825,10 +5814,10 @@ bool_factor:
 	| bool_test ;
 
 bool_test:
-	bool_pri IS TRUE_SYM	{ $$= is_truth_value($1,1,0); }
-	| bool_pri IS not TRUE_SYM { $$= is_truth_value($1,0,0); }
-	| bool_pri IS FALSE_SYM	{ $$= is_truth_value($1,0,1); }
-	| bool_pri IS not FALSE_SYM { $$= is_truth_value($1,1,1); }
+	bool_pri IS TRUE_SYM	{ $$= is_truth_value(YYTHD, $1,1,0); }
+	| bool_pri IS not TRUE_SYM { $$= is_truth_value(YYTHD, $1,0,0); }
+	| bool_pri IS FALSE_SYM	{ $$= is_truth_value(YYTHD, $1,0,1); }
+	| bool_pri IS not FALSE_SYM { $$= is_truth_value(YYTHD, $1,1,1); }
 	| bool_pri IS UNKNOWN_SYM { $$= new Item_func_isnull($1); }
 	| bool_pri IS not UNKNOWN_SYM { $$= new Item_func_isnotnull($1); }
 	| bool_pri ;
@@ -5949,56 +5938,67 @@ interval_expr:
 
 simple_expr:
 	simple_ident
+        | function_call_keyword
+        | function_call_nonkeyword
+        | function_call_generic
+        | function_call_conflict
  	| simple_expr COLLATE_SYM ident_or_text %prec NEG
 	  {
-	    $$= new Item_func_set_collation($1,
-					    new Item_string($3.str,
-							    $3.length,
-                                                            YYTHD->charset()));
+            THD *thd= YYTHD;
+            Item *i1= new (thd->mem_root) Item_string($3.str,
+                                                      $3.length,
+                                                      thd->charset());
+	    $$= new (thd->mem_root) Item_func_set_collation($1, i1);
 	  }
 	| literal
 	| param_marker
 	| variable
 	| sum_expr
 	| simple_expr OR_OR_SYM simple_expr
-	  { $$= new Item_func_concat($1, $3); }
+	  { $$= new (YYTHD->mem_root) Item_func_concat($1, $3); }
 	| '+' simple_expr %prec NEG	{ $$= $2; }
-	| '-' simple_expr %prec NEG	{ $$= new Item_func_neg($2); }
-	| '~' simple_expr %prec NEG	{ $$= new Item_func_bit_neg($2); }
-	| not2 simple_expr %prec NEG	{ $$= negate_expression(YYTHD, $2); }
+	| '-' simple_expr %prec NEG
+          { $$= new (YYTHD->mem_root) Item_func_neg($2); }
+	| '~' simple_expr %prec NEG
+          { $$= new (YYTHD->mem_root) Item_func_bit_neg($2); }
+	| not2 simple_expr %prec NEG
+          { $$= negate_expression(YYTHD, $2); }
 	| '(' subselect ')'   
           { 
-            $$= new Item_singlerow_subselect($2); 
+            $$= new (YYTHD->mem_root) Item_singlerow_subselect($2); 
           }
 	| '(' expr ')'		{ $$= $2; }
 	| '(' expr ',' expr_list ')'
 	  {
 	    $4->push_front($2);
-	    $$= new Item_row(*$4);
+	    $$= new (YYTHD->mem_root) Item_row(*$4);
 	  }
 	| ROW_SYM '(' expr ',' expr_list ')'
 	  {
 	    $5->push_front($3);
-	    $$= new Item_row(*$5);
+	    $$= new (YYTHD->mem_root) Item_row(*$5);
 	  }
 	| EXISTS '(' subselect ')' 
           {
-            $$= new Item_exists_subselect($3); 
+            $$= new (YYTHD->mem_root) Item_exists_subselect($3); 
           }
 	| '{' ident expr '}'	{ $$= $3; }
         | MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')'
-          { $2->push_front($5);
-            Select->add_ftfunc_to_list((Item_func_match*)
-                                        ($$=new Item_func_match(*$2,$6))); }
-	| ASCII_SYM '(' expr ')' { $$= new Item_func_ascii($3); }
+          {
+            $2->push_front($5);
+            Item_func_match *i1= new (YYTHD->mem_root) Item_func_match(*$2, $6);
+            Select->add_ftfunc_to_list(i1);
+            $$= i1;
+          }
 	| BINARY simple_expr %prec NEG
 	  {
-            $$= create_func_cast($2, ITEM_CAST_CHAR, -1, 0, &my_charset_bin);
+            $$= create_func_cast(YYTHD, $2, ITEM_CAST_CHAR, -1, 0,
+                                 &my_charset_bin);
 	  }
 	| CAST_SYM '(' expr AS cast_type ')'
 	  {
             LEX *lex= Lex;
-	    $$= create_func_cast($3, $5,
+	    $$= create_func_cast(YYTHD, $3, $5,
                                  lex->length ? atoi(lex->length) : -1,
                                  lex->dec ? atoi(lex->dec) : 0,
                                  lex->charset);
@@ -6006,10 +6006,10 @@ simple_expr:
               YYABORT;
 	  }
 	| CASE_SYM opt_expr WHEN_SYM when_list opt_else END
-	  { $$= new Item_func_case(* $4, $2, $5 ); }
+	  { $$= new (YYTHD->mem_root) Item_func_case(* $4, $2, $5 ); }
 	| CONVERT_SYM '(' expr ',' cast_type ')'
 	  {
-	    $$= create_func_cast($3, $5,
+	    $$= create_func_cast(YYTHD, $3, $5,
 				 Lex->length ? atoi(Lex->length) : -1,
                                  Lex->dec ? atoi(Lex->dec) : 0,
 				 Lex->charset);
@@ -6017,7 +6017,7 @@ simple_expr:
               YYABORT;
 	  }
 	| CONVERT_SYM '(' expr USING charset_name ')'
-	  { $$= new Item_func_conv_charset($3,$5); }
+	  { $$= new (YYTHD->mem_root) Item_func_conv_charset($3,$5); }
 	| DEFAULT '(' simple_ident ')'
 	  {
 	    if ($3->is_splocal())
@@ -6027,545 +6027,432 @@ simple_expr:
 	      my_error(ER_WRONG_COLUMN_NAME, MYF(0), il->my_name()->str);
 	      YYABORT;
 	    }
-	    $$= new Item_default_value(Lex->current_context(), $3);
+	    $$= new (YYTHD->mem_root) Item_default_value(Lex->current_context(),
+                                                         $3);
 	  }
 	| VALUES '(' simple_ident_nospvar ')'
-	  { $$= new Item_insert_value(Lex->current_context(), $3); }
-	| FUNC_ARG0 '(' ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(void))($1.symbol->create_func))();
-	  }
-	| FUNC_ARG1 '(' expr ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*))($1.symbol->create_func))($3);
-	  }
-	| FUNC_ARG2 '(' expr ',' expr ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-	      my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);
-	  }
-	| FUNC_ARG3 '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_insert_value(Lex->current_context(),
+                                                        $3); }
+	| interval_expr interval '+' expr
+	  /* we cannot put interval before - */
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($4,$1,$2,0); }
+	| interval_expr
 	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*,Item*,Item*))($1.symbol->create_func))($3,$5,$7);
-	  }
-	| ADDDATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 0);}
-	| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
-	  { $$= new Item_date_add_interval($3, $6, $7, 0); }
-	| REPEAT_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_repeat($3,$5); }
-	| ATAN	'(' expr ')'
-	  { $$= new Item_func_atan($3); }
-	| ATAN	'(' expr ',' expr ')'
-	  { $$= new Item_func_atan($3,$5); }
-	| CHAR_SYM '(' expr_list ')'
-	  { $$= new Item_func_char(*$3); }
-	| CHAR_SYM '(' expr_list USING charset_name ')'
-	  { $$= new Item_func_char(*$3, $5); }
-	| CHARSET '(' expr ')'
-	  { $$= new Item_func_charset($3); }
-	| COALESCE '(' expr_list ')'
-	  { $$= new Item_func_coalesce(* $3); }
-	| COLLATION_SYM '(' expr ')'
-	  { $$= new Item_func_collation($3); }
-	| CONCAT '(' expr_list ')'
-	  { $$= new Item_func_concat(* $3); }
-	| CONCAT_WS '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_concat_ws(*$5); }
-	| CONVERT_TZ_SYM '(' expr ',' expr ',' expr ')'
-	  {
-            if (Lex->add_time_zone_tables_to_query_tables(YYTHD))
+            if ($1->type() != Item::ROW_ITEM)
+            {
+              yyerror(ER(ER_SYNTAX_ERROR));
               YYABORT;
-	    $$= new Item_func_convert_tz($3, $5, $7);
-	  }
-	| CURDATE optional_braces
-	  { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; }
-	| CURTIME optional_braces
-	  { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; }
-	| CURTIME '(' expr ')'
+            }
+            $$= new (YYTHD->mem_root) Item_func_interval((Item_row *)$1);
+          }
+	| UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')'
 	  {
-	    $$= new Item_func_curtime_local($3);
-	    Lex->safe_to_cache_query=0;
+            $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9);
 	  }
+        ;
+
+/*
+  Function call syntax using official SQL 2003 keywords.
+  Because the function name is an official token,
+  a dedicated grammar rule is needed in the parser.
+  There is no potential for conflicts
+*/
+function_call_keyword:
+	  CHAR_SYM '(' expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_char(*$3); }
+	| CHAR_SYM '(' expr_list USING charset_name ')'
+	  { $$= new (YYTHD->mem_root) Item_func_char(*$3, $5); }
 	| CURRENT_USER optional_braces
           {
-            $$= new Item_func_current_user(Lex->current_context());
+            $$= new (YYTHD->mem_root) Item_func_current_user(Lex->current_context());
             Lex->safe_to_cache_query= 0;
           }
-	| DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')'
-	  { $$= new Item_date_add_interval($3,$5,$6,0); }
-	| DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')'
-	  { $$= new Item_date_add_interval($3,$5,$6,1); }
-	| DATABASE '(' ')'
-	  {
-	    $$= new Item_func_database();
-            Lex->safe_to_cache_query=0;
-	  }
 	| DATE_SYM '(' expr ')'
-	  { $$= new Item_date_typecast($3); }
+	  { $$= new (YYTHD->mem_root) Item_date_typecast($3); }
 	| DAY_SYM '(' expr ')'
-	  { $$= new Item_func_dayofmonth($3); }
-	| ELT_FUNC '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_elt(*$5); }
-	| MAKE_SET_SYM '(' expr ',' expr_list ')'
-	  { $$= new Item_func_make_set($3, *$5); }
-	| ENCRYPT '(' expr ')'
-	  {
-	    $$= new Item_func_encrypt($3);
-	    Lex->uncacheable(UNCACHEABLE_RAND);
-	  }
-	| ENCRYPT '(' expr ',' expr ')'   { $$= new Item_func_encrypt($3,$5); }
-	| DECODE_SYM '(' expr ',' TEXT_STRING_literal ')'
-	  { $$= new Item_func_decode($3,$5.str); }
-	| ENCODE_SYM '(' expr ',' TEXT_STRING_literal ')'
-	 { $$= new Item_func_encode($3,$5.str); }
-	| DES_DECRYPT_SYM '(' expr ')'
-        { $$= new Item_func_des_decrypt($3); }
-	| DES_DECRYPT_SYM '(' expr ',' expr ')'
-        { $$= new Item_func_des_decrypt($3,$5); }
-	| DES_ENCRYPT_SYM '(' expr ')'
-        { $$= new Item_func_des_encrypt($3); }
-	| DES_ENCRYPT_SYM '(' expr ',' expr ')'
-        { $$= new Item_func_des_encrypt($3,$5); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7, $9); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7, $9, $11); }
-	| FORMAT_SYM '(' expr ',' NUM ')'
-	  { $$= new Item_func_format($3,atoi($5.str)); }
-	| FROM_UNIXTIME '(' expr ')'
-	  { $$= new Item_func_from_unixtime($3); }
-	| FROM_UNIXTIME '(' expr ',' expr ')'
-	  {
-	    $$= new Item_func_date_format (new Item_func_from_unixtime($3),$5,0);
-	  }
-	| FIELD_FUNC '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_field(*$5); }
-	| geometry_function
-	  {
-#ifdef HAVE_SPATIAL
-	    $$= $1;
-#else
-	    my_error(ER_FEATURE_DISABLED, MYF(0),
-                     sym_group_geom.name, sym_group_geom.needed_define);
-	    YYABORT;
-#endif
-	  }
-	| GET_FORMAT '(' date_time_type  ',' expr ')'
-	  { $$= new Item_func_get_format($3, $5); }
+	  { $$= new (YYTHD->mem_root) Item_func_dayofmonth($3); }
 	| HOUR_SYM '(' expr ')'
-	  { $$= new Item_func_hour($3); }
-	| IF '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_if($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_hour($3); }
 	| INSERT '(' expr ',' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_insert($3,$5,$7,$9); }
-	| interval_expr interval '+' expr
-	  /* we cannot put interval before - */
-	  { $$= new Item_date_add_interval($4,$1,$2,0); }
-	| interval_expr
+	  { $$= new (YYTHD->mem_root) Item_func_insert($3,$5,$7,$9); }
+	| LEFT '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_left($3,$5); }
+	| MINUTE_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_minute($3); }
+	| MONTH_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_month($3); }
+	| RIGHT '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_right($3,$5); }
+	| SECOND_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_second($3); }
+	| TIME_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_time_typecast($3); }
+	| TIMESTAMP '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_datetime_typecast($3); }
+	| TIMESTAMP '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_add_time($3, $5, 1, 0); }
+	| TRIM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($3); }
+	| TRIM '(' LEADING expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_ltrim($6,$4); }
+	| TRIM '(' TRAILING expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_rtrim($6,$4); }
+	| TRIM '(' BOTH expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($6,$4); }
+	| TRIM '(' LEADING FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_ltrim($5); }
+	| TRIM '(' TRAILING FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_rtrim($5); }
+	| TRIM '(' BOTH FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($5); }
+	| TRIM '(' expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($5,$3); }
+	| USER '(' ')'
 	  {
-            if ($1->type() != Item::ROW_ITEM)
-            {
-              yyerror(ER(ER_SYNTAX_ERROR));
-              YYABORT;
-            }
-            $$= new Item_func_interval((Item_row *)$1);
+            $$= new (YYTHD->mem_root) Item_func_user();
+            Lex->safe_to_cache_query=0;
           }
-	| LAST_INSERT_ID '(' ')'
+	| YEAR_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_year($3); }
+        ;
+
+/*
+  Function calls using non reserved keywords, with special syntaxic forms.
+  Dedicated grammar rules are needed because of the syntax,
+  but also have the potential to cause incompatibilities with other
+  parts of the language.
+  MAINTAINER:
+  The only reasons a function should be added here are:
+  - for compatibility reasons with another SQL syntax (CURDATE),
+  - for typing reasons (GET_FORMAT)
+  Any other 'Syntaxic sugar' enhancements should be *STRONGLY*
+  discouraged.
+*/
+function_call_nonkeyword:
+	  ADDDATE_SYM '(' expr ',' expr ')'
 	  {
-	    $$= new Item_func_last_insert_id();
-	    Lex->safe_to_cache_query= 0;
-	  }
-	| LAST_INSERT_ID '(' expr ')'
+            $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5,
+                                                             INTERVAL_DAY, 0);
+          }
+	| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 0); }
+	| CURDATE optional_braces
 	  {
-	    $$= new Item_func_last_insert_id($3);
-	    Lex->safe_to_cache_query= 0;
-	  }
-	| LEFT '(' expr ',' expr ')'
-	  { $$= new Item_func_left($3,$5); }
-	| LOCATE '(' expr ',' expr ')'
-	  { $$= new Item_func_locate($5,$3); }
-	| LOCATE '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_locate($5,$3,$7); }
-	| GREATEST_SYM '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_max(*$5); }
-	| LEAST_SYM '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_min(*$5); }
-	| LOG_SYM '(' expr ')'
-	  { $$= new Item_func_log($3); }
-	| LOG_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_log($3, $5); }
-	| MASTER_POS_WAIT '(' expr ',' expr ')'
-	  {
-	    $$= new Item_master_pos_wait($3, $5);
-	    Lex->safe_to_cache_query=0;
-		  }
-	| MASTER_POS_WAIT '(' expr ',' expr ',' expr ')'
+            $$= new (YYTHD->mem_root) Item_func_curdate_local();
+            Lex->safe_to_cache_query=0;
+          }
+	| CURTIME optional_braces
+	  {
+            $$= new (YYTHD->mem_root) Item_func_curtime_local();
+            Lex->safe_to_cache_query=0;
+          }
+	| CURTIME '(' expr ')'
 	  {
-	    $$= new Item_master_pos_wait($3, $5, $7);
+	    $$= new (YYTHD->mem_root) Item_func_curtime_local($3);
 	    Lex->safe_to_cache_query=0;
 	  }
-	| MICROSECOND_SYM '(' expr ')'
-	  { $$= new Item_func_microsecond($3); }
-	| MINUTE_SYM '(' expr ')'
-	  { $$= new Item_func_minute($3); }
-	| MOD_SYM '(' expr ',' expr ')'
-	  { $$ = new Item_func_mod( $3, $5); }
-	| MONTH_SYM '(' expr ')'
-	  { $$= new Item_func_month($3); }
+	| DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,0); }
+	| DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,1); }
+	| EXTRACT_SYM '(' interval FROM expr ')'
+	  { $$=new (YYTHD->mem_root) Item_extract( $3, $5); }
+	| GET_FORMAT '(' date_time_type  ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_get_format($3, $5); }
 	| NOW_SYM optional_braces
-	  { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;}
+	  {
+            $$= new (YYTHD->mem_root) Item_func_now_local();
+            Lex->safe_to_cache_query=0;
+          }
 	| NOW_SYM '(' expr ')'
-	  { $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0;}
-	| PASSWORD '(' expr ')'
 	  {
-	    $$= YYTHD->variables.old_passwords ?
-              (Item *) new Item_func_old_password($3) :
-	      (Item *) new Item_func_password($3);
-	  }
-	| OLD_PASSWORD '(' expr ')'
-	  { $$=  new Item_func_old_password($3); }
+            $$= new (YYTHD->mem_root) Item_func_now_local($3);
+            Lex->safe_to_cache_query=0;
+          }
 	| POSITION_SYM '(' bit_expr IN_SYM expr ')'
-	  { $$ = new Item_func_locate($5,$3); }
-	| QUARTER_SYM '(' expr ')'
-	  { $$ = new Item_func_quarter($3); }
-	| RAND '(' expr ')'
-	  { $$= new Item_func_rand($3); Lex->uncacheable(UNCACHEABLE_RAND);}
-	| RAND '(' ')'
-	  { $$= new Item_func_rand(); Lex->uncacheable(UNCACHEABLE_RAND);}
-	| REPLACE '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_replace($3,$5,$7); }
-	| RIGHT '(' expr ',' expr ')'
-	  { $$= new Item_func_right($3,$5); }
-	| ROUND '(' expr ')'
-	  { $$= new Item_func_round($3, new Item_int((char*)"0",0,1),0); }
-	| ROUND '(' expr ',' expr ')' { $$= new Item_func_round($3,$5,0); }
-	| ROW_COUNT_SYM '(' ')'
-	  {
-	    $$= new Item_func_row_count();
-	    Lex->safe_to_cache_query= 0;
-	  }
+	  { $$ = new (YYTHD->mem_root) Item_func_locate($5,$3); }
 	| SUBDATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);}
+	  {
+            $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5,
+                                                             INTERVAL_DAY, 1);
+          }
 	| SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
-	  { $$= new Item_date_add_interval($3, $6, $7, 1); }
-	| SECOND_SYM '(' expr ')'
-	  { $$= new Item_func_second($3); }
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 1); }
 	| SUBSTRING '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_substr($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); }
 	| SUBSTRING '(' expr ',' expr ')'
-	  { $$= new Item_func_substr($3,$5); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); }
 	| SUBSTRING '(' expr FROM expr FOR_SYM expr ')'
-	  { $$= new Item_func_substr($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); }
 	| SUBSTRING '(' expr FROM expr ')'
-	  { $$= new Item_func_substr($3,$5); }
-	| SUBSTRING_INDEX '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_substr_index($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); }
 	| SYSDATE optional_braces
           {
             if (global_system_variables.sysdate_is_now == 0)
-              $$= new Item_func_sysdate_local();
-            else $$= new Item_func_now_local();
+              $$= new (YYTHD->mem_root) Item_func_sysdate_local();
+            else
+              $$= new (YYTHD->mem_root) Item_func_now_local();
             Lex->safe_to_cache_query=0;
           }
 	| SYSDATE '(' expr ')'
           {
             if (global_system_variables.sysdate_is_now == 0)
-              $$= new Item_func_sysdate_local($3);
-            else $$= new Item_func_now_local($3);
+              $$= new (YYTHD->mem_root) Item_func_sysdate_local($3);
+            else
+              $$= new (YYTHD->mem_root) Item_func_now_local($3);
             Lex->safe_to_cache_query=0;
           }
-	| TIME_SYM '(' expr ')'
-	  { $$= new Item_time_typecast($3); }
-	| TIMESTAMP '(' expr ')'
-	  { $$= new Item_datetime_typecast($3); }
-	| TIMESTAMP '(' expr ',' expr ')'
-	  { $$= new Item_func_add_time($3, $5, 1, 0); }
 	| TIMESTAMP_ADD '(' interval_time_st ',' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($7,$5,$3,0); }
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($7,$5,$3,0); }
 	| TIMESTAMP_DIFF '(' interval_time_st ',' expr ',' expr ')'
-	  { $$= new Item_func_timestamp_diff($5,$7,$3); }
-	| TRIM '(' expr ')'
-	  { $$= new Item_func_trim($3); }
-	| TRIM '(' LEADING expr FROM expr ')'
-	  { $$= new Item_func_ltrim($6,$4); }
-	| TRIM '(' TRAILING expr FROM expr ')'
-	  { $$= new Item_func_rtrim($6,$4); }
-	| TRIM '(' BOTH expr FROM expr ')'
-	  { $$= new Item_func_trim($6,$4); }
-	| TRIM '(' LEADING FROM expr ')'
-	 { $$= new Item_func_ltrim($5); }
-	| TRIM '(' TRAILING FROM expr ')'
-	  { $$= new Item_func_rtrim($5); }
-	| TRIM '(' BOTH FROM expr ')'
-	  { $$= new Item_func_trim($5); }
-	| TRIM '(' expr FROM expr ')'
-	  { $$= new Item_func_trim($5,$3); }
-	| TRUNCATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_round($3,$5,1); }
-	| ident '.' ident '(' udf_expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_timestamp_diff($5,$7,$3); }
+	| UTC_DATE_SYM optional_braces
 	  {
-	    LEX *lex= Lex;
-	    sp_name *name= new sp_name($1, $3);
+            $$= new (YYTHD->mem_root) Item_func_curdate_utc();
+            Lex->safe_to_cache_query=0;
+          }
+	| UTC_TIME_SYM optional_braces
+	  {
+            $$= new (YYTHD->mem_root) Item_func_curtime_utc();
+            Lex->safe_to_cache_query=0;
+          }
+	| UTC_TIMESTAMP_SYM optional_braces
+	  {
+            $$= new (YYTHD->mem_root) Item_func_now_utc();
+            Lex->safe_to_cache_query=0;
+          }
+        ;
 
-	    name->init_qname(YYTHD);
-	    sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION);
-	    if ($5)
-	      $$= new Item_func_sp(Lex->current_context(), name, *$5);
-	    else
-	      $$= new Item_func_sp(Lex->current_context(), name);
-	    lex->safe_to_cache_query=0;
+/*
+  Functions calls using a non reserved keywork, and using a regular syntax.
+  Because the non reserved keyword is used in another part of the grammar,
+  a dedicated rule is needed here.
+*/
+function_call_conflict:
+	  ASCII_SYM '(' expr ')'
+          { $$= new (YYTHD->mem_root) Item_func_ascii($3); }
+	| CHARSET '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_charset($3); }
+	| COALESCE '(' expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_coalesce(* $3); }
+	| COLLATION_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_collation($3); }
+	| DATABASE '(' ')'
+	  {
+	    $$= new (YYTHD->mem_root) Item_func_database();
+            Lex->safe_to_cache_query=0;
+	  }
+	| IF '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_if($3,$5,$7); }
+	| MICROSECOND_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_microsecond($3); }
+	| MOD_SYM '(' expr ',' expr ')'
+	  { $$ = new (YYTHD->mem_root) Item_func_mod( $3, $5); }
+	| OLD_PASSWORD '(' expr ')'
+	  { $$=  new (YYTHD->mem_root) Item_func_old_password($3); }
+	| PASSWORD '(' expr ')'
+	  {
+            THD *thd= YYTHD;
+            Item* i1;
+            if (thd->variables.old_passwords)
+              i1= new (thd->mem_root) Item_func_old_password($3);
+            else
+              i1= new (thd->mem_root) Item_func_password($3);
+            $$= i1;
 	  }
-	| IDENT_sys '(' 
+	| QUARTER_SYM '(' expr ')'
+	  { $$ = new (YYTHD->mem_root) Item_func_quarter($3); }
+	| REPEAT_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_repeat($3,$5); }
+	| REPLACE '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_replace($3,$5,$7); }
+	| TRUNCATE_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_round($3,$5,1); }
+	| WEEK_SYM '(' expr ')'
+	  {
+            THD *thd= YYTHD;
+            Item *i1= new (thd->mem_root) Item_int((char*) "0",
+                                           thd->variables.default_week_format,
+                                                   1);
+
+            $$= new (thd->mem_root) Item_func_week($3, i1);
+          }
+	| WEEK_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_week($3,$5); }
+        | geometry_function
           {
+#ifdef HAVE_SPATIAL
+            $$= $1;
+#else
+            my_error(ER_FEATURE_DISABLED, MYF(0),
+                     sym_group_geom.name, sym_group_geom.needed_define);
+            YYABORT;
+#endif
+          }
+        ;
+
+geometry_function:
+	  CONTAINS_SYM '(' expr ',' expr ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_rel($3, $5,
+                                               Item_func::SP_CONTAINS_FUNC));
+          }
+	| GEOMETRYCOLLECTION '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_geometrycollection,
+                           Geometry::wkb_point));
+          }
+	| LINESTRING '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_linestring,
+                           Geometry::wkb_point));
+          }
+ 	| MULTILINESTRING '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multilinestring,
+                           Geometry::wkb_linestring));
+          }
+	| MULTIPOINT '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multipoint,
+                           Geometry::wkb_point));
+          }
+ 	| MULTIPOLYGON '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multipolygon,
+                           Geometry::wkb_polygon));
+          }
+	| POINT_SYM '(' expr ',' expr ')'
+	  { $$= GEOM_NEW(YYTHD, Item_func_point($3,$5)); }
+	| POLYGON '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+	                   Geometry::wkb_polygon,
+                           Geometry::wkb_linestring));
+          }
+        ;
+
+/*
+  Regular function calls.
+  The function name is *not* a token, and therefore is guaranteed to not
+  introduce side effects to the language in general.
+  MAINTAINER:
+  All the new functions implemented for new features should fit into
+  this category. The place to implement the function itself is
+  in sql/item_create.cc
+*/
+function_call_generic:
+        IDENT_sys '('
+        {
 #ifdef HAVE_DLOPEN
-            udf_func *udf= 0;
-            if (using_udf_functions &&
-                (udf= find_udf($1.str, $1.length)) &&
-                udf->type == UDFTYPE_AGGREGATE)
+          udf_func *udf= 0;
+          if (using_udf_functions &&
+              (udf= find_udf($1.str, $1.length)) &&
+              udf->type == UDFTYPE_AGGREGATE)
+          {
+            LEX *lex= Lex;
+            if (lex->current_select->inc_in_sum_expr())
             {
-              LEX *lex= Lex;
-              if (lex->current_select->inc_in_sum_expr())
-              {
-                yyerror(ER(ER_SYNTAX_ERROR));
-                YYABORT;
-              }
+              yyerror(ER(ER_SYNTAX_ERROR));
+              YYABORT;
             }
-            $<udf>$= udf;
+          }
+          /* Temporary placing the result of find_udf in $3 */
+          $<udf>$= udf;
 #endif
+        }
+        expr_list_opt ')'
+        {
+          THD *thd= YYTHD;
+          LEX *lex= Lex;
+          Create_func *builder;
+          Item *item= NULL;
+
+          /*
+            Implementation note:
+            names are resolved with the following order:
+            - MySQL native functions,
+            - User Defined Functions,
+            - Stored Functions (assuming the current <use> database)
+
+            This will be revised with WL#2128 (SQL PATH)
+          */
+          builder= find_native_function_builder(thd, $1);
+          if (builder)
+          {
+            item= builder->create(thd, $1, $4);
           }
-          udf_expr_list ')'
+          else
           {
 #ifdef HAVE_DLOPEN
+            /* Retrieving the result of find_udf */
             udf_func *udf= $<udf>3;
-            SELECT_LEX *sel= Select;
 
             if (udf)
             {
               if (udf->type == UDFTYPE_AGGREGATE)
+              {
                 Select->in_sum_expr--;
-
-              Lex->binlog_row_based_if_mixed= TRUE;
-
-              switch (udf->returns) {
-              case STRING_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_str(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_str(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_str(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_str(udf);
-                }
-                break;
-              case REAL_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_float(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_float(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_float(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_float(udf);
-                }
-                break;
-              case INT_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_int(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_int(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_int(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_int(udf);
-                }
-                break;
-              case DECIMAL_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_decimal(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_decimal(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_decimal(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_decimal(udf);
-                }
-                break;
-              default:
-                YYABORT;
               }
+
+              item= Create_udf_func::s_singleton.create(thd, udf, $4);
             }
             else
-#endif /* HAVE_DLOPEN */
+#endif
             {
-	      LEX *lex= Lex;
-              THD *thd= lex->thd;
-              LEX_STRING db;
-              if (thd->copy_db_to(&db.str, &db.length))
-                YYABORT;
-              sp_name *name= new sp_name(db, $1);
-              if (name)
-                name->init_qname(thd);
-
-              sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION);
-              if ($4)
-                $$= new Item_func_sp(Lex->current_context(), name, *$4);
-              else
-                $$= new Item_func_sp(Lex->current_context(), name);
-	      lex->safe_to_cache_query=0;
-	    }
+              builder= find_qualified_function_builder(thd);
+              DBUG_ASSERT(builder);
+              item= builder->create(thd, $1, $4);
+            }
           }
-	| UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')'
-	  {
-            $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9);
-	  }
-	| UNIX_TIMESTAMP '(' ')'
-	  {
-	    $$= new Item_func_unix_timestamp();
-	    Lex->safe_to_cache_query=0;
-	  }
-	| UNIX_TIMESTAMP '(' expr ')'
-	  { $$= new Item_func_unix_timestamp($3); }
-	| USER '(' ')'
-	  { $$= new Item_func_user(); Lex->safe_to_cache_query=0; }
-	| UTC_DATE_SYM optional_braces
-	  { $$= new Item_func_curdate_utc(); Lex->safe_to_cache_query=0;}
-	| UTC_TIME_SYM optional_braces
-	  { $$= new Item_func_curtime_utc(); Lex->safe_to_cache_query=0;}
-	| UTC_TIMESTAMP_SYM optional_braces
-	  { $$= new Item_func_now_utc(); Lex->safe_to_cache_query=0;}
-	| WEEK_SYM '(' expr ')'
-	  {
-            $$= new Item_func_week($3,new Item_int((char*) "0",
-				   YYTHD->variables.default_week_format,1));
+
+          if (! ($$= item))
+          {
+            YYABORT;
           }
-	| WEEK_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_week($3,$5); }
-	| YEAR_SYM '(' expr ')'
-	  { $$= new Item_func_year($3); }
-	| YEARWEEK '(' expr ')'
-	  { $$= new Item_func_yearweek($3,new Item_int((char*) "0",0,1)); }
-	| YEARWEEK '(' expr ',' expr ')'
-	  { $$= new Item_func_yearweek($3, $5); }
-	| BENCHMARK_SYM '(' ulong_num ',' expr ')'
-	  {
-	    $$=new Item_func_benchmark($3,$5);
-	    Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-	  }
-	| EXTRACT_SYM '(' interval FROM expr ')'
-	{ $$=new Item_extract( $3, $5); };
+        }
+	| ident '.' ident '(' udf_expr_list ')'
+	{
+          THD *thd= YYTHD;
+          Create_qfunc *builder;
+          Item *item= NULL;
 
-geometry_function:
-	  CONTAINS_SYM '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_spatial_rel($3, $5, Item_func::SP_CONTAINS_FUNC)); }
-	| GEOMFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| GEOMFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| GEOMFROMWKB '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_wkb($3)); }
-	| GEOMFROMWKB '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_wkb($3, $5)); }
-	| GEOMETRYCOLLECTION '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                           Geometry::wkb_geometrycollection,
-                           Geometry::wkb_point)); }
-	| LINESTRING '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_linestring, Geometry::wkb_point)); }
- 	| MULTILINESTRING '(' expr_list ')'
-	  { $$= GEOM_NEW( Item_func_spatial_collection(* $3,
-                   Geometry::wkb_multilinestring, Geometry::wkb_linestring)); }
- 	| MLINEFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MLINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MPOINTFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MPOINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MPOLYFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MPOLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MULTIPOINT '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_multipoint, Geometry::wkb_point)); }
- 	| MULTIPOLYGON '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_multipolygon, Geometry::wkb_polygon)); }
-	| POINT_SYM '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_point($3,$5)); }
- 	| POINTFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| POINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| POLYFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| POLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| POLYGON '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-	          Geometry::wkb_polygon, Geometry::wkb_linestring)); }
- 	| GEOMCOLLFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| GEOMCOLLFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
- 	| LINEFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| LINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	;
+          /*
+            The following in practice calls:
+            <code>Create_sp_func::create()</code>
+            and builds a stored function.
+
+            However, it's important to maintain the interface between the
+            parser and the implementation in item_create.cc clean,
+            since this will change with WL#2128 (SQL PATH):
+            - INFORMATION_SCHEMA.version() is the SQL 99 syntax for the native
+            funtion version(),
+            - MySQL.version() is the SQL 2003 syntax for the native function
+            version() (a vendor can specify any schema).
+          */
+
+          builder= find_qualified_function_builder(thd);
+          DBUG_ASSERT(builder);
+          item= builder->create(thd, $1, $3, $5);
+
+          if (! ($$= item))
+          {
+            YYABORT;
+          }
+	}
+        ;
 
 fulltext_options:
           opt_natural_language_mode opt_query_expansion
@@ -6775,6 +6662,13 @@ cast_type:
         | DECIMAL_SYM float_options { $$=ITEM_CAST_DECIMAL; Lex->charset= NULL; }
 	;
 
+expr_list_opt:
+        /* empty */
+          { $$ = NULL; }
+        | expr_list
+          { $$ = $1;}
+        ;
+
 expr_list:
 	{ Select->expr_list.push_front(new List<Item>); }
 	expr_list2
diff --git a/tests/mysql_client_test.c b/tests/mysql_client_test.c
index 148295398f4..d16eec1e3cc 100644
--- a/tests/mysql_client_test.c
+++ b/tests/mysql_client_test.c
@@ -8685,7 +8685,7 @@ static void test_sqlmode()
   if (!opt_silent)
     fprintf(stdout, "\n  query: %s", query);
   stmt= mysql_simple_prepare(mysql, query);
-  check_stmt_r(stmt);
+  check_stmt(stmt);
 
   /* ANSI */
   strmov(query, "SET SQL_MODE= \"ANSI\"");