| List: | Commits | « Previous MessageNext Message » | |
| From: | marc.alff | Date: | October 27 2006 11:45pm |
| Subject: | bk commit into 5.1 tree (malff:1.2328) BUG#21114 | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1 repository of marcsql. When marcsql does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet@stripped, 2006-10-27 14:44:57-07:00, malff@weblab.(none) +19 -0 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 second iteration, it takes into account the comments received to date. mysql-test/include/parser_stress_func.inc@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +59 -0 New tests mysql-test/include/parser_stress_func.inc@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +0 -0 mysql-test/r/func_math.result@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +12 -0 Improved test coverage mysql-test/r/parser.result@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +112 -0 New tests mysql-test/r/parser.result@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +0 -0 mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +867 -0 New tests mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +0 -0 mysql-test/r/view.result@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +4 -4 Name collision, x() is a geometry native in function mysql-test/t/func_math.test@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +5 -0 Improved test coverage mysql-test/t/parser.test@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +146 -0 New tests mysql-test/t/parser.test@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +0 -0 mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +422 -0 New tests mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +0 -0 mysql-test/t/view.test@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +3 -3 Name collision, x() is a geometry native in function sql/item_create.cc@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +4524 -319 Revised the create_func implementation sql/item_create.h@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +147 -144 Revised the create_func implementation sql/item_geofunc.h@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +2 -2 Explicit Item allocation in the thread memory pool. sql/lex.h@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +5 -211 Removed function parsing from the lexical parser sql/lex_symbol.h@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +0 -1 Removed function parsing from the lexical parser sql/mysql_priv.h@stripped, 2006-10-27 14:44:52-07:00, malff@weblab.(none) +4 -0 Server initialization and shutdown sql/mysqld.cc@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +3 -0 Server initialization and shutdown sql/share/errmsg.txt@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +4 -0 New error messages sql/sql_yacc.yy@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +674 -780 Removed function parsing from the lexical parser tests/mysql_client_test.c@stripped, 2006-10-27 14:44:53-07:00, malff@weblab.(none) +1 -1 Spaces are no longer significant for function calls # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: malff # Host: weblab.(none) # Root: /home/marcsql/TREE/mysql-5.1-21114_b --- 1.66/sql/item_create.cc 2006-10-27 14:45:04 -07:00 +++ 1.67/sql/item_create.cc 2006-10-27 14:45:04 -07:00 @@ -14,728 +14,4933 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* Functions to create an item. Used by lex.h */ +/* Functions to create an item. Used by sql_yacc.yy */ #include "mysql_priv.h" +#include "item_create.h" +#include "sp_head.h" +#include "sp.h" + +/* +============================================================================= + LOCAL DECLARATIONS +============================================================================= +*/ + +/** + Adapter for functions that takes exactly zero arguments. +*/ +class Create_func_arg0 : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + Builder method, with no arguments. + @param thd The current thread + @return An item representing the function call + */ + virtual Item* create(THD *thd) = 0; + +protected: + /** Constructor. */ + Create_func_arg0() {} + /** Destructor. */ + virtual ~Create_func_arg0() {} +}; + + +/** + Adapter for functions that takes exactly one argument. +*/ +class Create_func_arg1 : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + Builder method, with one argument. + @param thd The current thread + @param arg1 The first argument of the function + @return An item representing the function call + */ + virtual Item* create(THD *thd, Item *arg1) = 0; + +protected: + /** Constructor. */ + Create_func_arg1() {} + /** Destructor. */ + virtual ~Create_func_arg1() {} +}; + + +/** + Adapter for functions that takes exactly two arguments. +*/ +class Create_func_arg2 : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + Builder method, with two arguments. + @param thd The current thread + @param arg1 The first argument of the function + @param arg2 The second argument of the function + @return An item representing the function call + */ + virtual Item* create(THD *thd, Item *arg1, Item *arg2) = 0; + +protected: + /** Constructor. */ + Create_func_arg2() {} + /** Destructor. */ + virtual ~Create_func_arg2() {} +}; + + +/** + Adapter for functions that takes exactly three arguments. +*/ +class Create_func_arg3 : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + Builder method, with three arguments. + @param thd The current thread + @param arg1 The first argument of the function + @param arg2 The second argument of the function + @param arg3 The third argument of the function + @return An item representing the function call + */ + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3) = 0; + +protected: + /** Constructor. */ + Create_func_arg3() {} + /** Destructor. */ + virtual ~Create_func_arg3() {} +}; + + +/** + Function builder for Stored Functions. +*/ +class Create_sp_func : public Create_qfunc +{ +public: + virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list); + + static Create_sp_func s_singleton; + +protected: + /** Constructor. */ + Create_sp_func() {} + /** Destructor. */ + virtual ~Create_sp_func() {} +}; + + +#ifndef HAVE_SPATIAL +/** + Common (non) builder for geometry functions. + This builder is used in <code>--without-geometry</code> builds only, + to report an error. +*/ +class Create_func_no_geom : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** Singleton. */ + static Create_func_no_geom s_singleton; + +protected: + /** Constructor. */ + Create_func_no_geom() {} + /** Destructor. */ + virtual ~Create_func_no_geom() {} +}; +#endif + + +/* Concrete functions builders (native functions) */ + +class Create_func_abs : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_abs s_singleton; + +protected: + Create_func_abs() {} + virtual ~Create_func_abs() {} +}; + + +class Create_func_acos : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_acos s_singleton; + +protected: + Create_func_acos() {} + virtual ~Create_func_acos() {} +}; + + +class Create_func_addtime : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_addtime s_singleton; + +protected: + Create_func_addtime() {} + virtual ~Create_func_addtime() {} +}; + + +class Create_func_aes_encrypt : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_aes_encrypt s_singleton; + +protected: + Create_func_aes_encrypt() {} + virtual ~Create_func_aes_encrypt() {} +}; + + +class Create_func_aes_decrypt : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_aes_decrypt s_singleton; + +protected: + Create_func_aes_decrypt() {} + virtual ~Create_func_aes_decrypt() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_area : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_area s_singleton; + +protected: + Create_func_area() {} + virtual ~Create_func_area() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_as_wkb : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_as_wkb s_singleton; + +protected: + Create_func_as_wkb() {} + virtual ~Create_func_as_wkb() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_as_wkt : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_as_wkt s_singleton; + +protected: + Create_func_as_wkt() {} + virtual ~Create_func_as_wkt() {} +}; +#endif + + +class Create_func_asin : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_asin s_singleton; + +protected: + Create_func_asin() {} + virtual ~Create_func_asin() {} +}; + + +class Create_func_atan : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_atan s_singleton; + +protected: + Create_func_atan() {} + virtual ~Create_func_atan() {} +}; + + +class Create_func_benchmark : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_benchmark s_singleton; + +protected: + Create_func_benchmark() {} + virtual ~Create_func_benchmark() {} +}; + + +class Create_func_bin : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_bin s_singleton; + +protected: + Create_func_bin() {} + virtual ~Create_func_bin() {} +}; + + +class Create_func_bit_count : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_bit_count s_singleton; + +protected: + Create_func_bit_count() {} + virtual ~Create_func_bit_count() {} +}; + + +class Create_func_bit_length : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_bit_length s_singleton; + +protected: + Create_func_bit_length() {} + virtual ~Create_func_bit_length() {} +}; + + +class Create_func_ceiling : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg); + + static Create_func_ceiling s_singleton; + +protected: + Create_func_ceiling() {} + virtual ~Create_func_ceiling() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_centroid : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_centroid s_singleton; + +protected: + Create_func_centroid() {} + virtual ~Create_func_centroid() {} +}; +#endif + + +class Create_func_char_length : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_char_length s_singleton; + +protected: + Create_func_char_length() {} + virtual ~Create_func_char_length() {} +}; + + +class Create_func_coercibility : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_coercibility s_singleton; + +protected: + Create_func_coercibility() {} + virtual ~Create_func_coercibility() {} +}; + + +class Create_func_compress : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_compress s_singleton; + +protected: + Create_func_compress() {} + virtual ~Create_func_compress() {} +}; + + +class Create_func_concat : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_concat s_singleton; + +protected: + Create_func_concat() {} + virtual ~Create_func_concat() {} +}; + + +class Create_func_concat_ws : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_concat_ws s_singleton; + +protected: + Create_func_concat_ws() {} + virtual ~Create_func_concat_ws() {} +}; + + +class Create_func_connection_id : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_connection_id s_singleton; + +protected: + Create_func_connection_id() {} + virtual ~Create_func_connection_id() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_contains : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_contains s_singleton; + +protected: + Create_func_contains() {} + virtual ~Create_func_contains() {} +}; +#endif + + +class Create_func_conv : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_conv s_singleton; + +protected: + Create_func_conv() {} + virtual ~Create_func_conv() {} +}; + + +class Create_func_convert_tz : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_convert_tz s_singleton; + +protected: + Create_func_convert_tz() {} + virtual ~Create_func_convert_tz() {} +}; + + +class Create_func_cos : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_cos s_singleton; + +protected: + Create_func_cos() {} + virtual ~Create_func_cos() {} +}; + + +class Create_func_cot : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_cot s_singleton; + +protected: + Create_func_cot() {} + virtual ~Create_func_cot() {} +}; + + +class Create_func_crc32 : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_crc32 s_singleton; + +protected: + Create_func_crc32() {} + virtual ~Create_func_crc32() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_crosses : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_crosses s_singleton; + +protected: + Create_func_crosses() {} + virtual ~Create_func_crosses() {} +}; +#endif + + +class Create_func_date_format : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_date_format s_singleton; + +protected: + Create_func_date_format() {} + virtual ~Create_func_date_format() {} +}; + + +class Create_func_datediff : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_datediff s_singleton; + +protected: + Create_func_datediff() {} + virtual ~Create_func_datediff() {} +}; + + +class Create_func_dayname : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_dayname s_singleton; + +protected: + Create_func_dayname() {} + virtual ~Create_func_dayname() {} +}; + + +class Create_func_dayofmonth : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_dayofmonth s_singleton; + +protected: + Create_func_dayofmonth() {} + virtual ~Create_func_dayofmonth() {} +}; + + +class Create_func_dayofweek : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_dayofweek s_singleton; + +protected: + Create_func_dayofweek() {} + virtual ~Create_func_dayofweek() {} +}; + + +class Create_func_dayofyear : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_dayofyear s_singleton; + +protected: + Create_func_dayofyear() {} + virtual ~Create_func_dayofyear() {} +}; + + +class Create_func_decode : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_decode s_singleton; + +protected: + Create_func_decode() {} + virtual ~Create_func_decode() {} +}; + + +class Create_func_degrees : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_degrees s_singleton; + +protected: + Create_func_degrees() {} + virtual ~Create_func_degrees() {} +}; + + +class Create_func_des_decrypt : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_des_decrypt s_singleton; + +protected: + Create_func_des_decrypt() {} + virtual ~Create_func_des_decrypt() {} +}; + + +class Create_func_des_encrypt : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_des_encrypt s_singleton; + +protected: + Create_func_des_encrypt() {} + virtual ~Create_func_des_encrypt() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_dimension : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_dimension s_singleton; + +protected: + Create_func_dimension() {} + virtual ~Create_func_dimension() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_disjoint : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_disjoint s_singleton; + +protected: + Create_func_disjoint() {} + virtual ~Create_func_disjoint() {} +}; +#endif + + +class Create_func_elt : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_elt s_singleton; + +protected: + Create_func_elt() {} + virtual ~Create_func_elt() {} +}; + + +class Create_func_encode : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_encode s_singleton; + +protected: + Create_func_encode() {} + virtual ~Create_func_encode() {} +}; + + +class Create_func_encrypt : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_encrypt s_singleton; + +protected: + Create_func_encrypt() {} + virtual ~Create_func_encrypt() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_endpoint : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_endpoint s_singleton; + +protected: + Create_func_endpoint() {} + virtual ~Create_func_endpoint() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_envelope : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_envelope s_singleton; + +protected: + Create_func_envelope() {} + virtual ~Create_func_envelope() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_equals : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_equals s_singleton; + +protected: + Create_func_equals() {} + virtual ~Create_func_equals() {} +}; +#endif + + +class Create_func_exp : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_exp s_singleton; + +protected: + Create_func_exp() {} + virtual ~Create_func_exp() {} +}; + + +class Create_func_export_set : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_export_set s_singleton; + +protected: + Create_func_export_set() {} + virtual ~Create_func_export_set() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_exteriorring : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_exteriorring s_singleton; + +protected: + Create_func_exteriorring() {} + virtual ~Create_func_exteriorring() {} +}; +#endif + + +class Create_func_field : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_field s_singleton; + +protected: + Create_func_field() {} + virtual ~Create_func_field() {} +}; + + +class Create_func_find_in_set : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_find_in_set s_singleton; + +protected: + Create_func_find_in_set() {} + virtual ~Create_func_find_in_set() {} +}; + + +class Create_func_floor : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_floor s_singleton; + +protected: + Create_func_floor() {} + virtual ~Create_func_floor() {} +}; + + +class Create_func_format : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_format s_singleton; + +protected: + Create_func_format() {} + virtual ~Create_func_format() {} +}; + + +class Create_func_found_rows : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_found_rows s_singleton; + +protected: + Create_func_found_rows() {} + virtual ~Create_func_found_rows() {} +}; + + +class Create_func_from_days : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_from_days s_singleton; + +protected: + Create_func_from_days() {} + virtual ~Create_func_from_days() {} +}; + + +class Create_func_from_unixtime : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_from_unixtime s_singleton; + +protected: + Create_func_from_unixtime() {} + virtual ~Create_func_from_unixtime() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_geometry_from_text : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_geometry_from_text s_singleton; + +protected: + Create_func_geometry_from_text() {} + virtual ~Create_func_geometry_from_text() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_geometry_from_wkb : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_geometry_from_wkb s_singleton; + +protected: + Create_func_geometry_from_wkb() {} + virtual ~Create_func_geometry_from_wkb() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_geometry_type : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_geometry_type s_singleton; + +protected: + Create_func_geometry_type() {} + virtual ~Create_func_geometry_type() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_geometryn : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_geometryn s_singleton; + +protected: + Create_func_geometryn() {} + virtual ~Create_func_geometryn() {} +}; +#endif + + +class Create_func_get_lock : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_get_lock s_singleton; + +protected: + Create_func_get_lock() {} + virtual ~Create_func_get_lock() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_glength : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_glength s_singleton; + +protected: + Create_func_glength() {} + virtual ~Create_func_glength() {} +}; +#endif + + +class Create_func_greatest : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_greatest s_singleton; + +protected: + Create_func_greatest() {} + virtual ~Create_func_greatest() {} +}; + + +class Create_func_hex : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_hex s_singleton; + +protected: + Create_func_hex() {} + virtual ~Create_func_hex() {} +}; + + +class Create_func_ifnull : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_ifnull s_singleton; + +protected: + Create_func_ifnull() {} + virtual ~Create_func_ifnull() {} +}; + + +class Create_func_inet_ntoa : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_inet_ntoa s_singleton; + +protected: + Create_func_inet_ntoa() {} + virtual ~Create_func_inet_ntoa() {} +}; + + +class Create_func_inet_aton : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_inet_aton s_singleton; + +protected: + Create_func_inet_aton() {} + virtual ~Create_func_inet_aton() {} +}; + + +class Create_func_instr : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_instr s_singleton; + +protected: + Create_func_instr() {} + virtual ~Create_func_instr() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_interiorringn : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_interiorringn s_singleton; + +protected: + Create_func_interiorringn() {} + virtual ~Create_func_interiorringn() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_intersects : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_intersects s_singleton; + +protected: + Create_func_intersects() {} + virtual ~Create_func_intersects() {} +}; +#endif + + +class Create_func_is_free_lock : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_is_free_lock s_singleton; + +protected: + Create_func_is_free_lock() {} + virtual ~Create_func_is_free_lock() {} +}; + + +class Create_func_is_used_lock : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_is_used_lock s_singleton; + +protected: + Create_func_is_used_lock() {} + virtual ~Create_func_is_used_lock() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_isclosed : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_isclosed s_singleton; + +protected: + Create_func_isclosed() {} + virtual ~Create_func_isclosed() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_isempty : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_isempty s_singleton; + +protected: + Create_func_isempty() {} + virtual ~Create_func_isempty() {} +}; +#endif + + +class Create_func_isnull : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_isnull s_singleton; + +protected: + Create_func_isnull() {} + virtual ~Create_func_isnull() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_issimple : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_issimple s_singleton; + +protected: + Create_func_issimple() {} + virtual ~Create_func_issimple() {} +}; +#endif + + +class Create_func_last_day : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_last_day s_singleton; + +protected: + Create_func_last_day() {} + virtual ~Create_func_last_day() {} +}; + + +class Create_func_last_insert_id : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_last_insert_id s_singleton; + +protected: + Create_func_last_insert_id() {} + virtual ~Create_func_last_insert_id() {} +}; + + +class Create_func_lcase : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_lcase s_singleton; + +protected: + Create_func_lcase() {} + virtual ~Create_func_lcase() {} +}; + + +class Create_func_least : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_least s_singleton; + +protected: + Create_func_least() {} + virtual ~Create_func_least() {} +}; + + +class Create_func_length : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_length s_singleton; + +protected: + Create_func_length() {} + virtual ~Create_func_length() {} +}; + + +class Create_func_ln : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_ln s_singleton; + +protected: + Create_func_ln() {} + virtual ~Create_func_ln() {} +}; + + +class Create_func_load_file : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_load_file s_singleton; + +protected: + Create_func_load_file() {} + virtual ~Create_func_load_file() {} +}; + + +class Create_func_locate : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_locate s_singleton; + +protected: + Create_func_locate() {} + virtual ~Create_func_locate() {} +}; + + +class Create_func_log : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_log s_singleton; + +protected: + Create_func_log() {} + virtual ~Create_func_log() {} +}; + + +class Create_func_log10 : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_log10 s_singleton; + +protected: + Create_func_log10() {} + virtual ~Create_func_log10() {} +}; + + +class Create_func_log2 : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_log2 s_singleton; + +protected: + Create_func_log2() {} + virtual ~Create_func_log2() {} +}; + + +class Create_func_lpad : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_lpad s_singleton; + +protected: + Create_func_lpad() {} + virtual ~Create_func_lpad() {} +}; + + +class Create_func_ltrim : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_ltrim s_singleton; + +protected: + Create_func_ltrim() {} + virtual ~Create_func_ltrim() {} +}; + + +class Create_func_makedate : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_makedate s_singleton; + +protected: + Create_func_makedate() {} + virtual ~Create_func_makedate() {} +}; + + +class Create_func_maketime : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_maketime s_singleton; + +protected: + Create_func_maketime() {} + virtual ~Create_func_maketime() {} +}; + + +class Create_func_make_set : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_make_set s_singleton; + +protected: + Create_func_make_set() {} + virtual ~Create_func_make_set() {} +}; + + +class Create_func_master_pos_wait : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_master_pos_wait s_singleton; + +protected: + Create_func_master_pos_wait() {} + virtual ~Create_func_master_pos_wait() {} +}; + + +class Create_func_md5 : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_md5 s_singleton; + +protected: + Create_func_md5() {} + virtual ~Create_func_md5() {} +}; + + +class Create_func_monthname : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_monthname s_singleton; + +protected: + Create_func_monthname() {} + virtual ~Create_func_monthname() {} +}; + + +class Create_func_name_const : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_name_const s_singleton; + +protected: + Create_func_name_const() {} + virtual ~Create_func_name_const() {} +}; + + +class Create_func_nullif : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_nullif s_singleton; + +protected: + Create_func_nullif() {} + virtual ~Create_func_nullif() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_numgeometries : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_numgeometries s_singleton; + +protected: + Create_func_numgeometries() {} + virtual ~Create_func_numgeometries() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_numinteriorring : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_numinteriorring s_singleton; + +protected: + Create_func_numinteriorring() {} + virtual ~Create_func_numinteriorring() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_numpoints : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_numpoints s_singleton; + +protected: + Create_func_numpoints() {} + virtual ~Create_func_numpoints() {} +}; +#endif + + +class Create_func_oct : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_oct s_singleton; + +protected: + Create_func_oct() {} + virtual ~Create_func_oct() {} +}; + + +class Create_func_ord : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_ord s_singleton; + +protected: + Create_func_ord() {} + virtual ~Create_func_ord() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_overlaps : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_overlaps s_singleton; + +protected: + Create_func_overlaps() {} + virtual ~Create_func_overlaps() {} +}; +#endif + + +class Create_func_period_add : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_period_add s_singleton; + +protected: + Create_func_period_add() {} + virtual ~Create_func_period_add() {} +}; + + +class Create_func_period_diff : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_period_diff s_singleton; + +protected: + Create_func_period_diff() {} + virtual ~Create_func_period_diff() {} +}; + + +class Create_func_pi : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_pi s_singleton; + +protected: + Create_func_pi() {} + virtual ~Create_func_pi() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_pointn : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_pointn s_singleton; + +protected: + Create_func_pointn() {} + virtual ~Create_func_pointn() {} +}; +#endif + + +class Create_func_pow : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_pow s_singleton; + +protected: + Create_func_pow() {} + virtual ~Create_func_pow() {} +}; + + +class Create_func_quote : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_quote s_singleton; + +protected: + Create_func_quote() {} + virtual ~Create_func_quote() {} +}; + + +class Create_func_radians : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_radians s_singleton; + +protected: + Create_func_radians() {} + virtual ~Create_func_radians() {} +}; + + +class Create_func_rand : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_rand s_singleton; + +protected: + Create_func_rand() {} + virtual ~Create_func_rand() {} +}; + + +class Create_func_release_lock : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_release_lock s_singleton; + +protected: + Create_func_release_lock() {} + virtual ~Create_func_release_lock() {} +}; + + +class Create_func_reverse : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_reverse s_singleton; + +protected: + Create_func_reverse() {} + virtual ~Create_func_reverse() {} +}; + + +class Create_func_round : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_round s_singleton; + +protected: + Create_func_round() {} + virtual ~Create_func_round() {} +}; + + +class Create_func_row_count : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_row_count s_singleton; + +protected: + Create_func_row_count() {} + virtual ~Create_func_row_count() {} +}; + + +class Create_func_rpad : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_rpad s_singleton; + +protected: + Create_func_rpad() {} + virtual ~Create_func_rpad() {} +}; + + +class Create_func_rtrim : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_rtrim s_singleton; + +protected: + Create_func_rtrim() {} + virtual ~Create_func_rtrim() {} +}; + + +class Create_func_sec_to_time : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sec_to_time s_singleton; + +protected: + Create_func_sec_to_time() {} + virtual ~Create_func_sec_to_time() {} +}; + + +class Create_func_sha : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sha s_singleton; + +protected: + Create_func_sha() {} + virtual ~Create_func_sha() {} +}; + + +class Create_func_sign : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sign s_singleton; + +protected: + Create_func_sign() {} + virtual ~Create_func_sign() {} +}; + + +class Create_func_sin : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sin s_singleton; + +protected: + Create_func_sin() {} + virtual ~Create_func_sin() {} +}; + + +class Create_func_sleep : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sleep s_singleton; + +protected: + Create_func_sleep() {} + virtual ~Create_func_sleep() {} +}; + + +class Create_func_soundex : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_soundex s_singleton; + +protected: + Create_func_soundex() {} + virtual ~Create_func_soundex() {} +}; + + +class Create_func_space : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_space s_singleton; + +protected: + Create_func_space() {} + virtual ~Create_func_space() {} +}; + + +class Create_func_sqrt : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_sqrt s_singleton; + +protected: + Create_func_sqrt() {} + virtual ~Create_func_sqrt() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_srid : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_srid s_singleton; + +protected: + Create_func_srid() {} + virtual ~Create_func_srid() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_startpoint : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_startpoint s_singleton; + +protected: + Create_func_startpoint() {} + virtual ~Create_func_startpoint() {} +}; +#endif + + +class Create_func_str_to_date : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_str_to_date s_singleton; + +protected: + Create_func_str_to_date() {} + virtual ~Create_func_str_to_date() {} +}; + + +class Create_func_strcmp : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_strcmp s_singleton; + +protected: + Create_func_strcmp() {} + virtual ~Create_func_strcmp() {} +}; + + +class Create_func_substr_index : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_substr_index s_singleton; + +protected: + Create_func_substr_index() {} + virtual ~Create_func_substr_index() {} +}; + + +class Create_func_subtime : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_subtime s_singleton; + +protected: + Create_func_subtime() {} + virtual ~Create_func_subtime() {} +}; + + +class Create_func_tan : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_tan s_singleton; + +protected: + Create_func_tan() {} + virtual ~Create_func_tan() {} +}; + + +class Create_func_time_format : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_time_format s_singleton; + +protected: + Create_func_time_format() {} + virtual ~Create_func_time_format() {} +}; + + +class Create_func_time_to_sec : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_time_to_sec s_singleton; + +protected: + Create_func_time_to_sec() {} + virtual ~Create_func_time_to_sec() {} +}; + + +class Create_func_timediff : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_timediff s_singleton; + +protected: + Create_func_timediff() {} + virtual ~Create_func_timediff() {} +}; + + +class Create_func_to_days : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_to_days s_singleton; + +protected: + Create_func_to_days() {} + virtual ~Create_func_to_days() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_touches : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_touches s_singleton; + +protected: + Create_func_touches() {} + virtual ~Create_func_touches() {} +}; +#endif + + +class Create_func_ucase : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_ucase s_singleton; + +protected: + Create_func_ucase() {} + virtual ~Create_func_ucase() {} +}; + + +class Create_func_uncompress : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_uncompress s_singleton; + +protected: + Create_func_uncompress() {} + virtual ~Create_func_uncompress() {} +}; + + +class Create_func_uncompressed_length : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_uncompressed_length s_singleton; + +protected: + Create_func_uncompressed_length() {} + virtual ~Create_func_uncompressed_length() {} +}; + + +class Create_func_unhex : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_unhex s_singleton; + +protected: + Create_func_unhex() {} + virtual ~Create_func_unhex() {} +}; + + +class Create_func_unix_timestamp : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_unix_timestamp s_singleton; + +protected: + Create_func_unix_timestamp() {} + virtual ~Create_func_unix_timestamp() {} +}; + + +class Create_func_uuid : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_uuid s_singleton; + +protected: + Create_func_uuid() {} + virtual ~Create_func_uuid() {} +}; + + +class Create_func_version : public Create_func_arg0 +{ +public: + virtual Item* create(THD *thd); + + static Create_func_version s_singleton; + +protected: + Create_func_version() {} + virtual ~Create_func_version() {} +}; + + +class Create_func_weekday : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_weekday s_singleton; + +protected: + Create_func_weekday() {} + virtual ~Create_func_weekday() {} +}; + + +class Create_func_weekofyear : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_weekofyear s_singleton; + +protected: + Create_func_weekofyear() {} + virtual ~Create_func_weekofyear() {} +}; + + +#ifdef HAVE_SPATIAL +class Create_func_within : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_within s_singleton; + +protected: + Create_func_within() {} + virtual ~Create_func_within() {} +}; +#endif + + +#ifdef HAVE_SPATIAL +class Create_func_x : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_x s_singleton; + +protected: + Create_func_x() {} + virtual ~Create_func_x() {} +}; +#endif + + +class Create_func_xml_extractvalue : public Create_func_arg2 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2); + + static Create_func_xml_extractvalue s_singleton; + +protected: + Create_func_xml_extractvalue() {} + virtual ~Create_func_xml_extractvalue() {} +}; + + +class Create_func_xml_update : public Create_func_arg3 +{ +public: + virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3); + + static Create_func_xml_update s_singleton; + +protected: + Create_func_xml_update() {} + virtual ~Create_func_xml_update() {} +}; + -Item *create_func_abs(Item* a) +#ifdef HAVE_SPATIAL +class Create_func_y : public Create_func_arg1 +{ +public: + virtual Item* create(THD *thd, Item *arg1); + + static Create_func_y s_singleton; + +protected: + Create_func_y() {} + virtual ~Create_func_y() {} +}; +#endif + + +class Create_func_year_week : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + static Create_func_year_week s_singleton; + +protected: + Create_func_year_week() {} + virtual ~Create_func_year_week() {} +}; + + +/* +============================================================================= + IMPLEMENTATION +============================================================================= +*/ + +#ifndef HAVE_SPATIAL +Create_func_no_geom Create_func_no_geom::s_singleton; + +Item* +Create_func_no_geom::create(THD * /* unused */, + LEX_STRING /* unused */, + List<Item> * /* unused */) { - return new Item_func_abs(a); + /* FIXME: error message can't be translated. */ + my_error(ER_FEATURE_DISABLED, MYF(0), + sym_group_geom.name, sym_group_geom.needed_define); + return NULL; } +#endif -Item *create_func_acos(Item* a) + +Item* +Create_qfunc::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_acos(a); + LEX_STRING db; + if (thd->copy_db_to(&db.str, &db.length)) + return NULL; + + return create(thd, db, name, item_list); } -Item *create_func_aes_encrypt(Item* a, Item* b) + +#ifdef HAVE_DLOPEN +Create_udf_func Create_udf_func::s_singleton; + +Item* +Create_udf_func::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_aes_encrypt(a, b); + udf_func *udf= find_udf(name.str, name.length); + DBUG_ASSERT(udf); + return create(thd, udf, item_list); } -Item *create_func_aes_decrypt(Item* a, Item* b) + +Item* +Create_udf_func::create(THD *thd, udf_func *udf, List<Item> *item_list) { - return new Item_func_aes_decrypt(a, b); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + +#ifdef HAVE_ROW_BASED_REPLICATION + thd->lex->binlog_row_based_if_mixed= TRUE; +#endif + + DBUG_ASSERT( (udf->type == UDFTYPE_FUNCTION) + || (udf->type == UDFTYPE_AGGREGATE)); + + switch(udf->returns) + { + case STRING_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new (thd->mem_root) Item_func_udf_str(udf, *item_list); + else + func= new (thd->mem_root) Item_func_udf_str(udf); + } + else + { + if (arg_count) + func= new (thd->mem_root) Item_sum_udf_str(udf, *item_list); + else + func= new (thd->mem_root) Item_sum_udf_str(udf); + } + break; + } + case REAL_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new (thd->mem_root) Item_func_udf_float(udf, *item_list); + else + func= new (thd->mem_root) Item_func_udf_float(udf); + } + else + { + if (arg_count) + func= new (thd->mem_root) Item_sum_udf_float(udf, *item_list); + else + func= new (thd->mem_root) Item_sum_udf_float(udf); + } + break; + } + case INT_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new (thd->mem_root) Item_func_udf_int(udf, *item_list); + else + func= new (thd->mem_root) Item_func_udf_int(udf); + } + else + { + if (arg_count) + func= new (thd->mem_root) Item_sum_udf_int(udf, *item_list); + else + func= new (thd->mem_root) Item_sum_udf_int(udf); + } + break; + } + case DECIMAL_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new (thd->mem_root) Item_func_udf_decimal(udf, *item_list); + else + func= new (thd->mem_root) Item_func_udf_decimal(udf); + } + else + { + if (arg_count) + func= new (thd->mem_root) Item_sum_udf_decimal(udf, *item_list); + else + func= new (thd->mem_root) Item_sum_udf_decimal(udf); + } + break; + } + default: + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "UDF return type"); + } + } + return func; +} +#endif + + +Create_sp_func Create_sp_func::s_singleton; + +Item* +Create_sp_func::create(THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *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_ascii(Item* a) + +Item* +Create_func_arg0::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_ascii(a); + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + if (arg_count != 0) + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + return NULL; + } + + return create(thd); } -Item *create_func_ord(Item* a) + +Item* +Create_func_arg1::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_ord(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_asin(Item* a) + +Item* +Create_func_arg2::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_asin(a); + int arg_count= 0; + + if (item_list) + arg_count= item_list->elements; + + if (arg_count != 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_bin(Item* a) + +Item* +Create_func_arg3::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 2,1)); + int arg_count= 0; + + if (item_list) + arg_count= item_list->elements; + + if (arg_count != 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_bit_count(Item* a) + +Create_func_abs Create_func_abs::s_singleton; + +Item* +Create_func_abs::create(THD *thd, Item *arg1) { - return new Item_func_bit_count(a); + return new (thd->mem_root) Item_func_abs(arg1); } -Item *create_func_ceiling(Item* a) + +Create_func_acos Create_func_acos::s_singleton; + +Item* +Create_func_acos::create(THD *thd, Item *arg1) { - return new Item_func_ceiling(a); + return new (thd->mem_root) Item_func_acos(arg1); } -Item *create_func_connection_id(void) + +Create_func_addtime Create_func_addtime::s_singleton; + +Item* +Create_func_addtime::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_add_time(arg1, arg2, 0, 0); } -Item *create_func_conv(Item* a, Item *b, Item *c) + +Create_func_aes_encrypt Create_func_aes_encrypt::s_singleton; + +Item* +Create_func_aes_encrypt::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_conv(a,b,c); + return new (thd->mem_root) Item_func_aes_encrypt(arg1, arg2); } -Item *create_func_cos(Item* a) + +Create_func_aes_decrypt Create_func_aes_decrypt::s_singleton; + +Item* +Create_func_aes_decrypt::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_cos(a); + return new (thd->mem_root) Item_func_aes_decrypt(arg1, arg2); } -Item *create_func_cot(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_div(new Item_int((char*) "1",1,1), - new Item_func_tan(a)); + return new (thd->mem_root) Item_func_area(arg1); } +#endif + -Item *create_func_date_format(Item* a,Item *b) +#ifdef HAVE_SPATIAL +Create_func_as_wkb Create_func_as_wkb::s_singleton; + +Item* +Create_func_as_wkb::create(THD *thd, Item *arg1) { - return new Item_func_date_format(a,b,0); + 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_dayofmonth(Item* a) +Item* +Create_func_as_wkt::create(THD *thd, Item *arg1) { - return new Item_func_dayofmonth(a); + return new (thd->mem_root) Item_func_as_wkt(arg1); } +#endif + + +Create_func_asin Create_func_asin::s_singleton; -Item *create_func_dayofweek(Item* a) +Item* +Create_func_asin::create(THD *thd, Item *arg1) { - return new Item_func_weekday(a, 1); + return new (thd->mem_root) Item_func_asin(arg1); } -Item *create_func_dayofyear(Item* a) + +Create_func_atan Create_func_atan::s_singleton; + +Item* +Create_func_atan::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_dayofyear(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_dayname(Item* a) + +Create_func_benchmark Create_func_benchmark::s_singleton; + +Item* +Create_func_benchmark::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_dayname(a); + /* TODO: Known limitation, see Bug#22684 */ + if ((arg1->type() != Item::INT_ITEM) || ! arg1->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "BENCHMARK"); + return NULL; + } + + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_benchmark(arg1->val_int(), arg2); } -Item *create_func_degrees(Item *a) + +Create_func_bin Create_func_bin::s_singleton; + +Item* +Create_func_bin::create(THD *thd, Item *arg1) { - return new Item_func_units((char*) "degrees",a,180/M_PI,0.0); + 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_exp(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_exp(a); + return new (thd->mem_root) Item_func_bit_count(arg1); } -Item *create_func_find_in_set(Item* a, Item *b) + +Create_func_bit_length Create_func_bit_length::s_singleton; + +Item* +Create_func_bit_length::create(THD *thd, Item *arg1) { - return new Item_func_find_in_set(a, b); + return new (thd->mem_root) Item_func_bit_length(arg1); } -Item *create_func_floor(Item* a) + +Create_func_ceiling Create_func_ceiling::s_singleton; + +Item* +Create_func_ceiling::create(THD *thd, Item *arg1) { - return new Item_func_floor(a); + return new (thd->mem_root) Item_func_ceiling(arg1); } -Item *create_func_found_rows(void) + +#ifdef HAVE_SPATIAL +Create_func_centroid Create_func_centroid::s_singleton; + +Item* +Create_func_centroid::create(THD *thd, Item *arg1) { - THD *thd=current_thd; - thd->lex->safe_to_cache_query= 0; - return new Item_func_found_rows(); + return new (thd->mem_root) Item_func_centroid(arg1); } +#endif + -Item *create_func_from_days(Item* a) +Create_func_char_length Create_func_char_length::s_singleton; + +Item* +Create_func_char_length::create(THD *thd, Item *arg1) { - return new Item_func_from_days(a); + return new (thd->mem_root) Item_func_char_length(arg1); } -Item *create_func_get_lock(Item* a, Item *b) + +Create_func_coercibility Create_func_coercibility::s_singleton; + +Item* +Create_func_coercibility::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_get_lock(a, b); + return new (thd->mem_root) Item_func_coercibility(arg1); } -Item *create_func_hex(Item *a) + +Create_func_concat Create_func_concat::s_singleton; + +Item* +Create_func_concat::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_hex(a); + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + 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_inet_ntoa(Item* a) + +Create_func_concat_ws Create_func_concat_ws::s_singleton; + +Item* +Create_func_concat_ws::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_inet_ntoa(a); + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + /* "WS" stands for "With Separator": this function takes 2+ arguments */ + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + return NULL; + } + + return new (thd->mem_root) Item_func_concat_ws(*item_list); } -Item *create_func_inet_aton(Item* a) + +Create_func_compress Create_func_compress::s_singleton; + +Item* +Create_func_compress::create(THD *thd, Item *arg1) { - return new Item_func_inet_aton(a); + return new (thd->mem_root) Item_func_compress(arg1); } -Item *create_func_ifnull(Item* a, Item *b) +Create_func_connection_id Create_func_connection_id::s_singleton; + +Item* +Create_func_connection_id::create(THD *thd) { - return new Item_func_ifnull(a,b); + thd->lex->safe_to_cache_query= 0; + return new (thd->mem_root) Item_func_connection_id(); } -Item *create_func_nullif(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_nullif(a,b); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_CONTAINS_FUNC); } +#endif + -Item *create_func_locate(Item* a, Item *b) +Create_func_conv Create_func_conv::s_singleton; + +Item* +Create_func_conv::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_locate(b,a); + return new (thd->mem_root) Item_func_conv(arg1, arg2, arg3); } -Item *create_func_instr(Item* a, Item *b) + +Create_func_convert_tz Create_func_convert_tz::s_singleton; + +Item* +Create_func_convert_tz::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_locate(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_isnull(Item* a) + +Create_func_cos Create_func_cos::s_singleton; + +Item* +Create_func_cos::create(THD *thd, Item *arg1) { - return new Item_func_isnull(a); + return new (thd->mem_root) Item_func_cos(arg1); } -Item *create_func_lcase(Item* a) + +Create_func_cot Create_func_cot::s_singleton; + +Item* +Create_func_cot::create(THD *thd, Item *arg1) { - return new Item_func_lcase(a); + Item *i1= new (thd->mem_root) Item_int((char*) "1", 1, 1); + Item *i2= new (thd->mem_root) Item_func_tan(arg1); + return new (thd->mem_root) Item_func_div(i1, i2); } -Item *create_func_length(Item* a) + +Create_func_crc32 Create_func_crc32::s_singleton; + +Item* +Create_func_crc32::create(THD *thd, Item *arg1) { - return new Item_func_length(a); + return new (thd->mem_root) Item_func_crc32(arg1); } -Item *create_func_bit_length(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_crosses Create_func_crosses::s_singleton; + +Item* +Create_func_crosses::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_bit_length(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_coercibility(Item* a) +Item* +Create_func_date_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_coercibility(a); + return new (thd->mem_root) Item_func_date_format(arg1, arg2, 0); } -Item *create_func_char_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_char_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_ln(Item* a) + +Create_func_dayname Create_func_dayname::s_singleton; + +Item* +Create_func_dayname::create(THD *thd, Item *arg1) { - return new Item_func_ln(a); + return new (thd->mem_root) Item_func_dayname(arg1); } -Item *create_func_log2(Item* a) + +Create_func_dayofmonth Create_func_dayofmonth::s_singleton; + +Item* +Create_func_dayofmonth::create(THD *thd, Item *arg1) { - return new Item_func_log2(a); + return new (thd->mem_root) Item_func_dayofmonth(arg1); } -Item *create_func_log10(Item* a) + +Create_func_dayofweek Create_func_dayofweek::s_singleton; + +Item* +Create_func_dayofweek::create(THD *thd, Item *arg1) { - return new Item_func_log10(a); + return new (thd->mem_root) Item_func_weekday(arg1, 1); } -Item *create_func_lpad(Item* a, Item *b, Item *c) + +Create_func_dayofyear Create_func_dayofyear::s_singleton; + +Item* +Create_func_dayofyear::create(THD *thd, Item *arg1) { - return new Item_func_lpad(a,b,c); + return new (thd->mem_root) Item_func_dayofyear(arg1); } -Item *create_func_ltrim(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_ltrim(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_md5(Item* a) + +Create_func_degrees Create_func_degrees::s_singleton; + +Item* +Create_func_degrees::create(THD *thd, Item *arg1) { - return new Item_func_md5(a); + return new (thd->mem_root) Item_func_units((char*) "degrees", arg1, + 180/M_PI, 0.0); } -Item *create_func_mod(Item* a, Item *b) + +Create_func_des_decrypt Create_func_des_decrypt::s_singleton; + +Item* +Create_func_des_decrypt::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_mod(a,b); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new (thd->mem_root) Item_func_des_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_name_const(Item *a, Item *b) + +Create_func_des_encrypt Create_func_des_encrypt::s_singleton; + +Item* +Create_func_des_encrypt::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_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_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_monthname(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_monthname(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_month(Item* a) +Item* +Create_func_disjoint::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_month(a); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_DISJOINT_FUNC); } +#endif + -Item *create_func_oct(Item *a) +Create_func_elt Create_func_elt::s_singleton; + +Item* +Create_func_elt::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 8,1)); + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + return NULL; + } + + return new (thd->mem_root) Item_func_elt(*item_list); } -Item *create_func_period_add(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_period_add(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_period_diff(Item* a, Item *b) + +Create_func_encrypt Create_func_encrypt::s_singleton; + +Item* +Create_func_encrypt::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_period_diff(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_pi(void) + +#ifdef HAVE_SPATIAL +Create_func_endpoint Create_func_endpoint::s_singleton; + +Item* +Create_func_endpoint::create(THD *thd, Item *arg1) { - return new Item_static_float_func("pi()", M_PI, 6, 8); + 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_pow(Item* a, Item *b) +Item* +Create_func_envelope::create(THD *thd, Item *arg1) { - return new Item_func_pow(a,b); + return new (thd->mem_root) Item_func_envelope(arg1); } +#endif + + +#ifdef HAVE_SPATIAL +Create_func_equals Create_func_equals::s_singleton; -Item *create_func_radians(Item *a) +Item* +Create_func_equals::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_units((char*) "radians",a,M_PI/180,0.0); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_EQUALS_FUNC); } +#endif + -Item *create_func_release_lock(Item* a) +Create_func_exp Create_func_exp::s_singleton; + +Item* +Create_func_exp::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_release_lock(a); + return new (thd->mem_root) Item_func_exp(arg1); } -Item *create_func_repeat(Item* a, Item *b) + +Create_func_export_set Create_func_export_set::s_singleton; + +Item* +Create_func_export_set::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - 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 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_reverse(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_reverse(a); + return new (thd->mem_root) Item_func_spatial_decomp(arg1, + Item_func::SP_EXTERIORRING); } +#endif -Item *create_func_rpad(Item* a, Item *b, Item *c) + +Create_func_field Create_func_field::s_singleton; + +Item* +Create_func_field::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_rpad(a,b,c); + 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_rtrim(Item* a) + +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_rtrim(a); + return new (thd->mem_root) Item_func_find_in_set(arg1, arg2); } -Item *create_func_sec_to_time(Item* a) + +Create_func_floor Create_func_floor::s_singleton; + +Item* +Create_func_floor::create(THD *thd, Item *arg1) { - return new Item_func_sec_to_time(a); + return new (thd->mem_root) Item_func_floor(arg1); } -Item *create_func_sign(Item* a) + +Create_func_format Create_func_format::s_singleton; + +Item* +Create_func_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sign(a); + /* TODO: Known limitation, see Bug#22684 */ + if ((arg2->type() != Item::INT_ITEM) || ! arg2->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "FORMAT"); + return NULL; + } + + return new (thd->mem_root) Item_func_format(arg1, arg2->val_int()); } -Item *create_func_sin(Item* a) + +Create_func_found_rows Create_func_found_rows::s_singleton; + +Item* +Create_func_found_rows::create(THD *thd) { - return new Item_func_sin(a); + thd->lex->safe_to_cache_query= 0; + return new (thd->mem_root) Item_func_found_rows(); } -Item *create_func_sha(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_sha(a); + return new (thd->mem_root) Item_func_from_days(arg1); } -Item *create_func_sleep(Item* a) + +Create_func_from_unixtime Create_func_from_unixtime::s_singleton; + +Item* +Create_func_from_unixtime::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_sleep(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new (thd->mem_root) Item_func_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_space(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_geometry_from_text Create_func_geometry_from_text::s_singleton; + +Item* +Create_func_geometry_from_text::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - CHARSET_INFO *cs= current_thd->variables.collation_connection; - Item *sp; + Item *func= NULL; + int arg_count= 0; - if (cs->mbminlen > 1) + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) { - uint dummy_errors; - sp= new Item_string("",0,cs); - if (sp) - sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors); + 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; + } } - else + + 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> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) { - sp= new Item_string(" ",1,cs); + 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 sp ? new Item_func_repeat(sp, a) : 0; + + return func; } +#endif + + +#ifdef HAVE_SPATIAL +Create_func_geometry_type Create_func_geometry_type::s_singleton; + +Item* +Create_func_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_soundex(Item* a) +Item* +Create_func_get_lock::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_soundex(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_get_lock(arg1, arg2); } -Item *create_func_sqrt(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_sqrt(a); + return new (thd->mem_root) Item_func_glength(arg1); } +#endif -Item *create_func_strcmp(Item* a, Item *b) + +Create_func_greatest Create_func_greatest::s_singleton; + +Item* +Create_func_greatest::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_strcmp(a,b); + 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_tan(Item* a) + +Create_func_hex Create_func_hex::s_singleton; + +Item* +Create_func_hex::create(THD *thd, Item *arg1) { - return new Item_func_tan(a); + return new (thd->mem_root) Item_func_hex(arg1); } -Item *create_func_time_format(Item *a, Item *b) + +Create_func_ifnull Create_func_ifnull::s_singleton; + +Item* +Create_func_ifnull::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_date_format(a,b,1); + return new (thd->mem_root) Item_func_ifnull(arg1, arg2); } -Item *create_func_time_to_sec(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_time_to_sec(a); + return new (thd->mem_root) Item_func_inet_ntoa(arg1); } -Item *create_func_to_days(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_to_days(a); + return new (thd->mem_root) Item_func_inet_aton(arg1); } -Item *create_func_ucase(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_ucase(a); + return new (thd->mem_root) Item_func_locate(arg1, arg2); } -Item *create_func_unhex(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_unhex(a); + return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2, + Item_func::SP_INTERIORRINGN); } +#endif + -Item *create_func_uuid(void) +#ifdef HAVE_SPATIAL +Create_func_intersects Create_func_intersects::s_singleton; + +Item* +Create_func_intersects::create(THD *thd, Item *arg1, Item *arg2) { - THD *thd= current_thd; -#ifdef HAVE_ROW_BASED_REPLICATION - thd->lex->binlog_row_based_if_mixed= TRUE; + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_INTERSECTS_FUNC); +} #endif - return new(thd->mem_root) Item_func_uuid(); + + +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_version(void) + +Create_func_is_used_lock Create_func_is_used_lock::s_singleton; + +Item* +Create_func_is_used_lock::create(THD *thd, Item *arg1) { - return new Item_static_string_func("version()", server_version, - (uint) strlen(server_version), - system_charset_info, DERIVATION_SYSCONST); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_is_used_lock(arg1); } -Item *create_func_weekday(Item* a) + +#ifdef HAVE_SPATIAL +Create_func_isclosed Create_func_isclosed::s_singleton; + +Item* +Create_func_isclosed::create(THD *thd, Item *arg1) { - return new Item_func_weekday(a, 0); + return new (thd->mem_root) Item_func_isclosed(arg1); } +#endif + -Item *create_func_year(Item* a) +#ifdef HAVE_SPATIAL +Create_func_isempty Create_func_isempty::s_singleton; + +Item* +Create_func_isempty::create(THD *thd, Item *arg1) { - return new Item_func_year(a); + return new (thd->mem_root) Item_func_isempty(arg1); } +#endif -Item *create_load_file(Item* a) + +Create_func_isnull Create_func_isnull::s_singleton; + +Item* +Create_func_isnull::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_load_file(a); + return new (thd->mem_root) Item_func_isnull(arg1); } -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs) +#ifdef HAVE_SPATIAL +Create_func_issimple Create_func_issimple::s_singleton; + +Item* +Create_func_issimple::create(THD *thd, Item *arg1) { - Item *res; - int tmp_len; - LINT_INIT(res); + 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); +} - switch (cast_type) { - case ITEM_CAST_BINARY: res= new Item_func_binary(a); break; - case ITEM_CAST_SIGNED_INT: res= new Item_func_signed(a); break; - case ITEM_CAST_UNSIGNED_INT: res= new Item_func_unsigned(a); break; - case ITEM_CAST_DATE: res= new Item_date_typecast(a); break; - case ITEM_CAST_TIME: res= new Item_time_typecast(a); break; - case ITEM_CAST_DATETIME: res= new Item_datetime_typecast(a); break; - case ITEM_CAST_DECIMAL: - tmp_len= (len>0) ? len : 10; - if (tmp_len < dec) - { - my_error(ER_M_BIGGER_THAN_D, MYF(0), ""); - return 0; - } - res= new Item_decimal_typecast(a, tmp_len, dec); - break; - case ITEM_CAST_CHAR: - res= new Item_char_typecast(a, len, cs ? cs : - current_thd->variables.collation_connection); - break; - default: - DBUG_ASSERT(0); - res= 0; - break; + +Create_func_last_insert_id Create_func_last_insert_id::s_singleton; + +Item* +Create_func_last_insert_id::create(THD *thd, LEX_STRING name, + List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 0: + { + func= new (thd->mem_root) Item_func_last_insert_id(); + thd->lex->safe_to_cache_query= 0; + break; + } + case 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 res; + + return func; +} + + +Create_func_lcase Create_func_lcase::s_singleton; + +Item* +Create_func_lcase::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_lcase(arg1); +} + + +Create_func_least Create_func_least::s_singleton; + +Item* +Create_func_least::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + return NULL; + } + + return new (thd->mem_root) Item_func_min(*item_list); +} + + +Create_func_length Create_func_length::s_singleton; + +Item* +Create_func_length::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_length(arg1); +} + + +Create_func_ln Create_func_ln::s_singleton; + +Item* +Create_func_ln::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_ln(arg1); +} + + +Create_func_load_file Create_func_load_file::s_singleton; + +Item* +Create_func_load_file::create(THD *thd, Item *arg1) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_load_file(arg1); +} + + +Create_func_locate Create_func_locate::s_singleton; + +Item* +Create_func_locate::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + /* Yes, parameters in that order : 2, 1 */ + func= new (thd->mem_root) Item_func_locate(param_2, param_1); + break; + } + case 3: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *param_3= item_list->pop(); + /* Yes, parameters in that order : 2, 1, 3 */ + func= new (thd->mem_root) Item_func_locate(param_2, param_1, param_3); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; +} + + +Create_func_log Create_func_log::s_singleton; + +Item* +Create_func_log::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new (thd->mem_root) Item_func_log(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new (thd->mem_root) Item_func_log(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; +} + + +Create_func_log10 Create_func_log10::s_singleton; + +Item* +Create_func_log10::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_log10(arg1); +} + + +Create_func_log2 Create_func_log2::s_singleton; + +Item* +Create_func_log2::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_log2(arg1); +} + + +Create_func_lpad Create_func_lpad::s_singleton; + +Item* +Create_func_lpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new (thd->mem_root) Item_func_lpad(arg1, arg2, arg3); +} + + +Create_func_ltrim Create_func_ltrim::s_singleton; + +Item* +Create_func_ltrim::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_ltrim(arg1); } -Item *create_func_is_free_lock(Item* a) + +Create_func_makedate Create_func_makedate::s_singleton; + +Item* +Create_func_makedate::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_makedate(arg1, arg2); +} + + +Create_func_maketime Create_func_maketime::s_singleton; + +Item* +Create_func_maketime::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new (thd->mem_root) Item_func_maketime(arg1, arg2, arg3); +} + + +Create_func_make_set Create_func_make_set::s_singleton; + +Item* +Create_func_make_set::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + return NULL; + } + + Item *param_1= item_list->pop(); + return new (thd->mem_root) Item_func_make_set(param_1, *item_list); +} + + +Create_func_master_pos_wait Create_func_master_pos_wait::s_singleton; + +Item* +Create_func_master_pos_wait::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_free_lock(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2); + thd->lex->safe_to_cache_query= 0; + break; + } + case 3: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *param_3= item_list->pop(); + func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2, param_3); + thd->lex->safe_to_cache_query= 0; + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; } -Item *create_func_is_used_lock(Item* a) + +Create_func_md5 Create_func_md5::s_singleton; + +Item* +Create_func_md5::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_used_lock(a); + return new (thd->mem_root) Item_func_md5(arg1); } -Item *create_func_quote(Item* a) + +Create_func_monthname Create_func_monthname::s_singleton; + +Item* +Create_func_monthname::create(THD *thd, Item *arg1) { - return new Item_func_quote(a); + return new (thd->mem_root) Item_func_monthname(arg1); } -Item *create_func_xml_extractvalue(Item *a, Item *b) + +Create_func_name_const Create_func_name_const::s_singleton; + +Item* +Create_func_name_const::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_xml_extractvalue(a, b); + return new (thd->mem_root) Item_name_const(arg1, arg2); } -Item *create_func_xml_update(Item *a, Item *b, Item *c) + +Create_func_nullif Create_func_nullif::s_singleton; + +Item* +Create_func_nullif::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_xml_update(a, b, c); + return new (thd->mem_root) Item_func_nullif(arg1, arg2); } + #ifdef HAVE_SPATIAL -Item *create_func_as_wkt(Item *a) +Create_func_numgeometries Create_func_numgeometries::s_singleton; + +Item* +Create_func_numgeometries::create(THD *thd, Item *arg1) { - return new Item_func_as_wkt(a); + return new (thd->mem_root) Item_func_numgeometries(arg1); } +#endif + -Item *create_func_as_wkb(Item *a) +#ifdef HAVE_SPATIAL +Create_func_numinteriorring Create_func_numinteriorring::s_singleton; + +Item* +Create_func_numinteriorring::create(THD *thd, Item *arg1) { - return new Item_func_as_wkb(a); + return new (thd->mem_root) Item_func_numinteriorring(arg1); } +#endif + -Item *create_func_srid(Item *a) +#ifdef HAVE_SPATIAL +Create_func_numpoints Create_func_numpoints::s_singleton; + +Item* +Create_func_numpoints::create(THD *thd, Item *arg1) { - return new Item_func_srid(a); + return new (thd->mem_root) Item_func_numpoints(arg1); } +#endif -Item *create_func_startpoint(Item *a) + +Create_func_oct Create_func_oct::s_singleton; + +Item* +Create_func_oct::create(THD *thd, Item *arg1) { - return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT); + Item *i10= new (thd->mem_root) Item_int((int32) 10,2); + Item *i8= new (thd->mem_root) Item_int((int32) 8,1); + return new (thd->mem_root) Item_func_conv(arg1, i10, i8); } -Item *create_func_endpoint(Item *a) + +Create_func_ord Create_func_ord::s_singleton; + +Item* +Create_func_ord::create(THD *thd, Item *arg1) { - return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT); + return new (thd->mem_root) Item_func_ord(arg1); } -Item *create_func_exteriorring(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_overlaps Create_func_overlaps::s_singleton; + +Item* +Create_func_overlaps::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_OVERLAPS_FUNC); } +#endif + + +Create_func_period_add Create_func_period_add::s_singleton; -Item *create_func_pointn(Item *a, Item *b) +Item* +Create_func_period_add::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN); + return new (thd->mem_root) Item_func_period_add(arg1, arg2); } -Item *create_func_interiorringn(Item *a, Item *b) + +Create_func_period_diff Create_func_period_diff::s_singleton; + +Item* +Create_func_period_diff::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN); + return new (thd->mem_root) Item_func_period_diff(arg1, arg2); } -Item *create_func_geometryn(Item *a, Item *b) + +Create_func_pi Create_func_pi::s_singleton; + +Item* +Create_func_pi::create(THD *thd) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN); + return new (thd->mem_root) Item_static_float_func("pi()", M_PI, 6, 8); } -Item *create_func_centroid(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_pointn Create_func_pointn::s_singleton; + +Item* +Create_func_pointn::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_centroid(a); + return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2, + Item_func::SP_POINTN); } +#endif + + +Create_func_pow Create_func_pow::s_singleton; -Item *create_func_envelope(Item *a) +Item* +Create_func_pow::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_envelope(a); + return new (thd->mem_root) Item_func_pow(arg1, arg2); } -Item *create_func_equals(Item *a, Item *b) + +Create_func_quote Create_func_quote::s_singleton; + +Item* +Create_func_quote::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC); + return new (thd->mem_root) Item_func_quote(arg1); } -Item *create_func_disjoint(Item *a, Item *b) + +Create_func_radians Create_func_radians::s_singleton; + +Item* +Create_func_radians::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC); + return new (thd->mem_root) Item_func_units((char*) "radians", arg1, + M_PI/180, 0.0); } -Item *create_func_intersects(Item *a, Item *b) + +Create_func_rand Create_func_rand::s_singleton; + +Item* +Create_func_rand::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 0: + { + func= new (thd->mem_root) Item_func_rand(); + thd->lex->uncacheable(UNCACHEABLE_RAND); + break; + } + case 1: + { + Item *param_1= item_list->pop(); + func= new (thd->mem_root) Item_func_rand(param_1); + thd->lex->uncacheable(UNCACHEABLE_RAND); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; } -Item *create_func_touches(Item *a, Item *b) + +Create_func_release_lock Create_func_release_lock::s_singleton; + +Item* +Create_func_release_lock::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_release_lock(arg1); } -Item *create_func_crosses(Item *a, Item *b) + +Create_func_reverse Create_func_reverse::s_singleton; + +Item* +Create_func_reverse::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC); + return new (thd->mem_root) Item_func_reverse(arg1); } -Item *create_func_within(Item *a, Item *b) + +Create_func_round Create_func_round::s_singleton; + +Item* +Create_func_round::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + Item *i0 = new (thd->mem_root) Item_int((char*)"0", 0, 1); + func= new (thd->mem_root) Item_func_round(param_1, i0, 0); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new (thd->mem_root) Item_func_round(param_1, param_2, 0); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; } -Item *create_func_contains(Item *a, Item *b) + +Create_func_row_count Create_func_row_count::s_singleton; + +Item* +Create_func_row_count::create(THD *thd) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC); + thd->lex->safe_to_cache_query= 0; + return new (thd->mem_root) Item_func_row_count(); } -Item *create_func_overlaps(Item *a, Item *b) + +Create_func_rpad Create_func_rpad::s_singleton; + +Item* +Create_func_rpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC); + return new (thd->mem_root) Item_func_rpad(arg1, arg2, arg3); } -Item *create_func_isempty(Item *a) + +Create_func_rtrim Create_func_rtrim::s_singleton; + +Item* +Create_func_rtrim::create(THD *thd, Item *arg1) { - return new Item_func_isempty(a); + return new (thd->mem_root) Item_func_rtrim(arg1); } -Item *create_func_issimple(Item *a) + +Create_func_sec_to_time Create_func_sec_to_time::s_singleton; + +Item* +Create_func_sec_to_time::create(THD *thd, Item *arg1) { - return new Item_func_issimple(a); + return new (thd->mem_root) Item_func_sec_to_time(arg1); } -Item *create_func_isclosed(Item *a) + +Create_func_sha Create_func_sha::s_singleton; + +Item* +Create_func_sha::create(THD *thd, Item *arg1) { - return new Item_func_isclosed(a); + return new (thd->mem_root) Item_func_sha(arg1); } -Item *create_func_geometry_type(Item *a) + +Create_func_sign Create_func_sign::s_singleton; + +Item* +Create_func_sign::create(THD *thd, Item *arg1) { - return new Item_func_geometry_type(a); + return new (thd->mem_root) Item_func_sign(arg1); } -Item *create_func_dimension(Item *a) + +Create_func_sin Create_func_sin::s_singleton; + +Item* +Create_func_sin::create(THD *thd, Item *arg1) { - return new Item_func_dimension(a); + return new (thd->mem_root) Item_func_sin(arg1); } -Item *create_func_x(Item *a) + +Create_func_sleep Create_func_sleep::s_singleton; + +Item* +Create_func_sleep::create(THD *thd, Item *arg1) { - return new Item_func_x(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new (thd->mem_root) Item_func_sleep(arg1); } -Item *create_func_y(Item *a) + +Create_func_soundex Create_func_soundex::s_singleton; + +Item* +Create_func_soundex::create(THD *thd, Item *arg1) { - return new Item_func_y(a); + return new (thd->mem_root) Item_func_soundex(arg1); } -Item *create_func_numpoints(Item *a) + +Create_func_space Create_func_space::s_singleton; + +Item* +Create_func_space::create(THD *thd, Item *arg1) { - return new Item_func_numpoints(a); + /** + TODO: Fix Bug#23637 + The parsed item tree should not depend on + <code>thd->variables.collation_connection</code>. + */ + CHARSET_INFO *cs= thd->variables.collation_connection; + Item *sp; + + if (cs->mbminlen > 1) + { + uint dummy_errors; + sp= new (thd->mem_root) Item_string("", 0, cs); + sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors); + } + else + { + sp= new (thd->mem_root) Item_string(" ", 1, cs); + } + + return new (thd->mem_root) Item_func_repeat(sp, arg1); } -Item *create_func_numinteriorring(Item *a) + +Create_func_sqrt Create_func_sqrt::s_singleton; + +Item* +Create_func_sqrt::create(THD *thd, Item *arg1) { - return new Item_func_numinteriorring(a); + return new (thd->mem_root) Item_func_sqrt(arg1); } -Item *create_func_numgeometries(Item *a) + +#ifdef HAVE_SPATIAL +Create_func_srid Create_func_srid::s_singleton; + +Item* +Create_func_srid::create(THD *thd, Item *arg1) { - return new Item_func_numgeometries(a); + return new (thd->mem_root) Item_func_srid(arg1); } +#endif + + +#ifdef HAVE_SPATIAL +Create_func_startpoint Create_func_startpoint::s_singleton; -Item *create_func_area(Item *a) +Item* +Create_func_startpoint::create(THD *thd, Item *arg1) { - return new Item_func_area(a); + return new (thd->mem_root) Item_func_spatial_decomp(arg1, + Item_func::SP_STARTPOINT); } +#endif + + +Create_func_str_to_date Create_func_str_to_date::s_singleton; -Item *create_func_glength(Item *a) +Item* +Create_func_str_to_date::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_glength(a); + return new (thd->mem_root) Item_func_str_to_date(arg1, arg2); } -Item *create_func_point(Item *a, Item *b) + +Create_func_strcmp Create_func_strcmp::s_singleton; + +Item* +Create_func_strcmp::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_point(a, b); + return new (thd->mem_root) Item_func_strcmp(arg1, arg2); } -#endif /*HAVE_SPATIAL*/ -Item *create_func_crc32(Item* a) + +Create_func_substr_index Create_func_substr_index::s_singleton; + +Item* +Create_func_substr_index::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_crc32(a); + return new (thd->mem_root) Item_func_substr_index(arg1, arg2, arg3); } -Item *create_func_compress(Item* a) + +Create_func_subtime Create_func_subtime::s_singleton; + +Item* +Create_func_subtime::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_compress(a); + return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 1); } -Item *create_func_uncompress(Item* a) + +Create_func_tan Create_func_tan::s_singleton; + +Item* +Create_func_tan::create(THD *thd, Item *arg1) { - return new Item_func_uncompress(a); + return new (thd->mem_root) Item_func_tan(arg1); } -Item *create_func_uncompressed_length(Item* a) + +Create_func_time_format Create_func_time_format::s_singleton; + +Item* +Create_func_time_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_uncompressed_length(a); + return new (thd->mem_root) Item_func_date_format(arg1, arg2, 1); } -Item *create_func_datediff(Item *a, Item *b) + +Create_func_time_to_sec Create_func_time_to_sec::s_singleton; + +Item* +Create_func_time_to_sec::create(THD *thd, Item *arg1) { - return new Item_func_minus(new Item_func_to_days(a), - new Item_func_to_days(b)); + return new (thd->mem_root) Item_func_time_to_sec(arg1); } -Item *create_func_weekofyear(Item *a) + +Create_func_timediff Create_func_timediff::s_singleton; + +Item* +Create_func_timediff::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_week(a, new Item_int((char*) "0", 3, 1)); + return new (thd->mem_root) Item_func_timediff(arg1, arg2); } -Item *create_func_makedate(Item* a,Item* b) + +Create_func_to_days Create_func_to_days::s_singleton; + +Item* +Create_func_to_days::create(THD *thd, Item *arg1) { - return new Item_func_makedate(a, b); + return new (thd->mem_root) Item_func_to_days(arg1); } -Item *create_func_addtime(Item* a,Item* b) + +#ifdef HAVE_SPATIAL +Create_func_touches Create_func_touches::s_singleton; + +Item* +Create_func_touches::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_add_time(a, b, 0, 0); + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_TOUCHES_FUNC); } +#endif + -Item *create_func_subtime(Item* a,Item* b) +Create_func_ucase Create_func_ucase::s_singleton; + +Item* +Create_func_ucase::create(THD *thd, Item *arg1) { - return new Item_func_add_time(a, b, 0, 1); + return new (thd->mem_root) Item_func_ucase(arg1); } -Item *create_func_timediff(Item* a,Item* b) + +Create_func_uncompress Create_func_uncompress::s_singleton; + +Item* +Create_func_uncompress::create(THD *thd, Item *arg1) { - return new Item_func_timediff(a, b); + return new (thd->mem_root) Item_func_uncompress(arg1); } -Item *create_func_maketime(Item* a,Item* b,Item* c) + +Create_func_uncompressed_length Create_func_uncompressed_length::s_singleton; + +Item* +Create_func_uncompressed_length::create(THD *thd, Item *arg1) { - return new Item_func_maketime(a, b, c); + return new (thd->mem_root) Item_func_uncompressed_length(arg1); } -Item *create_func_str_to_date(Item* a,Item* b) + +Create_func_unhex Create_func_unhex::s_singleton; + +Item* +Create_func_unhex::create(THD *thd, Item *arg1) { - return new Item_func_str_to_date(a, b); + return new (thd->mem_root) Item_func_unhex(arg1); } -Item *create_func_last_day(Item *a) + +Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton; + +Item* +Create_func_unix_timestamp::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_last_day(a); + 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) +{ +#ifdef HAVE_ROW_BASED_REPLICATION + thd->lex->binlog_row_based_if_mixed= TRUE; +#endif + return new (thd->mem_root) Item_func_uuid(); +} + + +Create_func_version Create_func_version::s_singleton; + +Item* +Create_func_version::create(THD *thd) +{ + return new (thd->mem_root) Item_static_string_func("version()", + server_version, + (uint) strlen(server_version), + system_charset_info, + DERIVATION_SYSCONST); +} + + +Create_func_weekday Create_func_weekday::s_singleton; + +Item* +Create_func_weekday::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_weekday(arg1, 0); +} + + +Create_func_weekofyear Create_func_weekofyear::s_singleton; + +Item* +Create_func_weekofyear::create(THD *thd, Item *arg1) +{ + Item *i1= new (thd->mem_root) Item_int((char*) "0", 3, 1); + return new (thd->mem_root) Item_func_week(arg1, i1); +} + + +#ifdef HAVE_SPATIAL +Create_func_within Create_func_within::s_singleton; + +Item* +Create_func_within::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2, + Item_func::SP_WITHIN_FUNC); +} +#endif + + +#ifdef HAVE_SPATIAL +Create_func_x Create_func_x::s_singleton; + +Item* +Create_func_x::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_x(arg1); +} +#endif + + +Create_func_xml_extractvalue Create_func_xml_extractvalue::s_singleton; + +Item* +Create_func_xml_extractvalue::create(THD *thd, Item *arg1, Item *arg2) +{ + return new (thd->mem_root) Item_func_xml_extractvalue(arg1, arg2); +} + + +Create_func_xml_update Create_func_xml_update::s_singleton; + +Item* +Create_func_xml_update::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new (thd->mem_root) Item_func_xml_update(arg1, arg2, arg3); +} + + +#ifdef HAVE_SPATIAL +Create_func_y Create_func_y::s_singleton; + +Item* +Create_func_y::create(THD *thd, Item *arg1) +{ + return new (thd->mem_root) Item_func_y(arg1); +} +#endif + + +Create_func_year_week Create_func_year_week::s_singleton; + +Item* +Create_func_year_week::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + arg_count= item_list->elements; + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + Item *i0= new (thd->mem_root) Item_int((char*) "0", 0, 1); + func= new (thd->mem_root) Item_func_yearweek(param_1, i0); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new (thd->mem_root) Item_func_yearweek(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str); + break; + } + } + + return func; +} + + +struct native_func_registry +{ + LEX_STRING name; + Create_func *builder; +}; + +#define BUILDER(F) & F::s_singleton + +#ifdef HAVE_SPATIAL + #define GEOM_BUILDER(F) & F::s_singleton +#else + #define GEOM_BUILDER(F) & Create_func_no_geom::s_singleton +#endif + +/* + MySQL native functions. + MAINTAINER: + - Keep sorted for human lookup. At runtime, a hash table is used. + - do **NOT** conditionaly (#ifdef, #ifndef) define a function *NAME*: + doing so will cause user code that works against a --without-XYZ binary + to fail with name collisions against a --with-XYZ binary. + Use something similar to GEOM_BUILDER instead. + - keep 1 line per entry, it makes grep | sort easier +*/ +static native_func_registry func_array[] = +{ + { C_STRING_WITH_LEN("ABS"), BUILDER(Create_func_abs)}, + { C_STRING_WITH_LEN("ACOS"), BUILDER(Create_func_acos)}, + { C_STRING_WITH_LEN("ADDTIME"), BUILDER(Create_func_addtime)}, + { C_STRING_WITH_LEN("AES_DECRYPT"), BUILDER(Create_func_aes_decrypt)}, + { C_STRING_WITH_LEN("AES_ENCRYPT"), BUILDER(Create_func_aes_encrypt)}, + { C_STRING_WITH_LEN("AREA"), GEOM_BUILDER(Create_func_area)}, + { C_STRING_WITH_LEN("ASBINARY"), GEOM_BUILDER(Create_func_as_wkb)}, + { C_STRING_WITH_LEN("ASIN"), BUILDER(Create_func_asin)}, + { C_STRING_WITH_LEN("ASTEXT"), GEOM_BUILDER(Create_func_as_wkt)}, + { C_STRING_WITH_LEN("ASWKB"), GEOM_BUILDER(Create_func_as_wkb)}, + { C_STRING_WITH_LEN("ASWKT"), GEOM_BUILDER(Create_func_as_wkt)}, + { C_STRING_WITH_LEN("ATAN"), BUILDER(Create_func_atan)}, + { C_STRING_WITH_LEN("ATAN2"), BUILDER(Create_func_atan)}, + { C_STRING_WITH_LEN("BENCHMARK"), BUILDER(Create_func_benchmark)}, + { C_STRING_WITH_LEN("BIN"), BUILDER(Create_func_bin)}, + { C_STRING_WITH_LEN("BIT_COUNT"), BUILDER(Create_func_bit_count)}, + { C_STRING_WITH_LEN("BIT_LENGTH"), BUILDER(Create_func_bit_length)}, + { C_STRING_WITH_LEN("CEIL"), BUILDER(Create_func_ceiling)}, + { C_STRING_WITH_LEN("CEILING"), BUILDER(Create_func_ceiling)}, + { C_STRING_WITH_LEN("CENTROID"), GEOM_BUILDER(Create_func_centroid)}, + { C_STRING_WITH_LEN("CHARACTER_LENGTH"), BUILDER(Create_func_char_length)}, + { C_STRING_WITH_LEN("CHAR_LENGTH"), BUILDER(Create_func_char_length)}, + { C_STRING_WITH_LEN("COERCIBILITY"), BUILDER(Create_func_coercibility)}, + { C_STRING_WITH_LEN("COMPRESS"), BUILDER(Create_func_compress)}, + { C_STRING_WITH_LEN("CONCAT"), BUILDER(Create_func_concat)}, + { C_STRING_WITH_LEN("CONCAT_WS"), BUILDER(Create_func_concat_ws)}, + { C_STRING_WITH_LEN("CONNECTION_ID"), BUILDER(Create_func_connection_id)}, + { C_STRING_WITH_LEN("CONV"), BUILDER(Create_func_conv)}, + { C_STRING_WITH_LEN("CONVERT_TZ"), BUILDER(Create_func_convert_tz)}, + { C_STRING_WITH_LEN("COS"), BUILDER(Create_func_cos)}, + { C_STRING_WITH_LEN("COT"), BUILDER(Create_func_cot)}, + { C_STRING_WITH_LEN("CRC32"), BUILDER(Create_func_crc32)}, + { C_STRING_WITH_LEN("CROSSES"), GEOM_BUILDER(Create_func_crosses)}, + { C_STRING_WITH_LEN("DATEDIFF"), BUILDER(Create_func_datediff)}, + { C_STRING_WITH_LEN("DATE_FORMAT"), BUILDER(Create_func_date_format)}, + { C_STRING_WITH_LEN("DAYNAME"), BUILDER(Create_func_dayname)}, + { C_STRING_WITH_LEN("DAYOFMONTH"), BUILDER(Create_func_dayofmonth)}, + { C_STRING_WITH_LEN("DAYOFWEEK"), BUILDER(Create_func_dayofweek)}, + { C_STRING_WITH_LEN("DAYOFYEAR"), BUILDER(Create_func_dayofyear)}, + { C_STRING_WITH_LEN("DECODE"), BUILDER(Create_func_decode)}, + { C_STRING_WITH_LEN("DEGREES"), BUILDER(Create_func_degrees)}, + { C_STRING_WITH_LEN("DES_DECRYPT"), BUILDER(Create_func_des_decrypt)}, + { C_STRING_WITH_LEN("DES_ENCRYPT"), BUILDER(Create_func_des_encrypt)}, + { C_STRING_WITH_LEN("DIMENSION"), GEOM_BUILDER(Create_func_dimension)}, + { C_STRING_WITH_LEN("DISJOINT"), GEOM_BUILDER(Create_func_disjoint)}, + { C_STRING_WITH_LEN("ELT"), BUILDER(Create_func_elt)}, + { C_STRING_WITH_LEN("ENCODE"), BUILDER(Create_func_encode)}, + { C_STRING_WITH_LEN("ENCRYPT"), BUILDER(Create_func_encrypt)}, + { C_STRING_WITH_LEN("ENDPOINT"), GEOM_BUILDER(Create_func_endpoint)}, + { C_STRING_WITH_LEN("ENVELOPE"), GEOM_BUILDER(Create_func_envelope)}, + { C_STRING_WITH_LEN("EQUALS"), GEOM_BUILDER(Create_func_equals)}, + { C_STRING_WITH_LEN("EXP"), BUILDER(Create_func_exp)}, + { C_STRING_WITH_LEN("EXPORT_SET"), BUILDER(Create_func_export_set)}, + { C_STRING_WITH_LEN("EXTERIORRING"), GEOM_BUILDER(Create_func_exteriorring)}, + { C_STRING_WITH_LEN("EXTRACTVALUE"), BUILDER(Create_func_xml_extractvalue)}, + { C_STRING_WITH_LEN("FIELD"), BUILDER(Create_func_field)}, + { C_STRING_WITH_LEN("FIND_IN_SET"), BUILDER(Create_func_find_in_set)}, + { C_STRING_WITH_LEN("FLOOR"), BUILDER(Create_func_floor)}, + { C_STRING_WITH_LEN("FORMAT"), BUILDER(Create_func_format)}, + { C_STRING_WITH_LEN("FOUND_ROWS"), BUILDER(Create_func_found_rows)}, + { C_STRING_WITH_LEN("FROM_DAYS"), BUILDER(Create_func_from_days)}, + { C_STRING_WITH_LEN("FROM_UNIXTIME"), BUILDER(Create_func_from_unixtime)}, + { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMCOLLFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMETRYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYN"), GEOM_BUILDER(Create_func_geometryn)}, + { C_STRING_WITH_LEN("GEOMETRYTYPE"), GEOM_BUILDER(Create_func_geometry_type)}, + { C_STRING_WITH_LEN("GEOMFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GET_LOCK"), BUILDER(Create_func_get_lock)}, + { C_STRING_WITH_LEN("GLENGTH"), GEOM_BUILDER(Create_func_glength)}, + { C_STRING_WITH_LEN("GREATEST"), BUILDER(Create_func_greatest)}, + { C_STRING_WITH_LEN("HEX"), BUILDER(Create_func_hex)}, + { C_STRING_WITH_LEN("IFNULL"), BUILDER(Create_func_ifnull)}, + { C_STRING_WITH_LEN("INET_ATON"), BUILDER(Create_func_inet_aton)}, + { C_STRING_WITH_LEN("INET_NTOA"), BUILDER(Create_func_inet_ntoa)}, + { C_STRING_WITH_LEN("INSTR"), BUILDER(Create_func_instr)}, + { C_STRING_WITH_LEN("INTERIORRINGN"), GEOM_BUILDER(Create_func_interiorringn)}, + { C_STRING_WITH_LEN("INTERSECTS"), GEOM_BUILDER(Create_func_intersects)}, + { C_STRING_WITH_LEN("ISCLOSED"), GEOM_BUILDER(Create_func_isclosed)}, + { C_STRING_WITH_LEN("ISEMPTY"), GEOM_BUILDER(Create_func_isempty)}, + { C_STRING_WITH_LEN("ISNULL"), BUILDER(Create_func_isnull)}, + { C_STRING_WITH_LEN("ISSIMPLE"), GEOM_BUILDER(Create_func_issimple)}, + { C_STRING_WITH_LEN("IS_FREE_LOCK"), BUILDER(Create_func_is_free_lock)}, + { C_STRING_WITH_LEN("IS_USED_LOCK"), BUILDER(Create_func_is_used_lock)}, + { C_STRING_WITH_LEN("LAST_DAY"), BUILDER(Create_func_last_day)}, + { C_STRING_WITH_LEN("LAST_INSERT_ID"), BUILDER(Create_func_last_insert_id)}, + { C_STRING_WITH_LEN("LCASE"), BUILDER(Create_func_lcase)}, + { C_STRING_WITH_LEN("LEAST"), BUILDER(Create_func_least)}, + { C_STRING_WITH_LEN("LENGTH"), BUILDER(Create_func_length)}, + { C_STRING_WITH_LEN("LINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("LINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("LINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("LINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("LN"), BUILDER(Create_func_ln)}, + { C_STRING_WITH_LEN("LOAD_FILE"), BUILDER(Create_func_load_file)}, + { C_STRING_WITH_LEN("LOCATE"), BUILDER(Create_func_locate)}, + { C_STRING_WITH_LEN("LOG"), BUILDER(Create_func_log)}, + { C_STRING_WITH_LEN("LOG10"), BUILDER(Create_func_log10)}, + { C_STRING_WITH_LEN("LOG2"), BUILDER(Create_func_log2)}, + { C_STRING_WITH_LEN("LOWER"), BUILDER(Create_func_lcase)}, + { C_STRING_WITH_LEN("LPAD"), BUILDER(Create_func_lpad)}, + { C_STRING_WITH_LEN("LTRIM"), BUILDER(Create_func_ltrim)}, + { C_STRING_WITH_LEN("MAKEDATE"), BUILDER(Create_func_makedate)}, + { C_STRING_WITH_LEN("MAKETIME"), BUILDER(Create_func_maketime)}, + { C_STRING_WITH_LEN("MAKE_SET"), BUILDER(Create_func_make_set)}, + { C_STRING_WITH_LEN("MASTER_POS_WAIT"), BUILDER(Create_func_master_pos_wait)}, + { C_STRING_WITH_LEN("MBRCONTAINS"), GEOM_BUILDER(Create_func_contains)}, + { C_STRING_WITH_LEN("MD5"), BUILDER(Create_func_md5)}, + { C_STRING_WITH_LEN("MLINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MLINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MONTHNAME"), BUILDER(Create_func_monthname)}, + { C_STRING_WITH_LEN("MPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MPOLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MPOLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTIPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("NAME_CONST"), BUILDER(Create_func_name_const)}, + { C_STRING_WITH_LEN("NULLIF"), BUILDER(Create_func_nullif)}, + { C_STRING_WITH_LEN("NUMGEOMETRIES"), GEOM_BUILDER(Create_func_numgeometries)}, + { C_STRING_WITH_LEN("NUMINTERIORRINGS"), GEOM_BUILDER(Create_func_numinteriorring)}, + { C_STRING_WITH_LEN("NUMPOINTS"), GEOM_BUILDER(Create_func_numpoints)}, + { C_STRING_WITH_LEN("OCT"), BUILDER(Create_func_oct)}, + { C_STRING_WITH_LEN("OCTET_LENGTH"), BUILDER(Create_func_length)}, + { C_STRING_WITH_LEN("ORD"), BUILDER(Create_func_ord)}, + { C_STRING_WITH_LEN("OVERLAPS"), GEOM_BUILDER(Create_func_overlaps)}, + { C_STRING_WITH_LEN("PERIOD_ADD"), BUILDER(Create_func_period_add)}, + { C_STRING_WITH_LEN("PERIOD_DIFF"), BUILDER(Create_func_period_diff)}, + { C_STRING_WITH_LEN("PI"), BUILDER(Create_func_pi)}, + { C_STRING_WITH_LEN("POINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POINTN"), GEOM_BUILDER(Create_func_pointn)}, + { C_STRING_WITH_LEN("POLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POW"), BUILDER(Create_func_pow)}, + { C_STRING_WITH_LEN("POWER"), BUILDER(Create_func_pow)}, + { C_STRING_WITH_LEN("QUOTE"), BUILDER(Create_func_quote)}, + { C_STRING_WITH_LEN("RADIANS"), BUILDER(Create_func_radians)}, + { C_STRING_WITH_LEN("RAND"), BUILDER(Create_func_rand)}, + { C_STRING_WITH_LEN("RELEASE_LOCK"), BUILDER(Create_func_release_lock)}, + { C_STRING_WITH_LEN("REVERSE"), BUILDER(Create_func_reverse)}, + { C_STRING_WITH_LEN("ROUND"), BUILDER(Create_func_round)}, + { C_STRING_WITH_LEN("ROW_COUNT"), BUILDER(Create_func_row_count)}, + { C_STRING_WITH_LEN("RPAD"), BUILDER(Create_func_rpad)}, + { C_STRING_WITH_LEN("RTRIM"), BUILDER(Create_func_rtrim)}, + { C_STRING_WITH_LEN("SEC_TO_TIME"), BUILDER(Create_func_sec_to_time)}, + { C_STRING_WITH_LEN("SHA"), BUILDER(Create_func_sha)}, + { C_STRING_WITH_LEN("SHA1"), BUILDER(Create_func_sha)}, + { C_STRING_WITH_LEN("SIGN"), BUILDER(Create_func_sign)}, + { C_STRING_WITH_LEN("SIN"), BUILDER(Create_func_sin)}, + { C_STRING_WITH_LEN("SLEEP"), BUILDER(Create_func_sleep)}, + { C_STRING_WITH_LEN("SOUNDEX"), BUILDER(Create_func_soundex)}, + { C_STRING_WITH_LEN("SPACE"), BUILDER(Create_func_space)}, + { C_STRING_WITH_LEN("SQRT"), BUILDER(Create_func_sqrt)}, + { C_STRING_WITH_LEN("SRID"), GEOM_BUILDER(Create_func_srid)}, + { C_STRING_WITH_LEN("STARTPOINT"), GEOM_BUILDER(Create_func_startpoint)}, + { C_STRING_WITH_LEN("STRCMP"), BUILDER(Create_func_strcmp)}, + { C_STRING_WITH_LEN("STR_TO_DATE"), BUILDER(Create_func_str_to_date)}, + { C_STRING_WITH_LEN("SUBSTRING_INDEX"), BUILDER(Create_func_substr_index)}, + { C_STRING_WITH_LEN("SUBTIME"), BUILDER(Create_func_subtime)}, + { C_STRING_WITH_LEN("TAN"), BUILDER(Create_func_tan)}, + { C_STRING_WITH_LEN("TIMEDIFF"), BUILDER(Create_func_timediff)}, + { C_STRING_WITH_LEN("TIME_FORMAT"), BUILDER(Create_func_time_format)}, + { C_STRING_WITH_LEN("TIME_TO_SEC"), BUILDER(Create_func_time_to_sec)}, + { C_STRING_WITH_LEN("TOUCHES"), GEOM_BUILDER(Create_func_touches)}, + { C_STRING_WITH_LEN("TO_DAYS"), BUILDER(Create_func_to_days)}, + { C_STRING_WITH_LEN("UCASE"), BUILDER(Create_func_ucase)}, + { C_STRING_WITH_LEN("UNCOMPRESS"), BUILDER(Create_func_uncompress)}, + { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH"), BUILDER(Create_func_uncompressed_length)}, + { C_STRING_WITH_LEN("UNHEX"), BUILDER(Create_func_unhex)}, + { C_STRING_WITH_LEN("UNIX_TIMESTAMP"), BUILDER(Create_func_unix_timestamp)}, + { C_STRING_WITH_LEN("UPDATEXML"), BUILDER(Create_func_xml_update)}, + { C_STRING_WITH_LEN("UPPER"), BUILDER(Create_func_ucase)}, + { C_STRING_WITH_LEN("UUID"), BUILDER(Create_func_uuid)}, + { C_STRING_WITH_LEN("VERSION"), BUILDER(Create_func_version)}, + { C_STRING_WITH_LEN("WEEKDAY"), BUILDER(Create_func_weekday)}, + { C_STRING_WITH_LEN("WEEKOFYEAR"), BUILDER(Create_func_weekofyear)}, + { C_STRING_WITH_LEN("WITHIN"), GEOM_BUILDER(Create_func_within)}, + { C_STRING_WITH_LEN("X"), GEOM_BUILDER(Create_func_x)}, + { C_STRING_WITH_LEN("Y"), GEOM_BUILDER(Create_func_y)}, + { C_STRING_WITH_LEN("YEARWEEK"), BUILDER(Create_func_year_week)}, + + { {0, 0}, NULL} +}; + +static HASH native_functions_hash; + +extern "C" byte* +get_native_fct_hash_key(const byte *buff, uint *length, my_bool /* unused */) +{ + native_func_registry *func= (native_func_registry*) buff; + *length= func->name.length; + return (byte*) func->name.str; +} + +/* + Load the hash table for native functions. + Note: this code is not thread safe, and is intended to be used at server + startup only (before going multi-threaded) +*/ + +int item_create_init() +{ + native_func_registry *func; + + DBUG_ENTER("item_create_init"); + + if (hash_init(& native_functions_hash, + system_charset_info, + array_elements(func_array), + 0, + 0, + (hash_get_key) get_native_fct_hash_key, + NULL, /* Nothing to free */ + MYF(0))) + DBUG_RETURN(1); + + for (func= func_array; func->builder != NULL; func++) + { + if (my_hash_insert(& native_functions_hash, (byte*) func)) + DBUG_RETURN(1); + } + +#ifndef DBUG_OFF + for (uint i=0 ; i < native_functions_hash.records ; i++) + { + func= (native_func_registry*) hash_element(& native_functions_hash, i); + DBUG_PRINT("info", ("native function %s, length %d", + func->name.str, func->name.length)); + } +#endif + + DBUG_RETURN(0); +} + +/* + Empty the hash table for native functions. + Note: this code is not thread safe, and is intended to be used at server + shutdown only (after thread requests have been executed). +*/ + +void item_create_cleanup() +{ + DBUG_ENTER("item_create_cleanup"); + hash_free(& native_functions_hash); + DBUG_VOID_RETURN; +} + +Create_func * +find_native_function_builder(THD *thd, LEX_STRING name) +{ + native_func_registry *func; + Create_func *builder= NULL; + + /* Thread safe */ + func= (native_func_registry*) hash_search(& native_functions_hash, + (byte*) name.str, + name.length); + + if (func) + { + builder= func->builder; + } + + return builder; +} + +Create_qfunc * +find_qualified_function_builder(THD *thd) +{ + return & Create_sp_func::s_singleton; +} + +Item* +create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec, + CHARSET_INFO *cs) +{ + Item *res; + LINT_INIT(res); + + switch (cast_type) + { + case ITEM_CAST_BINARY: + res= new (thd->mem_root) Item_func_binary(a); + break; + case ITEM_CAST_SIGNED_INT: + res= new (thd->mem_root) Item_func_signed(a); + break; + case ITEM_CAST_UNSIGNED_INT: + res= new (thd->mem_root) Item_func_unsigned(a); + break; + case ITEM_CAST_DATE: + res= new (thd->mem_root) Item_date_typecast(a); + break; + case ITEM_CAST_TIME: + res= new (thd->mem_root) Item_time_typecast(a); + break; + case ITEM_CAST_DATETIME: + res= new (thd->mem_root) Item_datetime_typecast(a); + break; + case ITEM_CAST_DECIMAL: + { + int tmp_len= (len>0) ? len : 10; + if (tmp_len < dec) + { + my_error(ER_M_BIGGER_THAN_D, MYF(0), ""); + return 0; + } + res= new (thd->mem_root) Item_decimal_typecast(a, tmp_len, dec); + break; + } + case ITEM_CAST_CHAR: + { + CHARSET_INFO *real_cs= (cs ? cs : thd->variables.collation_connection); + res= new (thd->mem_root) Item_char_typecast(a, len, real_cs); + break; + } + default: + { + DBUG_ASSERT(0); + res= 0; + break; + } + } + return res; +} + --- 1.45/sql/item_create.h 2006-10-27 14:45:04 -07:00 +++ 1.46/sql/item_create.h 2006-10-27 14:45:04 -07:00 @@ -14,148 +14,151 @@ 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 */ + +#ifndef ITEM_CREATE_H +#define ITEM_CREATE_H + +/** + Public function builder interface. + The parser (sql/sql_yacc.yy) uses a factory / builder pattern to + construct an <code>Item</code> object for each function call. + All the concrete function builders implements this interface, + either directly or indirectly with some adapter helpers. + Keeping the function creation separated from the bison grammar allows + to simplify the parser, and avoid the need to introduce a new token + for each function, which has undesirable side effects in the grammar. +*/ +class Create_func +{ +public: + /** + The builder create method. + Given the function name and list or arguments, this method creates + an <code>Item</code> that represents the function call. + In case or errors, a NULL item is returned, and an error is reported. + Note that the <code>thd</code> object may be modified by the builder. + In particular, the following members/methods can be set/called, + depending on the function called and the function possible side effects. + <ul> + <li><code>thd->lex->binlog_row_based_if_mixed</code></li> + <li><code>thd->lex->current_context()</code></li> + <li><code>thd->lex->safe_to_cache_query</code></li> + <li><code>thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT)</code></li> + <li><code>thd->lex->uncacheable(UNCACHEABLE_RAND)</code></li> + <li><code>thd->lex->add_time_zone_tables_to_query_tables(thd)</code></li> + </ul> + @param thd The current thread + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call, or NULL + */ + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list) = 0; + +protected: + /** Constructor */ + Create_func() {} + /** Destructor */ + virtual ~Create_func() {} +}; + + +/** + Function builder for qualified functions. + This builder is used with functions call using a qualified function name + syntax, as in <code>db.func(expr, expr, ...)</code>. +*/ +class Create_qfunc : public Create_func +{ +public: + /** + The builder create method, for unqualified functions. + This builder will use the current database for the database name. + @param thd The current thread + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + The builder create method, for qualified functions. + @param thd The current thread + @param db The database name + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list) = 0; + +protected: + /** Constructor. */ + Create_qfunc() {} + /** Destructor. */ + virtual ~Create_qfunc() {} +}; + + +/** + Find the native function builder associated with a given function name. + @param thd The current thread + @param name The native function name + @return The native function builder associated with the name, or NULL +*/ +extern Create_func * find_native_function_builder(THD *thd, LEX_STRING name); + + +/** + Find the function builder for qualified functions. + @param thd The current thread + @return A function builder for qualified functions +*/ +extern Create_qfunc * find_qualified_function_builder(THD *thd); + + +#ifdef HAVE_DLOPEN +/** + Function builder for User Defined Functions. +*/ +class Create_udf_func : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + The builder create method, for User Defined Functions. + @param thd The current thread + @param fct The User Defined Function metadata + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + Item* create(THD *thd, udf_func *fct, List<Item> *item_list); + + /** Singleton. */ + static Create_udf_func s_singleton; + +protected: + /** Constructor. */ + Create_udf_func() {} + /** Destructor. */ + virtual ~Create_udf_func() {} +}; +#endif + + +/** + Builder for cast expressions. + @param thd The current thread + @param a The item to cast + @param cast_type the type casted into + @param len TODO + @param dec TODO + @param cs The character set +*/ +Item* +create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec, + CHARSET_INFO *cs); + +#endif -Item *create_func_abs(Item* a); -Item *create_func_acos(Item* a); -Item *create_func_aes_encrypt(Item* a, Item* b); -Item *create_func_aes_decrypt(Item* a, Item* b); -Item *create_func_ascii(Item* a); -Item *create_func_asin(Item* a); -Item *create_func_bin(Item* a); -Item *create_func_bit_count(Item* a); -Item *create_func_bit_length(Item* a); -Item *create_func_coercibility(Item* a); -Item *create_func_ceiling(Item* a); -Item *create_func_char_length(Item* a); -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs); -Item *create_func_connection_id(void); -Item *create_func_conv(Item* a, Item *b, Item *c); -Item *create_func_cos(Item* a); -Item *create_func_cot(Item* a); -Item *create_func_crc32(Item* a); -Item *create_func_date_format(Item* a,Item *b); -Item *create_func_dayname(Item* a); -Item *create_func_dayofmonth(Item* a); -Item *create_func_dayofweek(Item* a); -Item *create_func_dayofyear(Item* a); -Item *create_func_degrees(Item *); -Item *create_func_exp(Item* a); -Item *create_func_find_in_set(Item* a, Item *b); -Item *create_func_floor(Item* a); -Item *create_func_found_rows(void); -Item *create_func_from_days(Item* a); -Item *create_func_get_lock(Item* a, Item *b); -Item *create_func_hex(Item *a); -Item *create_func_inet_aton(Item* a); -Item *create_func_inet_ntoa(Item* a); - -Item *create_func_ifnull(Item* a, Item *b); -Item *create_func_instr(Item* a, Item *b); -Item *create_func_isnull(Item* a); -Item *create_func_lcase(Item* a); -Item *create_func_length(Item* a); -Item *create_func_ln(Item* a); -Item *create_func_locate(Item* a, Item *b); -Item *create_func_log2(Item* a); -Item *create_func_log10(Item* a); -Item *create_func_lpad(Item* a, Item *b, Item *c); -Item *create_func_ltrim(Item* a); -Item *create_func_md5(Item* a); -Item *create_func_mod(Item* a, Item *b); -Item *create_func_monthname(Item* a); -Item *create_func_name_const(Item *a, Item *b); -Item *create_func_nullif(Item* a, Item *b); -Item *create_func_oct(Item *); -Item *create_func_ord(Item* a); -Item *create_func_period_add(Item* a, Item *b); -Item *create_func_period_diff(Item* a, Item *b); -Item *create_func_pi(void); -Item *create_func_pow(Item* a, Item *b); -Item *create_func_radians(Item *a); -Item *create_func_release_lock(Item* a); -Item *create_func_repeat(Item* a, Item *b); -Item *create_func_reverse(Item* a); -Item *create_func_rpad(Item* a, Item *b, Item *c); -Item *create_func_rtrim(Item* a); -Item *create_func_sec_to_time(Item* a); -Item *create_func_sign(Item* a); -Item *create_func_sin(Item* a); -Item *create_func_sha(Item* a); -Item *create_func_sleep(Item* a); -Item *create_func_soundex(Item* a); -Item *create_func_space(Item *); -Item *create_func_sqrt(Item* a); -Item *create_func_strcmp(Item* a, Item *b); -Item *create_func_tan(Item* a); -Item *create_func_time_format(Item *a, Item *b); -Item *create_func_time_to_sec(Item* a); -Item *create_func_to_days(Item* a); -Item *create_func_ucase(Item* a); -Item *create_func_unhex(Item* a); -Item *create_func_uuid(void); -Item *create_func_version(void); -Item *create_func_weekday(Item* a); -Item *create_load_file(Item* a); -Item *create_func_is_free_lock(Item* a); -Item *create_func_is_used_lock(Item* a); -Item *create_func_quote(Item* a); -Item *create_func_xml_extractvalue(Item *a, Item *b); -Item *create_func_xml_update(Item *a, Item *b, Item *c); -#ifdef HAVE_SPATIAL - -Item *create_func_geometry_from_text(Item *a); -Item *create_func_as_wkt(Item *a); -Item *create_func_as_wkb(Item *a); -Item *create_func_srid(Item *a); -Item *create_func_startpoint(Item *a); -Item *create_func_endpoint(Item *a); -Item *create_func_exteriorring(Item *a); -Item *create_func_centroid(Item *a); -Item *create_func_envelope(Item *a); -Item *create_func_pointn(Item *a, Item *b); -Item *create_func_interiorringn(Item *a, Item *b); -Item *create_func_geometryn(Item *a, Item *b); - -Item *create_func_equals(Item *a, Item *b); -Item *create_func_disjoint(Item *a, Item *b); -Item *create_func_intersects(Item *a, Item *b); -Item *create_func_touches(Item *a, Item *b); -Item *create_func_crosses(Item *a, Item *b); -Item *create_func_within(Item *a, Item *b); -Item *create_func_contains(Item *a, Item *b); -Item *create_func_overlaps(Item *a, Item *b); - -Item *create_func_isempty(Item *a); -Item *create_func_issimple(Item *a); -Item *create_func_isclosed(Item *a); - -Item *create_func_geometry_type(Item *a); -Item *create_func_dimension(Item *a); -Item *create_func_x(Item *a); -Item *create_func_y(Item *a); -Item *create_func_area(Item *a); -Item *create_func_glength(Item *a); - -Item *create_func_numpoints(Item *a); -Item *create_func_numinteriorring(Item *a); -Item *create_func_numgeometries(Item *a); - -Item *create_func_point(Item *a, Item *b); - -#endif /*HAVE_SPATIAL*/ - -Item *create_func_compress(Item *a); -Item *create_func_uncompress(Item *a); -Item *create_func_uncompressed_length(Item *a); - -Item *create_func_datediff(Item *a, Item *b); -Item *create_func_weekofyear(Item *a); -Item *create_func_makedate(Item* a,Item* b); -Item *create_func_addtime(Item* a,Item* b); -Item *create_func_subtime(Item* a,Item* b); -Item *create_func_timediff(Item* a,Item* b); -Item *create_func_maketime(Item* a,Item* b,Item* c); -Item *create_func_str_to_date(Item* a,Item* b); -Item *create_func_last_day(Item *a); --- 1.164/sql/lex.h 2006-10-27 14:45:04 -07:00 +++ 1.165/sql/lex.h 2006-10-27 14:45:04 -07:00 @@ -30,16 +30,7 @@ SYM_GROUP sym_group_rtree= {"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)} }; --- 1.7/sql/lex_symbol.h 2006-10-27 14:45:04 -07:00 +++ 1.8/sql/lex_symbol.h 2006-10-27 14:45:04 -07:00 @@ -26,7 +26,6 @@ typedef struct st_symbol { const char *name; uint tok; uint length; - void *create_func; struct st_sym_group *group; } SYMBOL; --- 1.452/sql/mysql_priv.h 2006-10-27 14:45:04 -07:00 +++ 1.453/sql/mysql_priv.h 2006-10-27 14:45:04 -07:00 @@ -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 */ --- 1.583/sql/mysqld.cc 2006-10-27 14:45:04 -07:00 +++ 1.584/sql/mysqld.cc 2006-10-27 14:45:04 -07:00 @@ -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 c return 1; init_client_errs(); lex_init(); + if (item_create_init()) + return 1; item_init(); set_var_init(); mysys_uses_curses=0; --- 1.510/sql/sql_yacc.yy 2006-10-27 14:45:04 -07:00 +++ 1.511/sql/sql_yacc.yy 2006-10-27 14:45:05 -07:00 @@ -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 ** %pure_parser /* We have threads */ -%token END_OF_INPUT +/* + Comments for TOKENS. + For each token, please include in the same line a comment that contains + the following tags: + SQL-2003-R : Reserved keyword as per SQL-2003 + SQL-2003-N : Non Reserved keyword as per SQL-2003 + SQL-1999-R : Reserved keyword as per SQL-1999 + SQL-1999-N : Non Reserved keyword as per SQL-1999 + MYSQL : MySQL extention (unspecified) + MYSQL-FUNC : MySQL extention, function + INTERNAL : Not a real token, lex optimization + OPERATOR : SQL operator + FUTURE-USE : Reserved for futur use + + This makes the code grep-able, and helps maintenance. +*/ -%token ABORT_SYM +%token ABORT_SYM /* INTERNAL (used in lex) */ %token ACCESSIBLE_SYM -%token ACTION -%token ADD -%token ADDDATE_SYM -%token AFTER_SYM +%token ACTION /* SQL-2003-N */ +%token ADD /* SQL-2003-R */ +%token ADDDATE_SYM /* MYSQL-FUNC */ +%token AFTER_SYM /* SQL-2003-N */ %token AGAINST %token AGGREGATE_SYM %token ALGORITHM_SYM -%token ALL -%token ALTER +%token ALL /* SQL-2003-R */ +%token ALTER /* SQL-2003-R */ %token ANALYZE_SYM -%token AND_AND_SYM -%token AND_SYM -%token ANY_SYM -%token AS -%token ASC -%token ASCII_SYM -%token ASENSITIVE_SYM -%token AT_SYM -%token ATAN +%token AND_AND_SYM /* OPERATOR */ +%token AND_SYM /* SQL-2003-R */ +%token ANY_SYM /* SQL-2003-R */ +%token AS /* SQL-2003-R */ +%token ASC /* SQL-2003-N */ +%token ASCII_SYM /* MYSQL-FUNC */ +%token ASENSITIVE_SYM /* FUTURE-USE */ +%token AT_SYM /* SQL-2003-R */ %token AUTHORS_SYM -%token AUTO_INC %token AUTOEXTEND_SIZE_SYM +%token AUTO_INC %token AVG_ROW_LENGTH -%token AVG_SYM +%token AVG_SYM /* SQL-2003-N */ %token BACKUP_SYM -%token BEFORE_SYM -%token BEGIN_SYM -%token BENCHMARK_SYM -%token BIGINT -%token BINARY +%token BEFORE_SYM /* SQL-2003-N */ +%token BEGIN_SYM /* SQL-2003-R */ +%token BETWEEN_SYM /* SQL-2003-R */ +%token BIGINT /* SQL-2003-R */ +%token BINARY /* SQL-2003-R */ %token BINLOG_SYM %token BIN_NUM -%token BIT_AND -%token BIT_OR -%token BIT_SYM -%token BIT_XOR -%token BLOB_SYM -%token BOOLEAN_SYM +%token BIT_AND /* MYSQL-FUNC */ +%token BIT_OR /* MYSQL-FUNC */ +%token BIT_SYM /* MYSQL-FUNC */ +%token BIT_XOR /* MYSQL-FUNC */ +%token BLOB_SYM /* SQL-2003-R */ +%token BOOLEAN_SYM /* SQL-2003-R */ %token BOOL_SYM -%token BOTH +%token BOTH /* SQL-2003-R */ %token BTREE_SYM -%token BY +%token BY /* SQL-2003-R */ %token BYTE_SYM %token CACHE_SYM -%token CALL_SYM -%token CASCADE -%token CASCADED -%token CAST_SYM -%token CHAIN_SYM +%token CALL_SYM /* SQL-2003-R */ +%token CASCADE /* SQL-2003-N */ +%token CASCADED /* SQL-2003-R */ +%token CASE_SYM /* SQL-2003-R */ +%token CAST_SYM /* SQL-2003-R */ +%token CHAIN_SYM /* SQL-2003-N */ %token CHANGE %token CHANGED %token CHARSET -%token CHAR_SYM +%token CHAR_SYM /* SQL-2003-R */ %token CHECKSUM_SYM -%token CHECK_SYM +%token CHECK_SYM /* SQL-2003-R */ %token CIPHER_SYM %token CLIENT_SYM -%token CLOSE_SYM -%token COALESCE +%token CLOSE_SYM /* SQL-2003-R */ +%token COALESCE /* SQL-2003-N */ %token CODE_SYM -%token COLLATE_SYM -%token COLLATION_SYM +%token COLLATE_SYM /* SQL-2003-R */ +%token COLLATION_SYM /* SQL-2003-N */ %token COLUMNS -%token COLUMN_SYM +%token COLUMN_SYM /* SQL-2003-R */ %token COMMENT_SYM -%token COMMITTED_SYM -%token COMMIT_SYM +%token COMMITTED_SYM /* SQL-2003-N */ +%token COMMIT_SYM /* SQL-2003-R */ %token COMPACT_SYM %token COMPLETION_SYM %token COMPRESSED_SYM -%token CONCAT -%token CONCAT_WS %token CONCURRENT -%token CONDITION_SYM +%token CONDITION_SYM /* SQL-2003-N */ %token CONNECTION_SYM %token CONSISTENT_SYM -%token CONSTRAINT -%token CONTAINS_SYM -%token CONTINUE_SYM +%token CONSTRAINT /* SQL-2003-R */ +%token CONTAINS_SYM /* SQL-2003-N */ +%token CONTINUE_SYM /* SQL-2003-R */ %token CONTRIBUTORS_SYM -%token CONVERT_SYM -%token CONVERT_TZ_SYM -%token COUNT_SYM -%token CREATE -%token CROSS -%token CUBE_SYM -%token CURDATE -%token CURRENT_USER -%token CURSOR_SYM -%token CURTIME +%token CONVERT_SYM /* SQL-2003-N */ +%token COUNT_SYM /* SQL-2003-N */ +%token CREATE /* SQL-2003-R */ +%token CROSS /* SQL-2003-R */ +%token CUBE_SYM /* SQL-2003-R */ +%token CURDATE /* MYSQL-FUNC */ +%token CURRENT_USER /* SQL-2003-R */ +%token CURSOR_SYM /* SQL-2003-R */ +%token CURTIME /* MYSQL-FUNC */ %token DATABASE %token DATABASES %token DATAFILE_SYM -%token DATA_SYM +%token DATA_SYM /* SQL-2003-N */ %token DATETIME -%token DATE_ADD_INTERVAL -%token DATE_SUB_INTERVAL -%token DATE_SYM +%token DATE_ADD_INTERVAL /* MYSQL-FUNC */ +%token DATE_SUB_INTERVAL /* MYSQL-FUNC */ +%token DATE_SYM /* SQL-2003-R */ %token DAY_HOUR_SYM %token DAY_MICROSECOND_SYM %token DAY_MINUTE_SYM %token DAY_SECOND_SYM -%token DAY_SYM -%token DEALLOCATE_SYM +%token DAY_SYM /* SQL-2003-R */ +%token DEALLOCATE_SYM /* SQL-2003-R */ %token DECIMAL_NUM -%token DECIMAL_SYM -%token DECLARE_SYM -%token DECODE_SYM -%token DEFAULT +%token DECIMAL_SYM /* SQL-2003-R */ +%token DECLARE_SYM /* SQL-2003-R */ +%token DEFAULT /* SQL-2003-R */ %token DEFINER_SYM %token DELAYED_SYM %token DELAY_KEY_WRITE_SYM -%token DELETE_SYM -%token DESC -%token DESCRIBE -%token DES_DECRYPT_SYM -%token DES_ENCRYPT_SYM +%token DELETE_SYM /* SQL-2003-R */ +%token DESC /* SQL-2003-N */ +%token DESCRIBE /* SQL-2003-R */ %token DES_KEY_FILE -%token DETERMINISTIC_SYM +%token DETERMINISTIC_SYM /* SQL-2003-R */ %token DIRECTORY_SYM %token DISABLE_SYM %token DISCARD %token DISK_SYM -%token DISTINCT +%token DISTINCT /* SQL-2003-R */ %token DIV_SYM -%token DOUBLE_SYM +%token DOUBLE_SYM /* SQL-2003-R */ %token DO_SYM -%token DROP +%token DROP /* SQL-2003-R */ %token DUAL_SYM %token DUMPFILE %token DUPLICATE_SYM -%token DYNAMIC_SYM -%token EACH_SYM +%token DYNAMIC_SYM /* SQL-2003-R */ +%token EACH_SYM /* SQL-2003-R */ +%token ELSE /* SQL-2003-R */ %token ELSEIF_SYM -%token ELT_FUNC %token ENABLE_SYM %token ENCLOSED -%token ENCODE_SYM -%token ENCRYPT -%token END +%token END /* SQL-2003-R */ %token ENDS_SYM +%token END_OF_INPUT /* INTERNAL */ %token ENGINES_SYM %token ENGINE_SYM %token ENUM -%token EQ -%token EQUAL_SYM +%token EQ /* OPERATOR */ +%token EQUAL_SYM /* OPERATOR */ %token ERRORS %token ESCAPED -%token ESCAPE_SYM -%token EVENT_SYM +%token ESCAPE_SYM /* SQL-2003-R */ %token EVENTS_SYM -%token EVERY_SYM -%token EXECUTE_SYM -%token EXISTS +%token EVENT_SYM +%token EVERY_SYM /* SQL-2003-N */ +%token EXECUTE_SYM /* SQL-2003-R */ +%token EXISTS /* SQL-2003-R */ %token EXIT_SYM %token EXPANSION_SYM -%token EXPORT_SET %token EXTENDED_SYM %token EXTENT_SIZE_SYM -%token EXTRACT_SYM -%token FALSE_SYM +%token EXTRACT_SYM /* SQL-2003-N */ +%token FALSE_SYM /* SQL-2003-R */ %token FAST_SYM -%token FETCH_SYM -%token FIELD_FUNC +%token FETCH_SYM /* SQL-2003-R */ %token FILE_SYM -%token FIRST_SYM +%token FIRST_SYM /* SQL-2003-N */ %token FIXED_SYM %token FLOAT_NUM -%token FLOAT_SYM +%token FLOAT_SYM /* SQL-2003-R */ %token FLUSH_SYM %token FORCE_SYM -%token FOREIGN -%token FORMAT_SYM -%token FOR_SYM -%token FOUND_SYM +%token FOREIGN /* SQL-2003-R */ +%token FOR_SYM /* SQL-2003-R */ +%token FOUND_SYM /* SQL-2003-R */ %token FRAC_SECOND_SYM %token FROM -%token FROM_UNIXTIME -%token FULL +%token FULL /* SQL-2003-R */ %token FULLTEXT_SYM -%token FUNCTION_SYM -%token FUNC_ARG0 -%token FUNC_ARG1 -%token FUNC_ARG2 -%token FUNC_ARG3 +%token FUNCTION_SYM /* SQL-2003-R */ %token GE -%token GEOMCOLLFROMTEXT %token GEOMETRYCOLLECTION %token GEOMETRY_SYM -%token GEOMFROMTEXT -%token GEOMFROMWKB -%token GET_FORMAT -%token GLOBAL_SYM -%token GRANT +%token GET_FORMAT /* MYSQL-FUNC */ +%token GLOBAL_SYM /* SQL-2003-R */ +%token GRANT /* SQL-2003-R */ %token GRANTS -%token GREATEST_SYM -%token GROUP +%token GROUP /* SQL-2003-R */ %token GROUP_CONCAT_SYM %token GROUP_UNIQUE_USERS -%token GT_SYM +%token GT_SYM /* OPERATOR */ %token HANDLER_SYM %token HASH_SYM -%token HAVING +%token HAVING /* SQL-2003-R */ %token HELP_SYM %token HEX_NUM %token HIGH_PRIORITY @@ -356,7 +357,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** %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 ** %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 ** %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 ** %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 ** simple_ident_nospvar simple_ident_q field_or_var limit_option part_func_expr + function_call_keyword + function_call_nonkeyword + function_call_generic + function_call_conflict %type <item_num> NUM_literal @@ -810,6 +798,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** %type <item_list> expr_list udf_expr_list udf_expr_list2 when_list ident_list ident_list_arg + expr_list_opt %type <var_type> option_type opt_var_type opt_var_ident_type @@ -848,7 +837,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** %type <udf_type> udf_func_type -%type <symbol> FUNC_ARG0 FUNC_ARG1 FUNC_ARG2 FUNC_ARG3 keyword keyword_sp +%type <symbol> keyword keyword_sp %type <lex_user> user grant_user @@ -5825,10 +5814,10 @@ bool_factor: | bool_test ; bool_test: - bool_pri IS TRUE_SYM { $$= is_truth_value($1,1,0); } - | bool_pri IS not TRUE_SYM { $$= is_truth_value($1,0,0); } - | bool_pri IS FALSE_SYM { $$= is_truth_value($1,0,1); } - | bool_pri IS not FALSE_SYM { $$= is_truth_value($1,1,1); } + bool_pri IS TRUE_SYM { $$= is_truth_value(YYTHD, $1,1,0); } + | bool_pri IS not TRUE_SYM { $$= is_truth_value(YYTHD, $1,0,0); } + | bool_pri IS FALSE_SYM { $$= is_truth_value(YYTHD, $1,0,1); } + | bool_pri IS not FALSE_SYM { $$= is_truth_value(YYTHD, $1,1,1); } | bool_pri IS UNKNOWN_SYM { $$= new Item_func_isnull($1); } | bool_pri IS not UNKNOWN_SYM { $$= new Item_func_isnotnull($1); } | bool_pri ; @@ -5949,56 +5938,67 @@ interval_expr: simple_expr: simple_ident + | function_call_keyword + | function_call_nonkeyword + | function_call_generic + | function_call_conflict | simple_expr COLLATE_SYM ident_or_text %prec NEG { - $$= new Item_func_set_collation($1, - new Item_string($3.str, - $3.length, - YYTHD->charset())); + THD *thd= YYTHD; + Item *i1= new (thd->mem_root) Item_string($3.str, + $3.length, + thd->charset()); + $$= new (thd->mem_root) Item_func_set_collation($1, i1); } | literal | param_marker | variable | sum_expr | simple_expr OR_OR_SYM simple_expr - { $$= new Item_func_concat($1, $3); } + { $$= new (YYTHD->mem_root) Item_func_concat($1, $3); } | '+' simple_expr %prec NEG { $$= $2; } - | '-' simple_expr %prec NEG { $$= new Item_func_neg($2); } - | '~' simple_expr %prec NEG { $$= new Item_func_bit_neg($2); } - | not2 simple_expr %prec NEG { $$= negate_expression(YYTHD, $2); } + | '-' simple_expr %prec NEG + { $$= new (YYTHD->mem_root) Item_func_neg($2); } + | '~' simple_expr %prec NEG + { $$= new (YYTHD->mem_root) Item_func_bit_neg($2); } + | not2 simple_expr %prec NEG + { $$= negate_expression(YYTHD, $2); } | '(' subselect ')' { - $$= new Item_singlerow_subselect($2); + $$= new (YYTHD->mem_root) Item_singlerow_subselect($2); } | '(' expr ')' { $$= $2; } | '(' expr ',' expr_list ')' { $4->push_front($2); - $$= new Item_row(*$4); + $$= new (YYTHD->mem_root) Item_row(*$4); } | ROW_SYM '(' expr ',' expr_list ')' { $5->push_front($3); - $$= new Item_row(*$5); + $$= new (YYTHD->mem_root) Item_row(*$5); } | EXISTS '(' subselect ')' { - $$= new Item_exists_subselect($3); + $$= new (YYTHD->mem_root) Item_exists_subselect($3); } | '{' ident expr '}' { $$= $3; } | MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')' - { $2->push_front($5); - Select->add_ftfunc_to_list((Item_func_match*) - ($$=new Item_func_match(*$2,$6))); } - | ASCII_SYM '(' expr ')' { $$= new Item_func_ascii($3); } + { + $2->push_front($5); + Item_func_match *i1= new (YYTHD->mem_root) Item_func_match(*$2, $6); + Select->add_ftfunc_to_list(i1); + $$= i1; + } | BINARY simple_expr %prec NEG { - $$= create_func_cast($2, ITEM_CAST_CHAR, -1, 0, &my_charset_bin); + $$= create_func_cast(YYTHD, $2, ITEM_CAST_CHAR, -1, 0, + &my_charset_bin); } | CAST_SYM '(' expr AS cast_type ')' { LEX *lex= Lex; - $$= create_func_cast($3, $5, + $$= create_func_cast(YYTHD, $3, $5, lex->length ? atoi(lex->length) : -1, lex->dec ? atoi(lex->dec) : 0, lex->charset); @@ -6006,10 +6006,10 @@ simple_expr: YYABORT; } | CASE_SYM opt_expr WHEN_SYM when_list opt_else END - { $$= new Item_func_case(* $4, $2, $5 ); } + { $$= new (YYTHD->mem_root) Item_func_case(* $4, $2, $5 ); } | CONVERT_SYM '(' expr ',' cast_type ')' { - $$= create_func_cast($3, $5, + $$= create_func_cast(YYTHD, $3, $5, Lex->length ? atoi(Lex->length) : -1, Lex->dec ? atoi(Lex->dec) : 0, Lex->charset); @@ -6017,7 +6017,7 @@ simple_expr: YYABORT; } | CONVERT_SYM '(' expr USING charset_name ')' - { $$= new Item_func_conv_charset($3,$5); } + { $$= new (YYTHD->mem_root) Item_func_conv_charset($3,$5); } | DEFAULT '(' simple_ident ')' { if ($3->is_splocal()) @@ -6027,545 +6027,432 @@ simple_expr: my_error(ER_WRONG_COLUMN_NAME, MYF(0), il->my_name()->str); YYABORT; } - $$= new Item_default_value(Lex->current_context(), $3); + $$= new (YYTHD->mem_root) Item_default_value(Lex->current_context(), + $3); } | VALUES '(' simple_ident_nospvar ')' - { $$= new Item_insert_value(Lex->current_context(), $3); } - | FUNC_ARG0 '(' ')' - { - if (!$1.symbol->create_func) - { - my_error(ER_FEATURE_DISABLED, MYF(0), - $1.symbol->group->name, - $1.symbol->group->needed_define); - YYABORT; - } - $$= ((Item*(*)(void))($1.symbol->create_func))(); - } - | FUNC_ARG1 '(' expr ')' - { - if (!$1.symbol->create_func) - { - my_error(ER_FEATURE_DISABLED, MYF(0), - $1.symbol->group->name, - $1.symbol->group->needed_define); - YYABORT; - } - $$= ((Item*(*)(Item*))($1.symbol->create_func))($3); - } - | FUNC_ARG2 '(' expr ',' expr ')' - { - if (!$1.symbol->create_func) - { - my_error(ER_FEATURE_DISABLED, MYF(0), - $1.symbol->group->name, - $1.symbol->group->needed_define); - YYABORT; - } - $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5); - } - | FUNC_ARG3 '(' expr ',' expr ',' expr ')' - { - 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 ')' + { $$= new (YYTHD->mem_root) Item_insert_value(Lex->current_context(), + $3); } + | interval_expr interval '+' expr + /* we cannot put interval before - */ + { $$= new (YYTHD->mem_root) Item_date_add_interval($4,$1,$2,0); } + | interval_expr { - if (Lex->add_time_zone_tables_to_query_tables(YYTHD)) + if ($1->type() != Item::ROW_ITEM) + { + yyerror(ER(ER_SYNTAX_ERROR)); YYABORT; - $$= new Item_func_convert_tz($3, $5, $7); - } - | CURDATE optional_braces - { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; } - | CURTIME optional_braces - { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; } - | CURTIME '(' expr ')' + } + $$= new (YYTHD->mem_root) Item_func_interval((Item_row *)$1); + } + | UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')' { - $$= new Item_func_curtime_local($3); - Lex->safe_to_cache_query=0; + $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9); } + ; + +/* + Function call syntax using official SQL 2003 keywords. + Because the function name is an official token, + a dedicated grammar rule is needed in the parser. + There is no potential for conflicts +*/ +function_call_keyword: + CHAR_SYM '(' expr_list ')' + { $$= new (YYTHD->mem_root) Item_func_char(*$3); } + | CHAR_SYM '(' expr_list USING charset_name ')' + { $$= new (YYTHD->mem_root) Item_func_char(*$3, $5); } | CURRENT_USER optional_braces { - $$= new Item_func_current_user(Lex->current_context()); + $$= new (YYTHD->mem_root) Item_func_current_user(Lex->current_context()); Lex->safe_to_cache_query= 0; } - | DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')' - { $$= new Item_date_add_interval($3,$5,$6,0); } - | DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')' - { $$= new Item_date_add_interval($3,$5,$6,1); } - | DATABASE '(' ')' - { - $$= new Item_func_database(); - Lex->safe_to_cache_query=0; - } | DATE_SYM '(' expr ')' - { $$= new Item_date_typecast($3); } + { $$= new (YYTHD->mem_root) Item_date_typecast($3); } | DAY_SYM '(' expr ')' - { $$= new Item_func_dayofmonth($3); } - | ELT_FUNC '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_elt(*$5); } - | MAKE_SET_SYM '(' expr ',' expr_list ')' - { $$= new Item_func_make_set($3, *$5); } - | ENCRYPT '(' expr ')' - { - $$= new Item_func_encrypt($3); - Lex->uncacheable(UNCACHEABLE_RAND); - } - | ENCRYPT '(' expr ',' expr ')' { $$= new Item_func_encrypt($3,$5); } - | DECODE_SYM '(' expr ',' TEXT_STRING_literal ')' - { $$= new Item_func_decode($3,$5.str); } - | ENCODE_SYM '(' expr ',' TEXT_STRING_literal ')' - { $$= new Item_func_encode($3,$5.str); } - | DES_DECRYPT_SYM '(' expr ')' - { $$= new Item_func_des_decrypt($3); } - | DES_DECRYPT_SYM '(' expr ',' expr ')' - { $$= new Item_func_des_decrypt($3,$5); } - | DES_ENCRYPT_SYM '(' expr ')' - { $$= new Item_func_des_encrypt($3); } - | DES_ENCRYPT_SYM '(' expr ',' expr ')' - { $$= new Item_func_des_encrypt($3,$5); } - | EXPORT_SET '(' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7); } - | EXPORT_SET '(' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7, $9); } - | EXPORT_SET '(' expr ',' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7, $9, $11); } - | FORMAT_SYM '(' expr ',' NUM ')' - { $$= new Item_func_format($3,atoi($5.str)); } - | FROM_UNIXTIME '(' expr ')' - { $$= new Item_func_from_unixtime($3); } - | FROM_UNIXTIME '(' expr ',' expr ')' - { - $$= new Item_func_date_format (new Item_func_from_unixtime($3),$5,0); - } - | FIELD_FUNC '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_field(*$5); } - | geometry_function - { -#ifdef HAVE_SPATIAL - $$= $1; -#else - my_error(ER_FEATURE_DISABLED, MYF(0), - sym_group_geom.name, sym_group_geom.needed_define); - YYABORT; -#endif - } - | GET_FORMAT '(' date_time_type ',' expr ')' - { $$= new Item_func_get_format($3, $5); } + { $$= new (YYTHD->mem_root) Item_func_dayofmonth($3); } | HOUR_SYM '(' expr ')' - { $$= new Item_func_hour($3); } - | IF '(' expr ',' expr ',' expr ')' - { $$= new Item_func_if($3,$5,$7); } + { $$= new (YYTHD->mem_root) Item_func_hour($3); } | INSERT '(' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_insert($3,$5,$7,$9); } - | interval_expr interval '+' expr - /* we cannot put interval before - */ - { $$= new Item_date_add_interval($4,$1,$2,0); } - | interval_expr + { $$= new (YYTHD->mem_root) Item_func_insert($3,$5,$7,$9); } + | LEFT '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_left($3,$5); } + | MINUTE_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_minute($3); } + | MONTH_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_month($3); } + | RIGHT '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_right($3,$5); } + | SECOND_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_second($3); } + | TIME_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_time_typecast($3); } + | TIMESTAMP '(' expr ')' + { $$= new (YYTHD->mem_root) Item_datetime_typecast($3); } + | TIMESTAMP '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_add_time($3, $5, 1, 0); } + | TRIM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_trim($3); } + | TRIM '(' LEADING expr FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_ltrim($6,$4); } + | TRIM '(' TRAILING expr FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_rtrim($6,$4); } + | TRIM '(' BOTH expr FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_trim($6,$4); } + | TRIM '(' LEADING FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_ltrim($5); } + | TRIM '(' TRAILING FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_rtrim($5); } + | TRIM '(' BOTH FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_trim($5); } + | TRIM '(' expr FROM expr ')' + { $$= new (YYTHD->mem_root) Item_func_trim($5,$3); } + | USER '(' ')' { - if ($1->type() != Item::ROW_ITEM) - { - yyerror(ER(ER_SYNTAX_ERROR)); - YYABORT; - } - $$= new Item_func_interval((Item_row *)$1); + $$= new (YYTHD->mem_root) Item_func_user(); + Lex->safe_to_cache_query=0; } - | LAST_INSERT_ID '(' ')' + | YEAR_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_year($3); } + ; + +/* + Function calls using non reserved keywords, with special syntaxic forms. + Dedicated grammar rules are needed because of the syntax, + but also have the potential to cause incompatibilities with other + parts of the language. + MAINTAINER: + The only reasons a function should be added here are: + - for compatibility reasons with another SQL syntax (CURDATE), + - for typing reasons (GET_FORMAT) + Any other 'Syntaxic sugar' enhancements should be *STRONGLY* + discouraged. +*/ +function_call_nonkeyword: + ADDDATE_SYM '(' expr ',' expr ')' { - $$= new Item_func_last_insert_id(); - Lex->safe_to_cache_query= 0; - } - | LAST_INSERT_ID '(' expr ')' + $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5, + INTERVAL_DAY, 0); + } + | ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')' + { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 0); } + | CURDATE optional_braces { - $$= new Item_func_last_insert_id($3); - Lex->safe_to_cache_query= 0; - } - | LEFT '(' expr ',' expr ')' - { $$= new Item_func_left($3,$5); } - | LOCATE '(' expr ',' expr ')' - { $$= new Item_func_locate($5,$3); } - | LOCATE '(' expr ',' expr ',' expr ')' - { $$= new Item_func_locate($5,$3,$7); } - | GREATEST_SYM '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_max(*$5); } - | LEAST_SYM '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_min(*$5); } - | LOG_SYM '(' expr ')' - { $$= new Item_func_log($3); } - | LOG_SYM '(' expr ',' expr ')' - { $$= new Item_func_log($3, $5); } - | MASTER_POS_WAIT '(' expr ',' expr ')' + $$= new (YYTHD->mem_root) Item_func_curdate_local(); + Lex->safe_to_cache_query=0; + } + | CURTIME optional_braces { - $$= new Item_master_pos_wait($3, $5); - Lex->safe_to_cache_query=0; - } - | MASTER_POS_WAIT '(' expr ',' expr ',' expr ')' + $$= new (YYTHD->mem_root) Item_func_curtime_local(); + Lex->safe_to_cache_query=0; + } + | CURTIME '(' expr ')' { - $$= new Item_master_pos_wait($3, $5, $7); + $$= new (YYTHD->mem_root) Item_func_curtime_local($3); Lex->safe_to_cache_query=0; } - | MICROSECOND_SYM '(' expr ')' - { $$= new Item_func_microsecond($3); } - | MINUTE_SYM '(' expr ')' - { $$= new Item_func_minute($3); } - | MOD_SYM '(' expr ',' expr ')' - { $$ = new Item_func_mod( $3, $5); } - | MONTH_SYM '(' expr ')' - { $$= new Item_func_month($3); } + | DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')' + { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,0); } + | DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')' + { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,1); } + | EXTRACT_SYM '(' interval FROM expr ')' + { $$=new (YYTHD->mem_root) Item_extract( $3, $5); } + | GET_FORMAT '(' date_time_type ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_get_format($3, $5); } | NOW_SYM optional_braces - { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;} + { + $$= new (YYTHD->mem_root) Item_func_now_local(); + Lex->safe_to_cache_query=0; + } | NOW_SYM '(' expr ')' - { $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0;} - | PASSWORD '(' expr ')' { - $$= YYTHD->variables.old_passwords ? - (Item *) new Item_func_old_password($3) : - (Item *) new Item_func_password($3); - } - | OLD_PASSWORD '(' expr ')' - { $$= new Item_func_old_password($3); } + $$= new (YYTHD->mem_root) Item_func_now_local($3); + Lex->safe_to_cache_query=0; + } | POSITION_SYM '(' bit_expr IN_SYM expr ')' - { $$ = new Item_func_locate($5,$3); } - | QUARTER_SYM '(' expr ')' - { $$ = new Item_func_quarter($3); } - | RAND '(' expr ')' - { $$= new Item_func_rand($3); Lex->uncacheable(UNCACHEABLE_RAND);} - | RAND '(' ')' - { $$= new Item_func_rand(); Lex->uncacheable(UNCACHEABLE_RAND);} - | REPLACE '(' expr ',' expr ',' expr ')' - { $$= new Item_func_replace($3,$5,$7); } - | RIGHT '(' expr ',' expr ')' - { $$= new Item_func_right($3,$5); } - | ROUND '(' expr ')' - { $$= new Item_func_round($3, new Item_int((char*)"0",0,1),0); } - | ROUND '(' expr ',' expr ')' { $$= new Item_func_round($3,$5,0); } - | ROW_COUNT_SYM '(' ')' - { - $$= new Item_func_row_count(); - Lex->safe_to_cache_query= 0; - } + { $$ = new (YYTHD->mem_root) Item_func_locate($5,$3); } | SUBDATE_SYM '(' expr ',' expr ')' - { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);} + { + $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5, + INTERVAL_DAY, 1); + } | SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')' - { $$= new Item_date_add_interval($3, $6, $7, 1); } - | SECOND_SYM '(' expr ')' - { $$= new Item_func_second($3); } + { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 1); } | SUBSTRING '(' expr ',' expr ',' expr ')' - { $$= new Item_func_substr($3,$5,$7); } + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); } | SUBSTRING '(' expr ',' expr ')' - { $$= new Item_func_substr($3,$5); } + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); } | SUBSTRING '(' expr FROM expr FOR_SYM expr ')' - { $$= new Item_func_substr($3,$5,$7); } + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); } | SUBSTRING '(' expr FROM expr ')' - { $$= new Item_func_substr($3,$5); } - | SUBSTRING_INDEX '(' expr ',' expr ',' expr ')' - { $$= new Item_func_substr_index($3,$5,$7); } + { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); } | SYSDATE optional_braces { if (global_system_variables.sysdate_is_now == 0) - $$= new Item_func_sysdate_local(); - else $$= new Item_func_now_local(); + $$= new (YYTHD->mem_root) Item_func_sysdate_local(); + else + $$= new (YYTHD->mem_root) Item_func_now_local(); Lex->safe_to_cache_query=0; } | SYSDATE '(' expr ')' { if (global_system_variables.sysdate_is_now == 0) - $$= new Item_func_sysdate_local($3); - else $$= new Item_func_now_local($3); + $$= new (YYTHD->mem_root) Item_func_sysdate_local($3); + else + $$= new (YYTHD->mem_root) Item_func_now_local($3); Lex->safe_to_cache_query=0; } - | TIME_SYM '(' expr ')' - { $$= new Item_time_typecast($3); } - | TIMESTAMP '(' expr ')' - { $$= new Item_datetime_typecast($3); } - | TIMESTAMP '(' expr ',' expr ')' - { $$= new Item_func_add_time($3, $5, 1, 0); } | TIMESTAMP_ADD '(' interval_time_st ',' expr ',' expr ')' - { $$= new Item_date_add_interval($7,$5,$3,0); } + { $$= new (YYTHD->mem_root) Item_date_add_interval($7,$5,$3,0); } | TIMESTAMP_DIFF '(' interval_time_st ',' expr ',' expr ')' - { $$= new Item_func_timestamp_diff($5,$7,$3); } - | TRIM '(' expr ')' - { $$= new Item_func_trim($3); } - | TRIM '(' LEADING expr FROM expr ')' - { $$= new Item_func_ltrim($6,$4); } - | TRIM '(' TRAILING expr FROM expr ')' - { $$= new Item_func_rtrim($6,$4); } - | TRIM '(' BOTH expr FROM expr ')' - { $$= new Item_func_trim($6,$4); } - | TRIM '(' LEADING FROM expr ')' - { $$= new Item_func_ltrim($5); } - | TRIM '(' TRAILING FROM expr ')' - { $$= new Item_func_rtrim($5); } - | TRIM '(' BOTH FROM expr ')' - { $$= new Item_func_trim($5); } - | TRIM '(' expr FROM expr ')' - { $$= new Item_func_trim($5,$3); } - | TRUNCATE_SYM '(' expr ',' expr ')' - { $$= new Item_func_round($3,$5,1); } - | ident '.' ident '(' udf_expr_list ')' + { $$= new (YYTHD->mem_root) Item_func_timestamp_diff($5,$7,$3); } + | UTC_DATE_SYM optional_braces { - LEX *lex= Lex; - sp_name *name= new sp_name($1, $3); + $$= new (YYTHD->mem_root) Item_func_curdate_utc(); + Lex->safe_to_cache_query=0; + } + | UTC_TIME_SYM optional_braces + { + $$= new (YYTHD->mem_root) Item_func_curtime_utc(); + Lex->safe_to_cache_query=0; + } + | UTC_TIMESTAMP_SYM optional_braces + { + $$= new (YYTHD->mem_root) Item_func_now_utc(); + Lex->safe_to_cache_query=0; + } + ; - name->init_qname(YYTHD); - sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION); - if ($5) - $$= new Item_func_sp(Lex->current_context(), name, *$5); - else - $$= new Item_func_sp(Lex->current_context(), name); - lex->safe_to_cache_query=0; +/* + Functions calls using a non reserved keywork, and using a regular syntax. + Because the non reserved keyword is used in another part of the grammar, + a dedicated rule is needed here. +*/ +function_call_conflict: + ASCII_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_ascii($3); } + | CHARSET '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_charset($3); } + | COALESCE '(' expr_list ')' + { $$= new (YYTHD->mem_root) Item_func_coalesce(* $3); } + | COLLATION_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_collation($3); } + | DATABASE '(' ')' + { + $$= new (YYTHD->mem_root) Item_func_database(); + Lex->safe_to_cache_query=0; + } + | IF '(' expr ',' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_if($3,$5,$7); } + | MICROSECOND_SYM '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_microsecond($3); } + | MOD_SYM '(' expr ',' expr ')' + { $$ = new (YYTHD->mem_root) Item_func_mod( $3, $5); } + | OLD_PASSWORD '(' expr ')' + { $$= new (YYTHD->mem_root) Item_func_old_password($3); } + | PASSWORD '(' expr ')' + { + THD *thd= YYTHD; + Item* i1; + if (thd->variables.old_passwords) + i1= new (thd->mem_root) Item_func_old_password($3); + else + i1= new (thd->mem_root) Item_func_password($3); + $$= i1; } - | IDENT_sys '(' + | QUARTER_SYM '(' expr ')' + { $$ = new (YYTHD->mem_root) Item_func_quarter($3); } + | REPEAT_SYM '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_repeat($3,$5); } + | REPLACE '(' expr ',' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_replace($3,$5,$7); } + | TRUNCATE_SYM '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_round($3,$5,1); } + | WEEK_SYM '(' expr ')' + { + THD *thd= YYTHD; + Item *i1= new (thd->mem_root) Item_int((char*) "0", + thd->variables.default_week_format, + 1); + + $$= new (thd->mem_root) Item_func_week($3, i1); + } + | WEEK_SYM '(' expr ',' expr ')' + { $$= new (YYTHD->mem_root) Item_func_week($3,$5); } + | geometry_function { +#ifdef HAVE_SPATIAL + $$= $1; +#else + my_error(ER_FEATURE_DISABLED, MYF(0), + sym_group_geom.name, sym_group_geom.needed_define); + YYABORT; +#endif + } + ; + +geometry_function: + CONTAINS_SYM '(' expr ',' expr ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_rel($3, $5, + Item_func::SP_CONTAINS_FUNC)); + } + | GEOMETRYCOLLECTION '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_geometrycollection, + Geometry::wkb_point)); + } + | LINESTRING '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_linestring, + Geometry::wkb_point)); + } + | MULTILINESTRING '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_multilinestring, + Geometry::wkb_linestring)); + } + | MULTIPOINT '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_multipoint, + Geometry::wkb_point)); + } + | MULTIPOLYGON '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_multipolygon, + Geometry::wkb_polygon)); + } + | POINT_SYM '(' expr ',' expr ')' + { $$= GEOM_NEW(YYTHD, Item_func_point($3,$5)); } + | POLYGON '(' expr_list ')' + { + $$= GEOM_NEW(YYTHD, + Item_func_spatial_collection(* $3, + Geometry::wkb_polygon, + Geometry::wkb_linestring)); + } + ; + +/* + Regular function calls. + The function name is *not* a token, and therefore is guaranteed to not + introduce side effects to the language in general. + MAINTAINER: + All the new functions implemented for new features should fit into + this category. The place to implement the function itself is + in sql/item_create.cc +*/ +function_call_generic: + IDENT_sys '(' + { #ifdef HAVE_DLOPEN - udf_func *udf= 0; - if (using_udf_functions && - (udf= find_udf($1.str, $1.length)) && - udf->type == UDFTYPE_AGGREGATE) + udf_func *udf= 0; + if (using_udf_functions && + (udf= find_udf($1.str, $1.length)) && + udf->type == UDFTYPE_AGGREGATE) + { + LEX *lex= Lex; + if (lex->current_select->inc_in_sum_expr()) { - LEX *lex= Lex; - if (lex->current_select->inc_in_sum_expr()) - { - yyerror(ER(ER_SYNTAX_ERROR)); - YYABORT; - } + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; } - $<udf>$= udf; + } + /* Temporary placing the result of find_udf in $3 */ + $<udf>$= udf; #endif + } + expr_list_opt ')' + { + THD *thd= YYTHD; + LEX *lex= Lex; + Create_func *builder; + Item *item= NULL; + + /* + Implementation note: + names are resolved with the following order: + - MySQL native functions, + - User Defined Functions, + - Stored Functions (assuming the current <use> database) + + This will be revised with WL#2128 (SQL PATH) + */ + builder= find_native_function_builder(thd, $1); + if (builder) + { + item= builder->create(thd, $1, $4); } - udf_expr_list ')' + else { #ifdef HAVE_DLOPEN + /* Retrieving the result of find_udf */ udf_func *udf= $<udf>3; - SELECT_LEX *sel= Select; if (udf) { if (udf->type == UDFTYPE_AGGREGATE) + { Select->in_sum_expr--; - - Lex->binlog_row_based_if_mixed= TRUE; - - switch (udf->returns) { - case STRING_RESULT: - if (udf->type == UDFTYPE_FUNCTION) - { - if ($4 != NULL) - $$ = new Item_func_udf_str(udf, *$4); - else - $$ = new Item_func_udf_str(udf); - } - else - { - if ($4 != NULL) - $$ = new Item_sum_udf_str(udf, *$4); - else - $$ = new Item_sum_udf_str(udf); - } - break; - case REAL_RESULT: - if (udf->type == UDFTYPE_FUNCTION) - { - if ($4 != NULL) - $$ = new Item_func_udf_float(udf, *$4); - else - $$ = new Item_func_udf_float(udf); - } - else - { - if ($4 != NULL) - $$ = new Item_sum_udf_float(udf, *$4); - else - $$ = new Item_sum_udf_float(udf); - } - break; - case INT_RESULT: - if (udf->type == UDFTYPE_FUNCTION) - { - if ($4 != NULL) - $$ = new Item_func_udf_int(udf, *$4); - else - $$ = new Item_func_udf_int(udf); - } - else - { - if ($4 != NULL) - $$ = new Item_sum_udf_int(udf, *$4); - else - $$ = new Item_sum_udf_int(udf); - } - break; - case DECIMAL_RESULT: - if (udf->type == UDFTYPE_FUNCTION) - { - if ($4 != NULL) - $$ = new Item_func_udf_decimal(udf, *$4); - else - $$ = new Item_func_udf_decimal(udf); - } - else - { - if ($4 != NULL) - $$ = new Item_sum_udf_decimal(udf, *$4); - else - $$ = new Item_sum_udf_decimal(udf); - } - break; - default: - YYABORT; } + + item= Create_udf_func::s_singleton.create(thd, udf, $4); } else -#endif /* HAVE_DLOPEN */ +#endif { - LEX *lex= Lex; - THD *thd= lex->thd; - LEX_STRING db; - if (thd->copy_db_to(&db.str, &db.length)) - YYABORT; - sp_name *name= new sp_name(db, $1); - if (name) - name->init_qname(thd); - - sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION); - if ($4) - $$= new Item_func_sp(Lex->current_context(), name, *$4); - else - $$= new Item_func_sp(Lex->current_context(), name); - lex->safe_to_cache_query=0; - } + builder= find_qualified_function_builder(thd); + DBUG_ASSERT(builder); + item= builder->create(thd, $1, $4); + } } - | UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')' - { - $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9); - } - | UNIX_TIMESTAMP '(' ')' - { - $$= new Item_func_unix_timestamp(); - Lex->safe_to_cache_query=0; - } - | UNIX_TIMESTAMP '(' expr ')' - { $$= new Item_func_unix_timestamp($3); } - | USER '(' ')' - { $$= new Item_func_user(); Lex->safe_to_cache_query=0; } - | UTC_DATE_SYM optional_braces - { $$= new Item_func_curdate_utc(); Lex->safe_to_cache_query=0;} - | UTC_TIME_SYM optional_braces - { $$= new Item_func_curtime_utc(); Lex->safe_to_cache_query=0;} - | UTC_TIMESTAMP_SYM optional_braces - { $$= new Item_func_now_utc(); Lex->safe_to_cache_query=0;} - | WEEK_SYM '(' expr ')' - { - $$= new Item_func_week($3,new Item_int((char*) "0", - YYTHD->variables.default_week_format,1)); + + if (! ($$= item)) + { + YYABORT; } - | WEEK_SYM '(' expr ',' expr ')' - { $$= new Item_func_week($3,$5); } - | YEAR_SYM '(' expr ')' - { $$= new Item_func_year($3); } - | YEARWEEK '(' expr ')' - { $$= new Item_func_yearweek($3,new Item_int((char*) "0",0,1)); } - | YEARWEEK '(' expr ',' expr ')' - { $$= new Item_func_yearweek($3, $5); } - | BENCHMARK_SYM '(' ulong_num ',' expr ')' - { - $$=new Item_func_benchmark($3,$5); - Lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - } - | EXTRACT_SYM '(' interval FROM expr ')' - { $$=new Item_extract( $3, $5); }; + } + | ident '.' ident '(' udf_expr_list ')' + { + THD *thd= YYTHD; + Create_qfunc *builder; + Item *item= NULL; -geometry_function: - CONTAINS_SYM '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_spatial_rel($3, $5, Item_func::SP_CONTAINS_FUNC)); } - | GEOMFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | GEOMFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | GEOMFROMWKB '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_wkb($3)); } - | GEOMFROMWKB '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_wkb($3, $5)); } - | GEOMETRYCOLLECTION '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_geometrycollection, - Geometry::wkb_point)); } - | LINESTRING '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_linestring, Geometry::wkb_point)); } - | MULTILINESTRING '(' expr_list ')' - { $$= GEOM_NEW( Item_func_spatial_collection(* $3, - Geometry::wkb_multilinestring, Geometry::wkb_linestring)); } - | MLINEFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | MLINEFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | MPOINTFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | MPOINTFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | MPOLYFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | MPOLYFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | MULTIPOINT '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_multipoint, Geometry::wkb_point)); } - | MULTIPOLYGON '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_multipolygon, Geometry::wkb_polygon)); } - | POINT_SYM '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_point($3,$5)); } - | POINTFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | POINTFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | POLYFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | POLYFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | POLYGON '(' expr_list ')' - { $$= GEOM_NEW(Item_func_spatial_collection(* $3, - Geometry::wkb_polygon, Geometry::wkb_linestring)); } - | GEOMCOLLFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | GEOMCOLLFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | LINEFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | LINEFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - ; + /* + The following in practice calls: + <code>Create_sp_func::create()</code> + and builds a stored function. + + However, it's important to maintain the interface between the + parser and the implementation in item_create.cc clean, + since this will change with WL#2128 (SQL PATH): + - INFORMATION_SCHEMA.version() is the SQL 99 syntax for the native + funtion version(), + - MySQL.version() is the SQL 2003 syntax for the native function + version() (a vendor can specify any schema). + */ + + builder= find_qualified_function_builder(thd); + DBUG_ASSERT(builder); + item= builder->create(thd, $1, $3, $5); + + if (! ($$= item)) + { + YYABORT; + } + } + ; fulltext_options: opt_natural_language_mode opt_query_expansion @@ -6774,6 +6661,13 @@ cast_type: | DATETIME { $$=ITEM_CAST_DATETIME; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; } | DECIMAL_SYM float_options { $$=ITEM_CAST_DECIMAL; Lex->charset= NULL; } ; + +expr_list_opt: + /* empty */ + { $$ = NULL; } + | expr_list + { $$ = $1;} + ; expr_list: { Select->expr_list.push_front(new List<Item>); } --- 1.132/sql/share/errmsg.txt 2006-10-27 14:45:05 -07:00 +++ 1.133/sql/share/errmsg.txt 2006-10-27 14:45:05 -07:00 @@ -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'" --- 1.188/mysql-test/r/view.result 2006-10-27 14:45:05 -07:00 +++ 1.189/mysql-test/r/view.result 2006-10-27 14:45:05 -07:00 @@ -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; --- 1.170/mysql-test/t/view.test 2006-10-27 14:45:05 -07:00 +++ 1.171/mysql-test/t/view.test 2006-10-27 14:45:05 -07:00 @@ -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 --- New file --- +++ mysql-test/include/parser_stress_func.inc 06/10/27 14:44:53 # # Bug#21114 (Foreign key creation fails to table with name format) # # Trying to trick the parser into thinking $FCT(...) is a function call, # which is not in the CREATE TABLE and FOREIGN KEY ... REFERENCES syntax # # Usage : # # let $engine_type=InnoDb; # let $verbose=1; # let $FCT= <value_1>; # -- source parser_stress_func.inc # let $FCT= <value_2>; # -- source parser_stress_func.inc # let $verbose=0; # let $FCT= <value_3>; # -- source parser_stress_func.inc # let $FCT= <value_4>; # -- source parser_stress_func.inc -- disable_warnings eval drop table if exists $FCT; drop table if exists bug21114_child; -- enable_warnings --disable_query_log --disable_result_log eval CREATE TABLE $FCT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE $engine_type; eval CREATE TABLE bug21114_child( pk int not null, fk_col1 int not null, fk_col2 int not null, fk_col3 int not null, fk_col4 int not null, CONSTRAINT fk_fct FOREIGN KEY (fk_col1, fk_col2) REFERENCES $FCT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES $FCT (col1, col2) ) ENGINE $engine_type; --enable_query_log --enable_result_log if ($verbose) { eval SHOW CREATE TABLE $FCT; SHOW CREATE TABLE bug21114_child; } DROP TABLE bug21114_child; eval DROP TABLE $FCT; --- New file --- +++ mysql-test/r/parser.result 06/10/27 14:44:53 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' --- New file --- +++ mysql-test/r/parser_stress_func_innodb.result 06/10/27 14:44:53 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; --- New file --- +++ mysql-test/t/parser.test 06/10/27 14:44:53 # # This file contains tests covering the parser # # # 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); --- New file --- +++ mysql-test/t/parser_stress_func_innodb.test 06/10/27 14:44:53 -- 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_stress_func.inc let $FCT=FIELD; -- source include/parser_stress_func.inc let $FCT=FORMAT; -- source include/parser_stress_func.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_stress_func.inc let $FCT=ADDDATE; -- source include/parser_stress_func.inc let $FCT=ADDTIME; -- source include/parser_stress_func.inc let $FCT=AES_DECRYPT; -- source include/parser_stress_func.inc let $FCT=AES_ENCRYPT; -- source include/parser_stress_func.inc let $FCT=AREA; -- source include/parser_stress_func.inc let $FCT=ASBINARY; -- source include/parser_stress_func.inc let $FCT=ASIN; -- source include/parser_stress_func.inc let $FCT=ASTEXT; -- source include/parser_stress_func.inc let $FCT=ASWKB; -- source include/parser_stress_func.inc let $FCT=ASWKT; -- source include/parser_stress_func.inc let $FCT=ATAN; -- source include/parser_stress_func.inc let $FCT=ATAN2; -- source include/parser_stress_func.inc let $FCT=BENCHMARK; -- source include/parser_stress_func.inc let $FCT=BIN; -- source include/parser_stress_func.inc let $FCT=BIT_COUNT; -- source include/parser_stress_func.inc let $FCT=BIT_LENGTH; -- source include/parser_stress_func.inc let $FCT=CEIL; -- source include/parser_stress_func.inc let $FCT=CEILING; -- source include/parser_stress_func.inc let $FCT=CENTROID; -- source include/parser_stress_func.inc let $FCT=CHARACTER_LENGTH; -- source include/parser_stress_func.inc let $FCT=CHAR_LENGTH; -- source include/parser_stress_func.inc let $FCT=COERCIBILITY; -- source include/parser_stress_func.inc let $FCT=COMPRESS; -- source include/parser_stress_func.inc let $FCT=CONCAT; -- source include/parser_stress_func.inc let $FCT=CONCAT_WS; -- source include/parser_stress_func.inc let $FCT=CONNECTION_ID; -- source include/parser_stress_func.inc let $FCT=CONV; -- source include/parser_stress_func.inc let $FCT=CONVERT_TZ; -- source include/parser_stress_func.inc let $FCT=COS; -- source include/parser_stress_func.inc let $FCT=COT; -- source include/parser_stress_func.inc let $FCT=CRC32; -- source include/parser_stress_func.inc let $FCT=CROSSES; -- source include/parser_stress_func.inc let $FCT=DATEDIFF; -- source include/parser_stress_func.inc let $FCT=DATE_FORMAT; -- source include/parser_stress_func.inc let $FCT=DAYNAME; -- source include/parser_stress_func.inc let $FCT=DAYOFMONTH; -- source include/parser_stress_func.inc let $FCT=DAYOFWEEK; -- source include/parser_stress_func.inc let $FCT=DAYOFYEAR; -- source include/parser_stress_func.inc let $FCT=DECODE; -- source include/parser_stress_func.inc let $FCT=DEGREES; -- source include/parser_stress_func.inc let $FCT=DES_DECRYPT; -- source include/parser_stress_func.inc let $FCT=DES_ENCRYPT; -- source include/parser_stress_func.inc let $FCT=DIMENSION; -- source include/parser_stress_func.inc let $FCT=DISJOINT; -- source include/parser_stress_func.inc let $FCT=ELT; -- source include/parser_stress_func.inc let $FCT=ENCODE; -- source include/parser_stress_func.inc let $FCT=ENCRYPT; -- source include/parser_stress_func.inc let $FCT=ENDPOINT; -- source include/parser_stress_func.inc let $FCT=ENVELOPE; -- source include/parser_stress_func.inc let $FCT=EQUALS; -- source include/parser_stress_func.inc let $FCT=EXP; -- source include/parser_stress_func.inc let $FCT=EXPORT_SET; -- source include/parser_stress_func.inc let $FCT=EXTERIORRING; -- source include/parser_stress_func.inc let $FCT=EXTRACTVALUE; -- source include/parser_stress_func.inc let $FCT=FIND_IN_SET; -- source include/parser_stress_func.inc let $FCT=FLOOR; -- source include/parser_stress_func.inc let $FCT=FOUND_ROWS; -- source include/parser_stress_func.inc let $FCT=FROM_DAYS; -- source include/parser_stress_func.inc let $FCT=FROM_UNIXTIME; -- source include/parser_stress_func.inc let $FCT=GEOMCOLLFROMTEXT; -- source include/parser_stress_func.inc let $FCT=GEOMCOLLFROMWKB; -- source include/parser_stress_func.inc let $FCT=GEOMETRYCOLLECTIONFROMTEXT; -- source include/parser_stress_func.inc let $FCT=GEOMETRYCOLLECTIONFROMWKB; -- source include/parser_stress_func.inc let $FCT=GEOMETRYFROMTEXT; -- source include/parser_stress_func.inc let $FCT=GEOMETRYFROMWKB; -- source include/parser_stress_func.inc let $FCT=GEOMETRYN; -- source include/parser_stress_func.inc let $FCT=GEOMETRYTYPE; -- source include/parser_stress_func.inc let $FCT=GEOMFROMTEXT; -- source include/parser_stress_func.inc let $FCT=GEOMFROMWKB; -- source include/parser_stress_func.inc let $FCT=GET_LOCK; -- source include/parser_stress_func.inc let $FCT=GLENGTH; -- source include/parser_stress_func.inc let $FCT=GREATEST; -- source include/parser_stress_func.inc let $FCT=HEX; -- source include/parser_stress_func.inc let $FCT=IFNULL; -- source include/parser_stress_func.inc let $FCT=INET_ATON; -- source include/parser_stress_func.inc let $FCT=INET_NTOA; -- source include/parser_stress_func.inc let $FCT=INSTR; -- source include/parser_stress_func.inc let $FCT=INTERIORRINGN; -- source include/parser_stress_func.inc let $FCT=INTERSECTS; -- source include/parser_stress_func.inc let $FCT=ISCLOSED; -- source include/parser_stress_func.inc let $FCT=ISEMPTY; -- source include/parser_stress_func.inc let $FCT=ISNULL; -- source include/parser_stress_func.inc let $FCT=ISSIMPLE; -- source include/parser_stress_func.inc let $FCT=IS_FREE_LOCK; -- source include/parser_stress_func.inc let $FCT=IS_USED_LOCK; -- source include/parser_stress_func.inc let $FCT=LAST_DAY; -- source include/parser_stress_func.inc let $FCT=LAST_INSERT_ID; -- source include/parser_stress_func.inc let $FCT=LCASE; -- source include/parser_stress_func.inc let $FCT=LEAST; -- source include/parser_stress_func.inc let $FCT=LENGTH; -- source include/parser_stress_func.inc let $FCT=LINEFROMTEXT; -- source include/parser_stress_func.inc let $FCT=LINEFROMWKB; -- source include/parser_stress_func.inc let $FCT=LINESTRINGFROMTEXT; -- source include/parser_stress_func.inc let $FCT=LINESTRINGFROMWKB; -- source include/parser_stress_func.inc let $FCT=LN; -- source include/parser_stress_func.inc let $FCT=LOAD_FILE; -- source include/parser_stress_func.inc let $FCT=LOCATE; -- source include/parser_stress_func.inc let $FCT=LOG; -- source include/parser_stress_func.inc let $FCT=LOG10; -- source include/parser_stress_func.inc let $FCT=LOG2; -- source include/parser_stress_func.inc let $FCT=LOWER; -- source include/parser_stress_func.inc let $FCT=LPAD; -- source include/parser_stress_func.inc let $FCT=LTRIM; -- source include/parser_stress_func.inc let $FCT=MAKEDATE; -- source include/parser_stress_func.inc let $FCT=MAKETIME; -- source include/parser_stress_func.inc let $FCT=MAKE_SET; -- source include/parser_stress_func.inc let $FCT=MASTER_POS_WAIT; -- source include/parser_stress_func.inc let $FCT=MBRCONTAINS; -- source include/parser_stress_func.inc let $FCT=MBRDISJOINT; -- source include/parser_stress_func.inc let $FCT=MBREQUAL; -- source include/parser_stress_func.inc let $FCT=MBRINTERSECTS; -- source include/parser_stress_func.inc let $FCT=MBROVERLAPS; -- source include/parser_stress_func.inc let $FCT=MBRTOUCHES; -- source include/parser_stress_func.inc let $FCT=MBRWITHIN; -- source include/parser_stress_func.inc let $FCT=MD5; -- source include/parser_stress_func.inc let $FCT=MLINEFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MLINEFROMWKB; -- source include/parser_stress_func.inc let $FCT=MONTHNAME; -- source include/parser_stress_func.inc let $FCT=MPOINTFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MPOINTFROMWKB; -- source include/parser_stress_func.inc let $FCT=MPOLYFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MPOLYFROMWKB; -- source include/parser_stress_func.inc let $FCT=MULTILINESTRINGFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MULTILINESTRINGFROMWKB; -- source include/parser_stress_func.inc let $FCT=MULTIPOINTFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MULTIPOINTFROMWKB; -- source include/parser_stress_func.inc let $FCT=MULTIPOLYGONFROMTEXT; -- source include/parser_stress_func.inc let $FCT=MULTIPOLYGONFROMWKB; -- source include/parser_stress_func.inc let $FCT=NAME_CONST; -- source include/parser_stress_func.inc let $FCT=NULLIF; -- source include/parser_stress_func.inc let $FCT=NUMGEOMETRIES; -- source include/parser_stress_func.inc let $FCT=NUMINTERIORRINGS; -- source include/parser_stress_func.inc let $FCT=NUMPOINTS; -- source include/parser_stress_func.inc let $FCT=OCT; -- source include/parser_stress_func.inc let $FCT=OCTET_LENGTH; -- source include/parser_stress_func.inc let $FCT=ORD; -- source include/parser_stress_func.inc let $FCT=OVERLAPS; -- source include/parser_stress_func.inc let $FCT=PERIOD_ADD; -- source include/parser_stress_func.inc let $FCT=PERIOD_DIFF; -- source include/parser_stress_func.inc let $FCT=PI; -- source include/parser_stress_func.inc let $FCT=POINTFROMTEXT; -- source include/parser_stress_func.inc let $FCT=POINTFROMWKB; -- source include/parser_stress_func.inc let $FCT=POINTN; -- source include/parser_stress_func.inc let $FCT=POLYFROMTEXT; -- source include/parser_stress_func.inc let $FCT=POLYFROMWKB; -- source include/parser_stress_func.inc let $FCT=POLYGONFROMTEXT; -- source include/parser_stress_func.inc let $FCT=POLYGONFROMWKB; -- source include/parser_stress_func.inc let $FCT=POW; -- source include/parser_stress_func.inc let $FCT=POWER; -- source include/parser_stress_func.inc let $FCT=QUOTE; -- source include/parser_stress_func.inc let $FCT=RADIANS; -- source include/parser_stress_func.inc let $FCT=RAND; -- source include/parser_stress_func.inc let $FCT=RELEASE_LOCK; -- source include/parser_stress_func.inc let $FCT=REVERSE; -- source include/parser_stress_func.inc let $FCT=ROUND; -- source include/parser_stress_func.inc let $FCT=ROW_COUNT; -- source include/parser_stress_func.inc let $FCT=RPAD; -- source include/parser_stress_func.inc let $FCT=RTRIM; -- source include/parser_stress_func.inc let $FCT=SEC_TO_TIME; -- source include/parser_stress_func.inc let $FCT=SESSION_USER; -- source include/parser_stress_func.inc let $FCT=SHA; -- source include/parser_stress_func.inc let $FCT=SHA1; -- source include/parser_stress_func.inc let $FCT=SIGN; -- source include/parser_stress_func.inc let $FCT=SIN; -- source include/parser_stress_func.inc let $FCT=SLEEP; -- source include/parser_stress_func.inc let $FCT=SOUNDEX; -- source include/parser_stress_func.inc let $FCT=SPACE; -- source include/parser_stress_func.inc let $FCT=SQRT; -- source include/parser_stress_func.inc let $FCT=SRID; -- source include/parser_stress_func.inc let $FCT=STARTPOINT; -- source include/parser_stress_func.inc let $FCT=STRCMP; -- source include/parser_stress_func.inc let $FCT=STR_TO_DATE; -- source include/parser_stress_func.inc let $FCT=SUBDATE; -- source include/parser_stress_func.inc let $FCT=SUBSTRING_INDEX; -- source include/parser_stress_func.inc let $FCT=SUBTIME; -- source include/parser_stress_func.inc let $FCT=SYSTEM_USER; -- source include/parser_stress_func.inc let $FCT=TAN; -- source include/parser_stress_func.inc let $FCT=TIMEDIFF; -- source include/parser_stress_func.inc let $FCT=TIME_FORMAT; -- source include/parser_stress_func.inc let $FCT=TIME_TO_SEC; -- source include/parser_stress_func.inc let $FCT=TOUCHES; -- source include/parser_stress_func.inc let $FCT=TO_DAYS; -- source include/parser_stress_func.inc let $FCT=UCASE; -- source include/parser_stress_func.inc let $FCT=UNCOMPRESS; -- source include/parser_stress_func.inc let $FCT=UNCOMPRESSED_LENGTH; -- source include/parser_stress_func.inc let $FCT=UNHEX; -- source include/parser_stress_func.inc let $FCT=UNIX_TIMESTAMP; -- source include/parser_stress_func.inc let $FCT=UPDATEXML; -- source include/parser_stress_func.inc let $FCT=UPPER; -- source include/parser_stress_func.inc let $FCT=UUID; -- source include/parser_stress_func.inc let $FCT=VERSION; -- source include/parser_stress_func.inc let $FCT=WEEKDAY; -- source include/parser_stress_func.inc let $FCT=WEEKOFYEAR; -- source include/parser_stress_func.inc let $FCT=WITHIN; -- source include/parser_stress_func.inc let $FCT=X; -- source include/parser_stress_func.inc let $FCT=Y; -- source include/parser_stress_func.inc let $FCT=YEARWEEK; -- source include/parser_stress_func.inc --- 1.38/mysql-test/r/func_math.result 2006-10-27 14:45:05 -07:00 +++ 1.39/mysql-test/r/func_math.result 2006-10-27 14:45:05 -07:00 @@ -102,6 +102,18 @@ Note 1003 select pi() AS `pi()`,format(s 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 --- 1.27/mysql-test/t/func_math.test 2006-10-27 14:45:05 -07:00 +++ 1.28/mysql-test/t/func_math.test 2006-10-27 14:45:05 -07:00 @@ -34,6 +34,11 @@ select pi(),format(sin(pi()/2),6),format 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 # --- 1.14/sql/item_geofunc.h 2006-10-27 14:45:05 -07:00 +++ 1.15/sql/item_geofunc.h 2006-10-27 14:45:05 -07:00 @@ -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 --- 1.219/tests/mysql_client_test.c 2006-10-27 14:45:05 -07:00 +++ 1.220/tests/mysql_client_test.c 2006-10-27 14:45:05 -07:00 @@ -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\"");
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (malff:1.2328) BUG#21114 | marc.alff | 27 Oct |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 2.698 sec. using MySQL 5.1.14-beta-log