From 384407aaeb37dafe4826c31006cd47c611da0da2 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 2 Nov 2006 11:01:53 -0700 Subject: [PATCH] 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 --- mysql-test/include/parser_bug21114.inc | 59 + mysql-test/r/func_math.result | 12 + mysql-test/r/parser.result | 388 ++ mysql-test/r/parser_bug21114_innodb.result | 867 ++++ mysql-test/r/view.result | 8 +- mysql-test/t/func_math.test | 5 + mysql-test/t/parser.test | 510 ++ mysql-test/t/parser_bug21114_innodb.test | 422 ++ mysql-test/t/view.test | 6 +- sql/item_create.cc | 5118 ++++++++++++++++++-- sql/item_create.h | 274 +- sql/item_geofunc.h | 4 +- sql/lex.h | 216 +- sql/lex_symbol.h | 1 - sql/mysql_priv.h | 4 + sql/mysqld.cc | 3 + sql/share/errmsg.txt | 4 + sql/sql_yacc.yy | 1516 +++--- tests/mysql_client_test.c | 2 +- 19 files changed, 7792 insertions(+), 1627 deletions(-) create mode 100755 mysql-test/include/parser_bug21114.inc create mode 100644 mysql-test/r/parser.result create mode 100644 mysql-test/r/parser_bug21114_innodb.result create mode 100644 mysql-test/t/parser.test create mode 100644 mysql-test/t/parser_bug21114_innodb.test 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= ; +# -- source parser_stress_func.inc +# let $FCT= ; +# -- source parser_stress_func.inc +# let $verbose=0; +# let $FCT= ; +# -- source parser_stress_func.inc +# let $FCT= ; +# -- 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" -Item *create_func_abs(Item* a) +/* +============================================================================= + LOCAL DECLARATIONS +============================================================================= +*/ + +/** + Adapter for functions that takes exactly zero arguments. +*/ + +class Create_func_arg0 : public Create_func { - return new Item_func_abs(a); +public: + virtual Item* create(THD *thd, LEX_STRING name, List *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_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_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_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_list); + + static Create_sp_func s_singleton; + +protected: + /** Constructor. */ + Create_sp_func() {} + /** Destructor. */ + virtual ~Create_sp_func() {} +}; + + +#ifndef HAVE_SPATIAL +/** + Common (non) builder for geometry functions. + This builder is used in --without-geometry 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 +{ +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_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_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 * /* 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_qfunc::create(THD *thd, LEX_STRING name, List *item_list) +{ + LEX_STRING db; + if (thd->copy_db_to(&db.str, &db.length)) + return NULL; + + return create(thd, db, name, item_list); } -Item *create_func_acos(Item* a) + +#ifdef HAVE_DLOPEN +Create_udf_func Create_udf_func::s_singleton; + +Item* +Create_udf_func::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_acos(a); + udf_func *udf= find_udf(name.str, name.length); + DBUG_ASSERT(udf); + return create(thd, udf, item_list); } -Item *create_func_aes_encrypt(Item* a, Item* b) + +Item* +Create_udf_func::create(THD *thd, udf_func *udf, List *item_list) { - return new Item_func_aes_encrypt(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_sp_func::create(THD *thd, LEX_STRING db, LEX_STRING name, + List *item_list) +{ + 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_aes_decrypt(Item* a, Item* b) + +Item* +Create_func_arg0::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_aes_decrypt(a, b); + 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_ascii(Item* a) + +Item* +Create_func_arg1::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_ascii(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_ord(Item* a) + +Item* +Create_func_arg2::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_ord(a); + 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_asin(Item* a) + +Item* +Create_func_arg3::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_asin(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_bin(Item* a) + +Create_func_abs Create_func_abs::s_singleton; + +Item* +Create_func_abs::create(THD *thd, Item *arg1) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 2,1)); + return new (thd->mem_root) Item_func_abs(arg1); } -Item *create_func_bit_count(Item* a) + +Create_func_acos Create_func_acos::s_singleton; + +Item* +Create_func_acos::create(THD *thd, Item *arg1) { - return new Item_func_bit_count(a); + return new (thd->mem_root) Item_func_acos(arg1); } -Item *create_func_ceiling(Item* a) + +Create_func_addtime Create_func_addtime::s_singleton; + +Item* +Create_func_addtime::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_ceiling(a); + return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 0); } -Item *create_func_connection_id(void) + +Create_func_aes_encrypt Create_func_aes_encrypt::s_singleton; + +Item* +Create_func_aes_encrypt::create(THD *thd, Item *arg1, Item *arg2) { - current_thd->lex->safe_to_cache_query= 0; - return new Item_func_connection_id(); + return new (thd->mem_root) Item_func_aes_encrypt(arg1, arg2); } -Item *create_func_conv(Item* a, Item *b, Item *c) + +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_conv(a,b,c); + return new (thd->mem_root) Item_func_aes_decrypt(arg1, arg2); } -Item *create_func_cos(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_area Create_func_area::s_singleton; + +Item* +Create_func_area::create(THD *thd, Item *arg1) { - return new Item_func_cos(a); + return new (thd->mem_root) Item_func_area(arg1); +} +#endif + + +#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 (thd->mem_root) Item_func_as_wkb(arg1); +} +#endif + + +#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 (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); } -Item *create_func_cot(Item* a) + +Create_func_atan Create_func_atan::s_singleton; + +Item* +Create_func_atan::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_div(new Item_int((char*) "1",1,1), - new Item_func_tan(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_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_date_format(Item* a,Item *b) + +Create_func_benchmark Create_func_benchmark::s_singleton; + +Item* +Create_func_benchmark::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_date_format(a,b,0); + /* 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_dayofmonth(Item* a) + +Create_func_bin Create_func_bin::s_singleton; + +Item* +Create_func_bin::create(THD *thd, Item *arg1) { - return new Item_func_dayofmonth(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_dayofweek(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_weekday(a, 1); + return new (thd->mem_root) Item_func_bit_count(arg1); } -Item *create_func_dayofyear(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_dayofyear(a); + return new (thd->mem_root) Item_func_bit_length(arg1); } -Item *create_func_dayname(Item* a) + +Create_func_ceiling Create_func_ceiling::s_singleton; + +Item* +Create_func_ceiling::create(THD *thd, Item *arg1) { - return new Item_func_dayname(a); + return new (thd->mem_root) Item_func_ceiling(arg1); } -Item *create_func_degrees(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_units((char*) "degrees",a,180/M_PI,0.0); + return new (thd->mem_root) Item_func_centroid(arg1); +} +#endif + + +Create_func_char_length Create_func_char_length::s_singleton; + +Item* +Create_func_char_length::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_char_length(arg1); } -Item *create_func_exp(Item* a) + +Create_func_coercibility Create_func_coercibility::s_singleton; + +Item* +Create_func_coercibility::create(THD *thd, Item *arg1) { - return new Item_func_exp(a); + return new (thd->mem_root) Item_func_coercibility(arg1); } -Item *create_func_find_in_set(Item* a, Item *b) + +Create_func_concat Create_func_concat::s_singleton; + +Item* +Create_func_concat::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_func_find_in_set(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_floor(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_list) { - return new Item_func_floor(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_found_rows(void) + +Create_func_compress Create_func_compress::s_singleton; + +Item* +Create_func_compress::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_compress(arg1); +} + + +Create_func_connection_id Create_func_connection_id::s_singleton; + +Item* +Create_func_connection_id::create(THD *thd) { - THD *thd=current_thd; thd->lex->safe_to_cache_query= 0; - return new Item_func_found_rows(); -} - -Item *create_func_from_days(Item* a) -{ - return new Item_func_from_days(a); -} - -Item *create_func_get_lock(Item* a, Item *b) -{ - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_get_lock(a, b); -} - -Item *create_func_hex(Item *a) -{ - return new Item_func_hex(a); -} - -Item *create_func_inet_ntoa(Item* a) -{ - return new Item_func_inet_ntoa(a); -} - -Item *create_func_inet_aton(Item* a) -{ - return new Item_func_inet_aton(a); + 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 + + +Create_func_conv Create_func_conv::s_singleton; + +Item* +Create_func_conv::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new (thd->mem_root) Item_func_conv(arg1, arg2, arg3); } -Item *create_func_nullif(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_nullif(a,b); + 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_locate(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(b,a); + return new (thd->mem_root) Item_func_cos(arg1); } -Item *create_func_instr(Item* a, Item *b) + +Create_func_cot Create_func_cot::s_singleton; + +Item* +Create_func_cot::create(THD *thd, Item *arg1) { - return new Item_func_locate(a,b); + 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_isnull(Item* a) + +Create_func_crc32 Create_func_crc32::s_singleton; + +Item* +Create_func_crc32::create(THD *thd, Item *arg1) { - return new Item_func_isnull(a); + return new (thd->mem_root) Item_func_crc32(arg1); } -Item *create_func_lcase(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_lcase(a); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_CROSSES_FUNC); +} +#endif + + +Create_func_date_format Create_func_date_format::s_singleton; + +Item* +Create_func_date_format::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_date_format(arg1, arg2, 0); } -Item *create_func_length(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_length(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_bit_length(Item* a) + +Create_func_dayname Create_func_dayname::s_singleton; + +Item* +Create_func_dayname::create(THD *thd, Item *arg1) { - return new Item_func_bit_length(a); + return new (thd->mem_root) Item_func_dayname(arg1); } -Item *create_func_coercibility(Item* a) + +Create_func_dayofmonth Create_func_dayofmonth::s_singleton; + +Item* +Create_func_dayofmonth::create(THD *thd, Item *arg1) { - return new Item_func_coercibility(a); + return new (thd->mem_root) Item_func_dayofmonth(arg1); } -Item *create_func_char_length(Item* a) + +Create_func_dayofweek Create_func_dayofweek::s_singleton; + +Item* +Create_func_dayofweek::create(THD *thd, Item *arg1) { - return new Item_func_char_length(a); + return new (thd->mem_root) Item_func_weekday(arg1, 1); } -Item *create_func_ln(Item* a) + +Create_func_dayofyear Create_func_dayofyear::s_singleton; + +Item* +Create_func_dayofyear::create(THD *thd, Item *arg1) { - return new Item_func_ln(a); + return new (thd->mem_root) Item_func_dayofyear(arg1); } -Item *create_func_log2(Item* a) + +Create_func_decode Create_func_decode::s_singleton; + +Item* +Create_func_decode::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_log2(a); + /* 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_log10(Item* a) + +Create_func_degrees Create_func_degrees::s_singleton; + +Item* +Create_func_degrees::create(THD *thd, Item *arg1) { - return new Item_func_log10(a); + return new (thd->mem_root) Item_func_units((char*) "degrees", arg1, + 180/M_PI, 0.0); } -Item *create_func_lpad(Item* a, Item *b, Item *c) + +Create_func_des_decrypt Create_func_des_decrypt::s_singleton; + +Item* +Create_func_des_decrypt::create(THD *thd, LEX_STRING name, + List *item_list) { - return new Item_func_lpad(a,b,c); + 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_ltrim(Item* a) + +Create_func_des_encrypt Create_func_des_encrypt::s_singleton; + +Item* +Create_func_des_encrypt::create(THD *thd, LEX_STRING name, + List *item_list) { - return new Item_func_ltrim(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_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_md5(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_dimension Create_func_dimension::s_singleton; + +Item* +Create_func_dimension::create(THD *thd, Item *arg1) { - return new Item_func_md5(a); + return new (thd->mem_root) Item_func_dimension(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_disjoint Create_func_disjoint::s_singleton; + +Item* +Create_func_disjoint::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_DISJOINT_FUNC); +} +#endif + + +Create_func_elt Create_func_elt::s_singleton; + +Item* +Create_func_elt::create(THD *thd, LEX_STRING name, List *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_elt(*item_list); } -Item *create_func_mod(Item* a, Item *b) + +Create_func_encode Create_func_encode::s_singleton; + +Item* +Create_func_encode::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_mod(a,b); + /* 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_name_const(Item *a, Item *b) + +Create_func_encrypt Create_func_encrypt::s_singleton; + +Item* +Create_func_encrypt::create(THD *thd, LEX_STRING name, List *item_list) { - return new Item_name_const(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_monthname(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_endpoint Create_func_endpoint::s_singleton; + +Item* +Create_func_endpoint::create(THD *thd, Item *arg1) { - return new Item_func_monthname(a); + 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_envelope::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_envelope(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_equals Create_func_equals::s_singleton; + +Item* +Create_func_equals::create(THD *thd, Item *arg1, Item *arg2) +{ + 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_exp::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_exp(arg1); } -Item *create_func_month(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_list) { - return new Item_func_month(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_oct(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_exteriorring Create_func_exteriorring::s_singleton; + +Item* +Create_func_exteriorring::create(THD *thd, Item *arg1) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 8,1)); + return new (thd->mem_root) Item_func_spatial_decomp(arg1, + Item_func::SP_EXTERIORRING); +} +#endif + + +Create_func_field Create_func_field::s_singleton; + +Item* +Create_func_field::create(THD *thd, LEX_STRING name, List *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_field(*item_list); } -Item *create_func_period_add(Item* a, Item *b) + +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_period_add(a,b); + return new (thd->mem_root) Item_func_find_in_set(arg1, arg2); } -Item *create_func_period_diff(Item* a, Item *b) + +Create_func_floor Create_func_floor::s_singleton; + +Item* +Create_func_floor::create(THD *thd, Item *arg1) { - return new Item_func_period_diff(a,b); + return new (thd->mem_root) Item_func_floor(arg1); } -Item *create_func_pi(void) + +Create_func_format Create_func_format::s_singleton; + +Item* +Create_func_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_static_float_func("pi()", M_PI, 6, 8); + /* 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_pow(Item* a, Item *b) + +Create_func_found_rows Create_func_found_rows::s_singleton; + +Item* +Create_func_found_rows::create(THD *thd) { - return new Item_func_pow(a,b); + thd->lex->safe_to_cache_query= 0; + return new (thd->mem_root) Item_func_found_rows(); } -Item *create_func_radians(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_units((char*) "radians",a,M_PI/180,0.0); + return new (thd->mem_root) Item_func_from_days(arg1); } -Item *create_func_release_lock(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_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 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_repeat(Item* a, Item *b) + +#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_list) { - return new Item_func_repeat(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_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_geometry_from_wkb::create(THD *thd, LEX_STRING name, + List *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_geometry_from_wkb(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_wkb(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_type Create_func_geometry_type::s_singleton; + +Item* +Create_func_geometry_type::create(THD *thd, Item *arg1) +{ + 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_geometryn::create(THD *thd, Item *arg1, Item *arg2) +{ + 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_get_lock::create(THD *thd, Item *arg1, Item *arg2) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_get_lock(arg1, arg2); } -Item *create_func_reverse(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_reverse(a); + return new (thd->mem_root) Item_func_glength(arg1); +} +#endif + + +Create_func_greatest Create_func_greatest::s_singleton; + +Item* +Create_func_greatest::create(THD *thd, LEX_STRING name, List *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_max(*item_list); } -Item *create_func_rpad(Item* a, Item *b, Item *c) + +Create_func_hex Create_func_hex::s_singleton; + +Item* +Create_func_hex::create(THD *thd, Item *arg1) { - return new Item_func_rpad(a,b,c); + return new (thd->mem_root) Item_func_hex(arg1); } -Item *create_func_rtrim(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_rtrim(a); + return new (thd->mem_root) Item_func_ifnull(arg1, arg2); } -Item *create_func_sec_to_time(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_sec_to_time(a); + return new (thd->mem_root) Item_func_inet_ntoa(arg1); } -Item *create_func_sign(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_sign(a); + return new (thd->mem_root) Item_func_inet_aton(arg1); } -Item *create_func_sin(Item* a) + +Create_func_instr Create_func_instr::s_singleton; + +Item* +Create_func_instr::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sin(a); + return new (thd->mem_root) Item_func_locate(arg1, arg2); } -Item *create_func_sha(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_interiorringn Create_func_interiorringn::s_singleton; + +Item* +Create_func_interiorringn::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sha(a); + return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2, + Item_func::SP_INTERIORRINGN); +} +#endif + + +#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_is_free_lock::create(THD *thd, Item *arg1) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_is_free_lock(arg1); } -Item *create_func_sleep(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) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_sleep(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_is_used_lock(arg1); } -Item *create_func_space(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_isclosed Create_func_isclosed::s_singleton; + +Item* +Create_func_isclosed::create(THD *thd, Item *arg1) { - CHARSET_INFO *cs= current_thd->variables.collation_connection; + return new (thd->mem_root) Item_func_isclosed(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_isempty Create_func_isempty::s_singleton; + +Item* +Create_func_isempty::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_isempty(arg1); +} +#endif + + +Create_func_isnull Create_func_isnull::s_singleton; + +Item* +Create_func_isnull::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_isnull(arg1); +} + + +#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_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 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: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + 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_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_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_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_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); +} + + +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_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(); + 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; +} + + +Create_func_md5 Create_func_md5::s_singleton; + +Item* +Create_func_md5::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_md5(arg1); +} + + +Create_func_monthname Create_func_monthname::s_singleton; + +Item* +Create_func_monthname::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_monthname(arg1); +} + + +Create_func_name_const Create_func_name_const::s_singleton; + +Item* +Create_func_name_const::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_name_const(arg1, arg2); +} + + +Create_func_nullif Create_func_nullif::s_singleton; + +Item* +Create_func_nullif::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_nullif(arg1, arg2); +} + + +#ifdef HAVE_SPATIAL +Create_func_numgeometries Create_func_numgeometries::s_singleton; + +Item* +Create_func_numgeometries::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_numgeometries(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_numinteriorring Create_func_numinteriorring::s_singleton; + +Item* +Create_func_numinteriorring::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_numinteriorring(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_numpoints Create_func_numpoints::s_singleton; + +Item* +Create_func_numpoints::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_numpoints(arg1); +} +#endif + + +Create_func_oct Create_func_oct::s_singleton; + +Item* +Create_func_oct::create(THD *thd, Item *arg1) +{ + 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); +} + + +Create_func_ord Create_func_ord::s_singleton; + +Item* +Create_func_ord::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_ord(arg1); +} + + +#ifdef HAVE_SPATIAL +Create_func_overlaps Create_func_overlaps::s_singleton; + +Item* +Create_func_overlaps::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_OVERLAPS_FUNC); +} +#endif + + +Create_func_period_add Create_func_period_add::s_singleton; + +Item* +Create_func_period_add::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_period_add(arg1, arg2); +} + + +Create_func_period_diff Create_func_period_diff::s_singleton; + +Item* +Create_func_period_diff::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_period_diff(arg1, arg2); +} + + +Create_func_pi Create_func_pi::s_singleton; + +Item* +Create_func_pi::create(THD *thd) +{ + return new (thd->mem_root) Item_static_float_func("pi()", M_PI, 6, 8); +} + + +#ifdef HAVE_SPATIAL +Create_func_pointn Create_func_pointn::s_singleton; + +Item* +Create_func_pointn::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2, + Item_func::SP_POINTN); +} +#endif + + +Create_func_pow Create_func_pow::s_singleton; + +Item* +Create_func_pow::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_pow(arg1, arg2); +} + + +Create_func_quote Create_func_quote::s_singleton; + +Item* +Create_func_quote::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_quote(arg1); +} + + +Create_func_radians Create_func_radians::s_singleton; + +Item* +Create_func_radians::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_units((char*) "radians", arg1, + M_PI/180, 0.0); +} + + +Create_func_rand Create_func_rand::s_singleton; + +Item* +Create_func_rand::create(THD *thd, LEX_STRING name, List *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_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; +} + + +Create_func_release_lock Create_func_release_lock::s_singleton; + +Item* +Create_func_release_lock::create(THD *thd, Item *arg1) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_release_lock(arg1); +} + + +Create_func_reverse Create_func_reverse::s_singleton; + +Item* +Create_func_reverse::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_reverse(arg1); +} + + +Create_func_round Create_func_round::s_singleton; + +Item* +Create_func_round::create(THD *thd, LEX_STRING name, List *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_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; +} + + +Create_func_row_count Create_func_row_count::s_singleton; + +Item* +Create_func_row_count::create(THD *thd) +{ + thd->lex->safe_to_cache_query= 0; + return new (thd->mem_root) Item_func_row_count(); +} + + +Create_func_rpad Create_func_rpad::s_singleton; + +Item* +Create_func_rpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new (thd->mem_root) Item_func_rpad(arg1, arg2, arg3); +} + + +Create_func_rtrim Create_func_rtrim::s_singleton; + +Item* +Create_func_rtrim::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_rtrim(arg1); +} + + +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 (thd->mem_root) Item_func_sec_to_time(arg1); +} + + +Create_func_sha Create_func_sha::s_singleton; + +Item* +Create_func_sha::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_sha(arg1); +} + + +Create_func_sign Create_func_sign::s_singleton; + +Item* +Create_func_sign::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_sign(arg1); +} + + +Create_func_sin Create_func_sin::s_singleton; + +Item* +Create_func_sin::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_sin(arg1); +} + + +Create_func_sleep Create_func_sleep::s_singleton; + +Item* +Create_func_sleep::create(THD *thd, Item *arg1) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_sleep(arg1); +} + + +Create_func_soundex Create_func_soundex::s_singleton; + +Item* +Create_func_soundex::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_soundex(arg1); +} + + +Create_func_space Create_func_space::s_singleton; + +Item* +Create_func_space::create(THD *thd, Item *arg1) +{ + /** + TODO: Fix Bug#23637 + The parsed item tree should not depend on + thd->variables.collation_connection. + */ + CHARSET_INFO *cs= thd->variables.collation_connection; Item *sp; if (cs->mbminlen > 1) { uint dummy_errors; - sp= new Item_string("",0,cs); - if (sp) - sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &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 Item_string(" ",1,cs); + sp= new (thd->mem_root) Item_string(" ", 1, cs); } - return sp ? new Item_func_repeat(sp, a) : 0; + + return new (thd->mem_root) Item_func_repeat(sp, arg1); } -Item *create_func_soundex(Item* a) + +Create_func_sqrt Create_func_sqrt::s_singleton; + +Item* +Create_func_sqrt::create(THD *thd, Item *arg1) { - return new Item_func_soundex(a); + return new (thd->mem_root) Item_func_sqrt(arg1); } -Item *create_func_sqrt(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_sqrt(a); + return new (thd->mem_root) Item_func_srid(arg1); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_startpoint Create_func_startpoint::s_singleton; + +Item* +Create_func_startpoint::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_spatial_decomp(arg1, + Item_func::SP_STARTPOINT); +} +#endif + + +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 (thd->mem_root) Item_func_str_to_date(arg1, arg2); } -Item *create_func_strcmp(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_strcmp(a,b); + return new (thd->mem_root) Item_func_strcmp(arg1, arg2); } -Item *create_func_tan(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_tan(a); + return new (thd->mem_root) Item_func_substr_index(arg1, arg2, arg3); } -Item *create_func_time_format(Item *a, Item *b) + +Create_func_subtime Create_func_subtime::s_singleton; + +Item* +Create_func_subtime::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_date_format(a,b,1); + return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 1); } -Item *create_func_time_to_sec(Item* a) + +Create_func_tan Create_func_tan::s_singleton; + +Item* +Create_func_tan::create(THD *thd, Item *arg1) { - return new Item_func_time_to_sec(a); + return new (thd->mem_root) Item_func_tan(arg1); } -Item *create_func_to_days(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_to_days(a); + return new (thd->mem_root) Item_func_date_format(arg1, arg2, 1); } -Item *create_func_ucase(Item* a) + +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_ucase(a); + return new (thd->mem_root) Item_func_time_to_sec(arg1); } -Item *create_func_unhex(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_unhex(a); + return new (thd->mem_root) Item_func_timediff(arg1, arg2); } -Item *create_func_uuid(void) + +Create_func_to_days Create_func_to_days::s_singleton; + +Item* +Create_func_to_days::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_to_days(arg1); +} + + +#ifdef HAVE_SPATIAL +Create_func_touches Create_func_touches::s_singleton; + +Item* +Create_func_touches::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_TOUCHES_FUNC); +} +#endif + + +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_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) { - THD *thd= current_thd; #ifdef HAVE_ROW_BASED_REPLICATION thd->lex->binlog_row_based_if_mixed= TRUE; #endif - return new(thd->mem_root) Item_func_uuid(); + return new (thd->mem_root) Item_func_uuid(); } -Item *create_func_version(void) + +Create_func_version Create_func_version::s_singleton; + +Item* +Create_func_version::create(THD *thd) { - return new Item_static_string_func("version()", server_version, - (uint) strlen(server_version), - system_charset_info, DERIVATION_SYSCONST); + return new (thd->mem_root) Item_static_string_func("version()", + server_version, + (uint) strlen(server_version), + system_charset_info, + DERIVATION_SYSCONST); } -Item *create_func_weekday(Item* a) + +Create_func_weekday Create_func_weekday::s_singleton; + +Item* +Create_func_weekday::create(THD *thd, Item *arg1) { - return new Item_func_weekday(a, 0); + return new (thd->mem_root) Item_func_weekday(arg1, 0); } -Item *create_func_year(Item* a) + +Create_func_weekofyear Create_func_weekofyear::s_singleton; + +Item* +Create_func_weekofyear::create(THD *thd, Item *arg1) { - return new Item_func_year(a); + Item *i1= new (thd->mem_root) Item_int((char*) "0", 3, 1); + return new (thd->mem_root) Item_func_week(arg1, i1); } -Item *create_load_file(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_within Create_func_within::s_singleton; + +Item* +Create_func_within::create(THD *thd, Item *arg1, Item *arg2) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_load_file(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); } -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs) +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_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; - int tmp_len; LINT_INIT(res); 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_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: - tmp_len= (len>0) ? len : 10; + { + int 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); + res= new (thd->mem_root) Item_decimal_typecast(a, tmp_len, dec); break; + } case ITEM_CAST_CHAR: - res= new Item_char_typecast(a, len, cs ? cs : - current_thd->variables.collation_connection); + { + 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; } -Item *create_func_is_free_lock(Item* a) -{ - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_free_lock(a); -} - -Item *create_func_is_used_lock(Item* a) -{ - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_used_lock(a); -} - -Item *create_func_quote(Item* a) -{ - return new Item_func_quote(a); -} - -Item *create_func_xml_extractvalue(Item *a, Item *b) -{ - return new Item_func_xml_extractvalue(a, b); -} - -Item *create_func_xml_update(Item *a, Item *b, Item *c) -{ - return new Item_func_xml_update(a, b, c); -} - -#ifdef HAVE_SPATIAL -Item *create_func_as_wkt(Item *a) -{ - return new Item_func_as_wkt(a); -} - -Item *create_func_as_wkb(Item *a) -{ - return new Item_func_as_wkb(a); -} - -Item *create_func_srid(Item *a) -{ - return new Item_func_srid(a); -} - -Item *create_func_startpoint(Item *a) -{ - return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT); -} - -Item *create_func_endpoint(Item *a) -{ - return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT); -} - -Item *create_func_exteriorring(Item *a) -{ - return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING); -} - -Item *create_func_pointn(Item *a, Item *b) -{ - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN); -} - -Item *create_func_interiorringn(Item *a, Item *b) -{ - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN); -} - -Item *create_func_geometryn(Item *a, Item *b) -{ - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN); -} - -Item *create_func_centroid(Item *a) -{ - return new Item_func_centroid(a); -} - -Item *create_func_envelope(Item *a) -{ - return new Item_func_envelope(a); -} - -Item *create_func_equals(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC); -} - -Item *create_func_disjoint(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC); -} - -Item *create_func_intersects(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC); -} - -Item *create_func_touches(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC); -} - -Item *create_func_crosses(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC); -} - -Item *create_func_within(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC); -} - -Item *create_func_contains(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC); -} - -Item *create_func_overlaps(Item *a, Item *b) -{ - return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC); -} - -Item *create_func_isempty(Item *a) -{ - return new Item_func_isempty(a); -} - -Item *create_func_issimple(Item *a) -{ - return new Item_func_issimple(a); -} - -Item *create_func_isclosed(Item *a) -{ - return new Item_func_isclosed(a); -} - -Item *create_func_geometry_type(Item *a) -{ - return new Item_func_geometry_type(a); -} - -Item *create_func_dimension(Item *a) -{ - return new Item_func_dimension(a); -} - -Item *create_func_x(Item *a) -{ - return new Item_func_x(a); -} - -Item *create_func_y(Item *a) -{ - return new Item_func_y(a); -} - -Item *create_func_numpoints(Item *a) -{ - return new Item_func_numpoints(a); -} - -Item *create_func_numinteriorring(Item *a) -{ - return new Item_func_numinteriorring(a); -} - -Item *create_func_numgeometries(Item *a) -{ - return new Item_func_numgeometries(a); -} - -Item *create_func_area(Item *a) -{ - return new Item_func_area(a); -} - -Item *create_func_glength(Item *a) -{ - return new Item_func_glength(a); -} - -Item *create_func_point(Item *a, Item *b) -{ - return new Item_func_point(a, b); -} -#endif /*HAVE_SPATIAL*/ - -Item *create_func_crc32(Item* a) -{ - return new Item_func_crc32(a); -} - -Item *create_func_compress(Item* a) -{ - return new Item_func_compress(a); -} - -Item *create_func_uncompress(Item* a) -{ - return new Item_func_uncompress(a); -} - -Item *create_func_uncompressed_length(Item* a) -{ - return new Item_func_uncompressed_length(a); -} - -Item *create_func_datediff(Item *a, Item *b) -{ - return new Item_func_minus(new Item_func_to_days(a), - new Item_func_to_days(b)); -} - -Item *create_func_weekofyear(Item *a) -{ - return new Item_func_week(a, new Item_int((char*) "0", 3, 1)); -} - -Item *create_func_makedate(Item* a,Item* b) -{ - return new Item_func_makedate(a, b); -} - -Item *create_func_addtime(Item* a,Item* b) -{ - return new Item_func_add_time(a, b, 0, 0); -} - -Item *create_func_subtime(Item* a,Item* b) -{ - return new Item_func_add_time(a, b, 0, 1); -} - -Item *create_func_timediff(Item* a,Item* b) -{ - return new Item_func_timediff(a, b); -} - -Item *create_func_maketime(Item* a,Item* b,Item* c) -{ - return new Item_func_maketime(a, b, c); -} - -Item *create_func_str_to_date(Item* a,Item* b) -{ - return new Item_func_str_to_date(a, b); -} - -Item *create_func_last_day(Item *a) -{ - return new Item_func_last_day(a); -} 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 */ +/* Functions to create an item. Used by sql/sql_yacc.yy */ -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); +#ifndef ITEM_CREATE_H +#define ITEM_CREATE_H -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 +/** + Public function builder interface. + The parser (sql/sql_yacc.yy) uses a factory / builder pattern to + construct an Item 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. +*/ -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); +class Create_func +{ +public: + /** + The builder create method. + Given the function name and list or arguments, this method creates + an Item that represents the function call. + In case or errors, a NULL item is returned, and an error is reported. + Note that the thd 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. +
    +
  • thd->lex->binlog_row_based_if_mixed
    • +
  • thd->lex->current_context()
    • +
  • thd->lex->safe_to_cache_query
    • +
  • thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT)
    • +
  • thd->lex->uncacheable(UNCACHEABLE_RAND)
    • +
  • thd->lex->add_time_zone_tables_to_query_tables(thd)
    • +
+ @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_list) = 0; -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); +protected: + /** Constructor */ + Create_func() {} + /** Destructor */ + virtual ~Create_func() {} +}; -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); +/** + Function builder for qualified functions. + This builder is used with functions call using a qualified function name + syntax, as in db.func(expr, expr, ...). +*/ -Item *create_func_numpoints(Item *a); -Item *create_func_numinteriorring(Item *a); -Item *create_func_numgeometries(Item *a); +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_list); -Item *create_func_point(Item *a, Item *b); + /** + 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_list) = 0; -#endif /*HAVE_SPATIAL*/ +protected: + /** Constructor. */ + Create_qfunc() {} + /** Destructor. */ + virtual ~Create_qfunc() {} +}; -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); +/** + 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_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_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 -%token ABORT_SYM + This makes the code grep-able, and helps maintenance. +*/ + +%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 NUM_literal @@ -810,6 +798,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); %type expr_list udf_expr_list udf_expr_list2 when_list ident_list ident_list_arg + expr_list_opt %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_func_type -%type FUNC_ARG0 FUNC_ARG1 FUNC_ARG2 FUNC_ARG3 keyword keyword_sp +%type keyword keyword_sp %type 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,170 +6027,15 @@ 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 ')' - { - 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)) - 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 Item_func_curtime_local($3); - Lex->safe_to_cache_query=0; - } - | CURRENT_USER optional_braces - { - $$= new 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); } - | 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); } - | HOUR_SYM '(' expr ')' - { $$= new Item_func_hour($3); } - | IF '(' expr ',' expr ',' expr ')' - { $$= new Item_func_if($3,$5,$7); } - | INSERT '(' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_insert($3,$5,$7,$9); } + { $$= new (YYTHD->mem_root) Item_insert_value(Lex->current_context(), + $3); } | interval_expr interval '+' expr /* we cannot put interval before - */ - { $$= new Item_date_add_interval($4,$1,$2,0); } + { $$= new (YYTHD->mem_root) Item_date_add_interval($4,$1,$2,0); } | interval_expr { if ($1->type() != Item::ROW_ITEM) @@ -6198,374 +6043,416 @@ simple_expr: yyerror(ER(ER_SYNTAX_ERROR)); YYABORT; } - $$= new Item_func_interval((Item_row *)$1); - } - | LAST_INSERT_ID '(' ')' - { - $$= new Item_func_last_insert_id(); - Lex->safe_to_cache_query= 0; - } - | LAST_INSERT_ID '(' expr ')' - { - $$= 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 Item_master_pos_wait($3, $5, $7); - 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); } - | NOW_SYM optional_braces - { $$= new 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); } - | 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; - } - | SUBDATE_SYM '(' expr ',' expr ')' - { $$= new 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); } - | SUBSTRING '(' expr ',' expr ',' expr ')' - { $$= new Item_func_substr($3,$5,$7); } - | SUBSTRING '(' expr ',' expr ')' - { $$= new Item_func_substr($3,$5); } - | SUBSTRING '(' expr FROM expr FOR_SYM expr ')' - { $$= new 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); } - | SYSDATE optional_braces - { - if (global_system_variables.sysdate_is_now == 0) - $$= new Item_func_sysdate_local(); - else $$= new 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); - 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); } - | 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 ')' - { - LEX *lex= Lex; - sp_name *name= new sp_name($1, $3); - - 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; - } - | IDENT_sys '(' - { -#ifdef HAVE_DLOPEN - 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()) - { - yyerror(ER(ER_SYNTAX_ERROR)); - YYABORT; - } - } - $$= udf; -#endif - } - udf_expr_list ')' - { -#ifdef HAVE_DLOPEN - udf_func *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; - } - } - else -#endif /* HAVE_DLOPEN */ - { - 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; - } + $$= new (YYTHD->mem_root) Item_func_interval((Item_row *)$1); } | UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')' { $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9); } - | UNIX_TIMESTAMP '(' ')' + ; + +/* + 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 (YYTHD->mem_root) Item_func_current_user(Lex->current_context()); + Lex->safe_to_cache_query= 0; + } + | DATE_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_date_typecast($3); } + | DAY_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_dayofmonth($3); } + | HOUR_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_hour($3); } + | INSERT '(' expr ',' expr ',' expr ',' 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 '(' ')' { - $$= new Item_func_unix_timestamp(); + $$= new (YYTHD->mem_root) Item_func_user(); + Lex->safe_to_cache_query=0; + } + | 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 (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 (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 (YYTHD->mem_root) Item_func_curtime_local($3); 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; } + | 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 (YYTHD->mem_root) Item_func_now_local(); + Lex->safe_to_cache_query=0; + } + | NOW_SYM '(' expr ')' + { + $$= new (YYTHD->mem_root) Item_func_now_local($3); + Lex->safe_to_cache_query=0; + } + | POSITION_SYM '(' bit_expr IN_SYM expr ')' + { $$ = new (YYTHD->mem_root) Item_func_locate($5,$3); } + | SUBDATE_SYM '(' expr ',' expr ')' + { + $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5, + INTERVAL_DAY, 1); + } + | SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')' + { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 1); } + | SUBSTRING '(' expr ',' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); } + | SUBSTRING '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); } + | SUBSTRING '(' expr FROM expr FOR_SYM expr ')' + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); } + | SUBSTRING '(' expr FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); } + | SYSDATE optional_braces + { + if (global_system_variables.sysdate_is_now == 0) + $$= 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 (YYTHD->mem_root) Item_func_sysdate_local($3); + else + $$= new (YYTHD->mem_root) Item_func_now_local($3); + Lex->safe_to_cache_query=0; + } + | TIMESTAMP_ADD '(' interval_time_st ',' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_date_add_interval($7,$5,$3,0); } + | TIMESTAMP_DIFF '(' interval_time_st ',' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_timestamp_diff($5,$7,$3); } | UTC_DATE_SYM optional_braces - { $$= new Item_func_curdate_utc(); Lex->safe_to_cache_query=0;} + { + $$= new (YYTHD->mem_root) 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;} + { + $$= new (YYTHD->mem_root) 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;} + { + $$= new (YYTHD->mem_root) Item_func_now_utc(); + 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; + } + | 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 ')' { - $$= new Item_func_week($3,new Item_int((char*) "0", - YYTHD->variables.default_week_format,1)); + 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 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); }; + { $$= 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(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)); } + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_rel($3, $5, + Item_func::SP_CONTAINS_FUNC)); + } | GEOMETRYCOLLECTION '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, Geometry::wkb_geometrycollection, - Geometry::wkb_point)); } + Geometry::wkb_point)); + } | LINESTRING '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_linestring, Geometry::wkb_point)); } + { + $$= GEOM_NEW(YYTHD, + 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)); } + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_multilinestring, + Geometry::wkb_linestring)); + } | MULTIPOINT '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_multipoint, Geometry::wkb_point)); } + { + $$= GEOM_NEW(YYTHD, + 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)); } + { + $$= GEOM_NEW(YYTHD, + 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)); } + { $$= GEOM_NEW(YYTHD, Item_func_point($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)); } - ; + { + $$= 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) + { + LEX *lex= Lex; + if (lex->current_select->inc_in_sum_expr()) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + } + /* Temporary placing the result of find_udf in $3 */ + $$= 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 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); + } + else + { +#ifdef HAVE_DLOPEN + /* Retrieving the result of find_udf */ + udf_func *udf= $3; + + if (udf) + { + if (udf->type == UDFTYPE_AGGREGATE) + { + Select->in_sum_expr--; + } + + item= Create_udf_func::s_singleton.create(thd, udf, $4); + } + else +#endif + { + builder= find_qualified_function_builder(thd); + DBUG_ASSERT(builder); + item= builder->create(thd, $1, $4); + } + } + + if (! ($$= item)) + { + YYABORT; + } + } + | ident '.' ident '(' udf_expr_list ')' + { + THD *thd= YYTHD; + Create_qfunc *builder; + Item *item= NULL; + + /* + The following in practice calls: + Create_sp_func::create() + 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); } 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\"");