| List: | Commits | « Previous MessageNext Message » | |
| From: | marc.alff | Date: | September 28 2006 2:01am |
| Subject: | bk commit into 5.1 tree (malff:1.2307) | ||
| 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-09-27 17:01:39-07:00, malff@weblab.(none) +18 -0 NOT READY FOR FORMAL REVIEW Intermediate check-in only --- Intermediate CSET, please ignore. mysql-test/include/parser_stress_func.inc@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +44 -0 New tests mysql-test/include/parser_stress_func.inc@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +0 -0 mysql-test/r/func_math.result@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +12 -0 Improved test coverage mysql-test/r/func_misc.result@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +112 -0 Testing edge conditions for builtin functions mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +4703 -0 New tests mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +0 -0 mysql-test/r/view.result@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +4 -4 Name collision, x() is a geometry builtin function mysql-test/t/func_math.test@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +5 -0 Improved test coverage mysql-test/t/func_misc.test@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +143 -0 Testing edge conditions for builtin functions mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +419 -0 New tests mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +0 -0 mysql-test/t/view.test@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +3 -3 Name collision, x() is a geometry builtin function sql/item_create.cc@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +2500 -314 Revised the create_func implementation sql/item_create.h@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +2129 -144 Revised the create_func implementation sql/lex.h@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +4 -213 Removed function parsing from the lexical parser sql/lex_symbol.h@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +0 -1 Removed function parsing from the lexical parser sql/mysql_priv.h@stripped, 2006-09-27 17:01:35-07:00, malff@weblab.(none) +4 -0 Server initialization and shutdown sql/mysqld.cc@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +2 -0 Server initialization and shutdown sql/share/errmsg.txt@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +4 -0 New error messages sql/sql_yacc.yy@stripped, 2006-09-27 17:01:36-07:00, malff@weblab.(none) +535 -718 Documented the tokens, reorganized the functions tests/mysql_client_test.c@stripped, 2006-09-27 17:01:36-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 --- 1.66/sql/item_create.cc 2006-09-27 17:01:46 -07:00 +++ 1.67/sql/item_create.cc 2006-09-27 17:01:46 -07:00 @@ -17,725 +17,2911 @@ /* Functions to create an item. Used by lex.h */ #include "mysql_priv.h" +#include "item_create.h" +#include "sp_head.h" +#include "sp.h" + +// Helpers +#ifndef HAVE_SPATIAL +static int error_spatial_disabled() +{ + // FIXME: error message can't be translated. + my_error(ER_FEATURE_DISABLED, MYF(0), + sym_group_geom.name, sym_group_geom.needed_define); + return 1; +} +#endif + +int create_qfunc::create( + THD *thd, LEX_STRING name, + List<Item> *item_list, Item *& func) +{ + LEX_STRING db; + if (thd->copy_db_to(&db.str, &db.length)) + { + return 1; + } + + return create(thd, db, name, item_list, func); +} + +#ifdef HAVE_DLOPEN +create_udf_func create_udf_func::s_singleton; + +int create_udf_func::create( + THD *thd, LEX_STRING name, + List<Item> *item_list, Item *& func) +{ + udf_func *udf= find_udf(name.str, name.length); + DBUG_ASSERT(udf); + return create(thd, udf, item_list, func); +} + +int create_udf_func::create( + THD *thd, udf_func *udf, + List<Item> *item_list, Item *& func) +{ + int error=0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + 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 Item_func_udf_str(udf, *item_list); + else + func= new Item_func_udf_str(udf); + } + else + { + if (arg_count) + func= new Item_sum_udf_str(udf, *item_list); + else + func= new Item_sum_udf_str(udf); + } + break; + } + case REAL_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new Item_func_udf_float(udf, *item_list); + else + func= new Item_func_udf_float(udf); + } + else + { + if (arg_count) + func= new Item_sum_udf_float(udf, *item_list); + else + func= new Item_sum_udf_float(udf); + } + break; + } + case INT_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new Item_func_udf_int(udf, *item_list); + else + func= new Item_func_udf_int(udf); + } + else + { + if (arg_count) + func= new Item_sum_udf_int(udf, *item_list); + else + func= new Item_sum_udf_int(udf); + } + break; + } + case DECIMAL_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new Item_func_udf_decimal(udf, *item_list); + else + func= new Item_func_udf_decimal(udf); + } + else + { + if (arg_count) + func= new Item_sum_udf_decimal(udf, *item_list); + else + func= new Item_sum_udf_decimal(udf); + } + break; + } + default: + { + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "UDF return type"); + error=1; + } + } + return error; +} +#endif + +create_sp_func create_sp_func::s_singleton; + +int create_sp_func::create( + THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list, Item *& func) +{ + int arg_count= 0; + LEX *lex= thd->lex; + sp_name *qname= new 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 Item_func_sp(lex->current_context(), qname, *item_list); + } + else + { + func= new Item_func_sp(lex->current_context(), qname); + } + lex->safe_to_cache_query= 0; + return 0; +} + + +int create_func_arg0::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error; + int arg_count= 0; -Item *create_func_abs(Item* a) + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count != 0) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + error= create(thd, func); + } + + return error; +} + +int create_func_arg1::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_abs(a); + int error; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count != 1) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + Item *param_1= item_list->pop(); + error= create(thd, param_1, func); + } + + return error; } -Item *create_func_acos(Item* a) +int create_func_arg2::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_acos(a); + int error; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count != 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + error= create(thd, param_1, param_2, func); + } + + return error; +} + + +int create_func_arg3::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count != 3) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *param_3= item_list->pop(); + error= create(thd, param_1, param_2, param_3, func); + } + + return error; } -Item *create_func_aes_encrypt(Item* a, Item* b) +create_func_abs create_func_abs::s_singleton; + +int create_func_abs::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_aes_encrypt(a, b); + func= new Item_func_abs(arg1); + return 0; } -Item *create_func_aes_decrypt(Item* a, Item* b) +create_func_acos create_func_acos::s_singleton; + +int create_func_acos::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_aes_decrypt(a, b); + func= new Item_func_acos(arg1); + return 0; } -Item *create_func_ascii(Item* a) +create_func_addtime create_func_addtime::s_singleton; + +int create_func_addtime::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_ascii(a); + func= new Item_func_add_time(arg1, arg2, 0, 0); + return 0; } -Item *create_func_ord(Item* a) +create_func_aes_encrypt create_func_aes_encrypt::s_singleton; + +int create_func_aes_encrypt::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_ord(a); + func= new Item_func_aes_encrypt(arg1, arg2); + return 0; } -Item *create_func_asin(Item* a) +create_func_aes_decrypt create_func_aes_decrypt::s_singleton; + +int create_func_aes_decrypt::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_asin(a); + func= new Item_func_aes_decrypt(arg1, arg2); + return 0; } -Item *create_func_bin(Item* a) +create_func_area create_func_area::s_singleton; + +int create_func_area::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 2,1)); +#ifdef HAVE_SPATIAL + func= new Item_func_area(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_bit_count(Item* a) +create_func_as_wkb create_func_as_wkb::s_singleton; + +int create_func_as_wkb::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_bit_count(a); +#ifdef HAVE_SPATIAL + func= new Item_func_as_wkb(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_ceiling(Item* a) +create_func_as_wkt create_func_as_wkt::s_singleton; + +int create_func_as_wkt::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_ceiling(a); +#ifdef HAVE_SPATIAL + func= new Item_func_as_wkt(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_connection_id(void) +create_func_asin create_func_asin::s_singleton; + +int create_func_asin::create( + THD *thd, Item *arg1, Item *& func) { - current_thd->lex->safe_to_cache_query= 0; - return new Item_func_connection_id(); + func= new Item_func_asin(arg1); + return 0; } -Item *create_func_conv(Item* a, Item *b, Item *c) +create_func_atan create_func_atan::s_singleton; + +int create_func_atan::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_conv(a,b,c); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_atan(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_atan(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_cos(Item* a) +create_func_benchmark create_func_benchmark::s_singleton; + +int create_func_benchmark::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_cos(a); + int error; + + /* + Previously, this constraint was in the parser grammar. + Just accepting an int constant for the first parameter. + TODO: Item_func_format should accept a real expression. + */ + if ((arg1->type() != Item::INT_ITEM) || ! arg1->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_BUILTIN_FCT, MYF(0), "BENCHMARK"); + func= NULL; + error= 1; + } + else + { + func= new Item_func_benchmark(arg1->val_int(), arg2); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + error= 0; + } + return error; } -Item *create_func_cot(Item* a) +create_func_bin create_func_bin::s_singleton; + +int create_func_bin::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_div(new Item_int((char*) "1",1,1), - new Item_func_tan(a)); + Item *i10= new Item_int((int32) 10,2); + Item *i2= new Item_int((int32) 2,1); + func= new Item_func_conv(arg1, i10, i2); + return 0; } -Item *create_func_date_format(Item* a,Item *b) +create_func_bit_count create_func_bit_count::s_singleton; + +int create_func_bit_count::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_date_format(a,b,0); + func= new Item_func_bit_count(arg1); + return 0; } -Item *create_func_dayofmonth(Item* a) +create_func_bit_length create_func_bit_length::s_singleton; + +int create_func_bit_length::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_dayofmonth(a); + func= new Item_func_bit_length(arg1); + return 0; } -Item *create_func_dayofweek(Item* a) +create_func_ceiling create_func_ceiling::s_singleton; + +int create_func_ceiling::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_weekday(a, 1); + func= new Item_func_ceiling(arg1); + return 0; } -Item *create_func_dayofyear(Item* a) +create_func_centroid create_func_centroid::s_singleton; + +int create_func_centroid::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_dayofyear(a); +#ifdef HAVE_SPATIAL + func= new Item_func_centroid(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_dayname(Item* a) +create_func_char_length create_func_char_length::s_singleton; + +int create_func_char_length::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_dayname(a); + func= new Item_func_char_length(arg1); + return 0; } -Item *create_func_degrees(Item *a) +create_func_coercibility create_func_coercibility::s_singleton; + +int create_func_coercibility::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_units((char*) "degrees",a,180/M_PI,0.0); + func= new Item_func_coercibility(arg1); + return 0; } -Item *create_func_exp(Item* a) +create_func_concat create_func_concat::s_singleton; + +int create_func_concat::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_exp(a); + int error; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 1) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + func= new Item_func_concat(*item_list); + error= 0; + } + + return error; } -Item *create_func_find_in_set(Item* a, Item *b) +create_func_concat_ws create_func_concat_ws::s_singleton; + +int create_func_concat_ws::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_find_in_set(a, b); + int error; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + // TODO : Investigate why CONCAT_WS historically needs 2+ args, + // while CONCAT accepts 1+ + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + func= new Item_func_concat_ws(*item_list); + error= 0; + } + + return error; } +create_func_compress create_func_compress::s_singleton; -Item *create_func_floor(Item* a) +int create_func_compress::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_floor(a); + func= new Item_func_compress(arg1); + return 0; } -Item *create_func_found_rows(void) +create_func_connection_id create_func_connection_id::s_singleton; + +int create_func_connection_id::create( + THD *thd, Item *& func) { - THD *thd=current_thd; + func= new Item_func_connection_id(); thd->lex->safe_to_cache_query= 0; - return new Item_func_found_rows(); + return 0; } -Item *create_func_from_days(Item* a) +create_func_contains create_func_contains::s_singleton; + +int create_func_contains::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_from_days(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_CONTAINS_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_get_lock(Item* a, Item *b) +create_func_conv create_func_conv::s_singleton; + +int create_func_conv::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_get_lock(a, b); + func= new Item_func_conv(arg1, arg2, arg3); + return 0; } -Item *create_func_hex(Item *a) +create_func_convert_tz create_func_convert_tz::s_singleton; + +int create_func_convert_tz::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) { - return new Item_func_hex(a); + if (thd->lex->add_time_zone_tables_to_query_tables(thd)) + { + return 1; + } + func= new Item_func_convert_tz(arg1, arg2, arg3); + return 0; } -Item *create_func_inet_ntoa(Item* a) +create_func_cos create_func_cos::s_singleton; + +int create_func_cos::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_inet_ntoa(a); + func= new Item_func_cos(arg1); + return 0; } -Item *create_func_inet_aton(Item* a) +create_func_cot create_func_cot::s_singleton; + +int create_func_cot::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_inet_aton(a); + Item *i1= new Item_int((char*) "1", 1, 1); + func= new Item_func_div(i1, new Item_func_tan(arg1)); + return 0; } +create_func_crc32 create_func_crc32::s_singleton; -Item *create_func_ifnull(Item* a, Item *b) +int create_func_crc32::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_ifnull(a,b); + func= new Item_func_crc32(arg1); + return 0; } -Item *create_func_nullif(Item* a, Item *b) +create_func_crosses create_func_crosses::s_singleton; + +int create_func_crosses::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_nullif(a,b); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_CROSSES_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_locate(Item* a, Item *b) +create_func_date_format create_func_date_format::s_singleton; + +int create_func_date_format::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_locate(b,a); + func= new Item_func_date_format(arg1, arg2, 0); + return 0; } -Item *create_func_instr(Item* a, Item *b) +create_func_datediff create_func_datediff::s_singleton; + +int create_func_datediff::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_locate(a,b); + func= new Item_func_minus(new Item_func_to_days(arg1), + new Item_func_to_days(arg2)); + + return 0; } -Item *create_func_isnull(Item* a) +create_func_dayname create_func_dayname::s_singleton; + +int create_func_dayname::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_isnull(a); + func= new Item_func_dayname(arg1); + return 0; } -Item *create_func_lcase(Item* a) +create_func_dayofmonth create_func_dayofmonth::s_singleton; + +int create_func_dayofmonth::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_lcase(a); + func= new Item_func_dayofmonth(arg1); + return 0; } -Item *create_func_length(Item* a) +create_func_dayofweek create_func_dayofweek::s_singleton; + +int create_func_dayofweek::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_length(a); + func= new Item_func_weekday(arg1, 1); + return 0; } -Item *create_func_bit_length(Item* a) +create_func_dayofyear create_func_dayofyear::s_singleton; + +int create_func_dayofyear::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_bit_length(a); + func= new Item_func_dayofyear(arg1); + return 0; } -Item *create_func_coercibility(Item* a) +create_func_decode create_func_decode::s_singleton; + +int create_func_decode::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_coercibility(a); + int error; + + /* + Previously, this constraint was in the parser grammar. + Just accepting a string constant for the first parameter. + TODO: Item_func_decode should accept a real expression. + */ + if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_BUILTIN_FCT, MYF(0), "DECODE"); + func= NULL; + error= 1; + } + else + { + String dummy; + String *val = arg2->val_str(& dummy); + DBUG_ASSERT(val); + func= new Item_func_decode(arg1, val->c_ptr()); + error= 0; + } + return error; } -Item *create_func_char_length(Item* a) +create_func_degrees create_func_degrees::s_singleton; + +int create_func_degrees::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_char_length(a); + func= new Item_func_units((char*) "degrees", arg1 ,180/M_PI, 0.0); + return 0; } -Item *create_func_ln(Item* a) +create_func_des_decrypt create_func_des_decrypt::s_singleton; + +int create_func_des_decrypt::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_ln(a); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_des_decrypt(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_des_decrypt(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_log2(Item* a) +create_func_des_encrypt create_func_des_encrypt::s_singleton; + +int create_func_des_encrypt::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_log2(a); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_des_encrypt(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_des_encrypt(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_log10(Item* a) +create_func_dimension create_func_dimension::s_singleton; + +int create_func_dimension::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_log10(a); +#ifdef HAVE_SPATIAL + func= new Item_func_dimension(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_lpad(Item* a, Item *b, Item *c) +create_func_disjoint create_func_disjoint::s_singleton; + +int create_func_disjoint::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_lpad(a,b,c); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_DISJOINT_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_ltrim(Item* a) +create_func_elt create_func_elt::s_singleton; + +int create_func_elt::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_ltrim(a); + int error; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + func= new Item_func_elt(*item_list); + error= 0; + } + + return error; } -Item *create_func_md5(Item* a) +create_func_encode create_func_encode::s_singleton; + +int create_func_encode::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_md5(a); + int error; + + /* + Previously, this constraint was in the parser grammar. + Just accepting a string constant for the first parameter. + TODO: Item_func_encode should accept a real expression. + */ + if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_BUILTIN_FCT, MYF(0), "ENCODE"); + func= NULL; + error= 1; + } + else + { + String dummy; + String *val = arg2->val_str(& dummy); + DBUG_ASSERT(val); + func= new Item_func_encode(arg1, val->c_ptr()); + error= 0; + } + return error; } -Item *create_func_mod(Item* a, Item *b) +create_func_encrypt create_func_encrypt::s_singleton; + +int create_func_encrypt::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_mod(a,b); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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 Item_func_encrypt(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_name_const(Item *a, Item *b) +create_func_endpoint create_func_endpoint::s_singleton; + +int create_func_endpoint::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_name_const(a,b); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_decomp(arg1, Item_func::SP_ENDPOINT); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_monthname(Item* a) +create_func_envelope create_func_envelope::s_singleton; + +int create_func_envelope::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_monthname(a); +#ifdef HAVE_SPATIAL + func= new Item_func_envelope(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_month(Item* a) +create_func_equals create_func_equals::s_singleton; + +int create_func_equals::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_month(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_EQUALS_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_oct(Item *a) +create_func_exp create_func_exp::s_singleton; + +int create_func_exp::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 8,1)); + func= new Item_func_exp(arg1); + return 0; } -Item *create_func_period_add(Item* a, Item *b) +create_func_export_set create_func_export_set::s_singleton; + +int create_func_export_set::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_period_add(a,b); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + 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 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 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 Item_func_export_set(param_1, param_2, param_3, param_4, param_5); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_period_diff(Item* a, Item *b) +create_func_exteriorring create_func_exteriorring::s_singleton; + +int create_func_exteriorring::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_period_diff(a,b); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_decomp(arg1, Item_func::SP_EXTERIORRING); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_pi(void) +create_func_field create_func_field::s_singleton; + +int create_func_field::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_static_float_func("pi()", M_PI, 6, 8); + int error; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + func= new Item_func_field(*item_list); + error= 0; + } + + return error; } -Item *create_func_pow(Item* a, Item *b) +create_func_find_in_set create_func_find_in_set::s_singleton; + +int create_func_find_in_set::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_pow(a,b); + func= new Item_func_find_in_set(arg1, arg2); + return 0; } -Item *create_func_radians(Item *a) +create_func_floor create_func_floor::s_singleton; + +int create_func_floor::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_units((char*) "radians",a,M_PI/180,0.0); + func= new Item_func_floor(arg1); + return 0; } -Item *create_func_release_lock(Item* a) +create_func_format create_func_format::s_singleton; + +int create_func_format::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_release_lock(a); + int error; + + /* + Previously, this constraint was in the parser grammar. + Just accepting an int constant for the second parameter. + TODO: Item_func_format should accept a real expression. + */ + if ((arg2->type() != Item::INT_ITEM) || ! arg2->basic_const_item()) + { + my_error(ER_WRONG_PARAMETERS_TO_BUILTIN_FCT, MYF(0), "FORMAT"); + func= NULL; + error= 1; + } + else + { + func= new Item_func_format(arg1, arg2->val_int()); + error= 0; + } + return error; } -Item *create_func_repeat(Item* a, Item *b) +create_func_found_rows create_func_found_rows::s_singleton; + +int create_func_found_rows::create( + THD *thd, Item *& func) { - return new Item_func_repeat(a,b); + func= new Item_func_found_rows(); + thd->lex->safe_to_cache_query= 0; + return 0; } -Item *create_func_reverse(Item* a) +create_func_from_days create_func_from_days::s_singleton; + +int create_func_from_days::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_reverse(a); + func= new Item_func_from_days(arg1); + return 0; } -Item *create_func_rpad(Item* a, Item *b, Item *c) +create_func_from_unixtime create_func_from_unixtime::s_singleton; + +int create_func_from_unixtime::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_rpad(a,b,c); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_from_unixtime(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *ut= new Item_func_from_unixtime(param_1); + func= new Item_func_date_format(ut, param_2, 0); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } +create_func_geometry_from_text create_func_geometry_from_text::s_singleton; -Item *create_func_rtrim(Item* a) +int create_func_geometry_from_text::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_rtrim(a); +#ifdef HAVE_SPATIAL + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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 Item_func_geometry_from_text(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_sec_to_time(Item* a) +create_func_geometry_from_wkb create_func_geometry_from_wkb::s_singleton; + +int create_func_geometry_from_wkb::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_sec_to_time(a); +#ifdef HAVE_SPATIAL + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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 Item_func_geometry_from_wkb(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_sign(Item* a) +create_func_geometry_type create_func_geometry_type::s_singleton; + +int create_func_geometry_type::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_sign(a); +#ifdef HAVE_SPATIAL + func= new Item_func_geometry_type(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_sin(Item* a) +create_func_geometryn create_func_geometryn::s_singleton; + +int create_func_geometryn::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_sin(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_decomp_n(arg1, arg2, Item_func::SP_GEOMETRYN); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_sha(Item* a) +create_func_get_lock create_func_get_lock::s_singleton; + +int create_func_get_lock::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_sha(a); + func= new Item_func_get_lock(arg1, arg2); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; } -Item *create_func_sleep(Item* a) +create_func_glength create_func_glength::s_singleton; + +int create_func_glength::create( + THD *thd, Item *arg1, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_sleep(a); +#ifdef HAVE_SPATIAL + func= new Item_func_glength(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_space(Item *a) +create_func_greatest create_func_greatest::s_singleton; + +int create_func_greatest::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - CHARSET_INFO *cs= current_thd->variables.collation_connection; - Item *sp; + int error; + int arg_count= 0; - if (cs->mbminlen > 1) + if (item_list != NULL) { - uint dummy_errors; - sp= new Item_string("",0,cs); - if (sp) - sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors); + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; } else { - sp= new Item_string(" ",1,cs); + func= new Item_func_max(*item_list); + error= 0; } - return sp ? new Item_func_repeat(sp, a) : 0; + + return error; +} + +create_func_hex create_func_hex::s_singleton; + +int create_func_hex::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_hex(arg1); + return 0; } -Item *create_func_soundex(Item* a) +create_func_ifnull create_func_ifnull::s_singleton; + +int create_func_ifnull::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_soundex(a); + func= new Item_func_ifnull(arg1, arg2); + return 0; } -Item *create_func_sqrt(Item* a) +create_func_inet_ntoa create_func_inet_ntoa::s_singleton; + +int create_func_inet_ntoa::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_sqrt(a); + func= new Item_func_inet_ntoa(arg1); + return 0; } -Item *create_func_strcmp(Item* a, Item *b) +create_func_inet_aton create_func_inet_aton::s_singleton; + +int create_func_inet_aton::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_strcmp(a,b); + func= new Item_func_inet_aton(arg1); + return 0; } -Item *create_func_tan(Item* a) +create_func_instr create_func_instr::s_singleton; + +int create_func_instr::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_tan(a); + func= new Item_func_locate(arg1, arg2); + return 0; } -Item *create_func_time_format(Item *a, Item *b) +create_func_interiorringn create_func_interiorringn::s_singleton; + +int create_func_interiorringn::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_date_format(a,b,1); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_decomp_n(arg1, arg2, Item_func::SP_INTERIORRINGN); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_time_to_sec(Item* a) +create_func_intersects create_func_intersects::s_singleton; + +int create_func_intersects::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_time_to_sec(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_INTERSECTS_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_to_days(Item* a) +create_func_is_free_lock create_func_is_free_lock::s_singleton; + +int create_func_is_free_lock::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_to_days(a); + func= new Item_func_is_free_lock(arg1); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; } -Item *create_func_ucase(Item* a) +create_func_is_used_lock create_func_is_used_lock::s_singleton; + +int create_func_is_used_lock::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_ucase(a); + func= new Item_func_is_used_lock(arg1); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; } -Item *create_func_unhex(Item* a) +create_func_isclosed create_func_isclosed::s_singleton; + +int create_func_isclosed::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_unhex(a); +#ifdef HAVE_SPATIAL + func= new Item_func_isclosed(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_uuid(void) +create_func_isempty create_func_isempty::s_singleton; + +int create_func_isempty::create( + THD *thd, Item *arg1, Item *& func) { - THD *thd= current_thd; -#ifdef HAVE_ROW_BASED_REPLICATION - thd->lex->binlog_row_based_if_mixed= TRUE; +#ifdef HAVE_SPATIAL + func= new Item_func_isempty(arg1); + return 0; +#else + return error_spatial_disabled(); #endif - return new(thd->mem_root) Item_func_uuid(); } -Item *create_func_version(void) +create_func_isnull create_func_isnull::s_singleton; + +int create_func_isnull::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_static_string_func("version()", server_version, - (uint) strlen(server_version), - system_charset_info, DERIVATION_SYSCONST); + func= new Item_func_isnull(arg1); + return 0; } -Item *create_func_weekday(Item* a) +create_func_issimple create_func_issimple::s_singleton; + +int create_func_issimple::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_weekday(a, 0); +#ifdef HAVE_SPATIAL + func= new Item_func_issimple(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_year(Item* a) +create_func_last_day create_func_last_day::s_singleton; + +int create_func_last_day::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_year(a); + func= new Item_func_last_day(arg1); + return 0; } -Item *create_load_file(Item* a) +create_func_last_insert_id create_func_last_insert_id::s_singleton; + +int create_func_last_insert_id::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_load_file(a); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 0: + { + func= new Item_func_last_insert_id(); + thd->lex->safe_to_cache_query= 0; + break; + } + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_last_insert_id(param_1); + thd->lex->safe_to_cache_query= 0; + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; +} +create_func_lcase create_func_lcase::s_singleton; + +int create_func_lcase::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_lcase(arg1); + return 0; } +create_func_least create_func_least::s_singleton; -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs) +int create_func_least::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - Item *res; - int tmp_len; - LINT_INIT(res); + int error; + int arg_count= 0; - 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) + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + func= new Item_func_min(*item_list); + error= 0; + } + + return error; +} + +create_func_length create_func_length::s_singleton; + +int create_func_length::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_length(arg1); + return 0; +} + +create_func_ln create_func_ln::s_singleton; + +int create_func_ln::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_ln(arg1); + return 0; +} + +create_func_load_file create_func_load_file::s_singleton; + +int create_func_load_file::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_load_file(arg1); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; +} + +create_func_locate create_func_locate::s_singleton; + +int create_func_locate::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 2: { - my_error(ER_M_BIGGER_THAN_D, MYF(0), ""); - return 0; + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + // Yes, parameters in that order : 2, 1 + func= new 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 Item_func_locate(param_2, param_1, param_3); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; } - 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; } - return res; + + return error; +} + +create_func_log create_func_log::s_singleton; + +int create_func_log::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_log(param_1); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_log(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; +} + +create_func_log10 create_func_log10::s_singleton; + +int create_func_log10::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_log10(arg1); + return 0; +} + +create_func_log2 create_func_log2::s_singleton; + +int create_func_log2::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_log2(arg1); + return 0; +} + +create_func_lpad create_func_lpad::s_singleton; + +int create_func_lpad::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) +{ + func= new Item_func_lpad(arg1, arg2, arg3); + return 0; +} + +create_func_ltrim create_func_ltrim::s_singleton; + +int create_func_ltrim::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_ltrim(arg1); + return 0; +} + +create_func_makedate create_func_makedate::s_singleton; + +int create_func_makedate::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) +{ + func= new Item_func_makedate(arg1, arg2); + return 0; +} + +create_func_maketime create_func_maketime::s_singleton; + +int create_func_maketime::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) +{ + func= new Item_func_maketime(arg1, arg2, arg3); + return 0; +} + +create_func_make_set create_func_make_set::s_singleton; + +int create_func_make_set::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + } + else + { + Item *param_1= item_list->pop(); + func= new Item_func_make_set(param_1, *item_list); + error= 0; + } + + return error; +} + +create_func_master_pos_wait create_func_master_pos_wait::s_singleton; + +int create_func_master_pos_wait::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new 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 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_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } +create_func_md5 create_func_md5::s_singleton; + +int create_func_md5::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_md5(arg1); + return 0; +} + +create_func_monthname create_func_monthname::s_singleton; + +int create_func_monthname::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_monthname(arg1); + return 0; +} + +create_func_name_const create_func_name_const::s_singleton; + +int create_func_name_const::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) +{ + func= new Item_name_const(arg1, arg2); + return 0; +} + +create_func_nullif create_func_nullif::s_singleton; + +int create_func_nullif::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) +{ + func= new Item_func_nullif(arg1, arg2); + return 0; +} + +create_func_numgeometries create_func_numgeometries::s_singleton; + +int create_func_numgeometries::create( + THD *thd, Item *arg1, Item *& func) +{ +#ifdef HAVE_SPATIAL + func= new Item_func_numgeometries(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif +} + +create_func_numinteriorring create_func_numinteriorring::s_singleton; + +int create_func_numinteriorring::create( + THD *thd, Item *arg1, Item *& func) +{ +#ifdef HAVE_SPATIAL + func= new Item_func_numinteriorring(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif +} + +create_func_numpoints create_func_numpoints::s_singleton; + +int create_func_numpoints::create( + THD *thd, Item *arg1, Item *& func) +{ +#ifdef HAVE_SPATIAL + func= new Item_func_numpoints(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif +} + +create_func_oct create_func_oct::s_singleton; + +int create_func_oct::create( + THD *thd, Item *arg1, Item *& func) +{ + Item *i10= new Item_int((int32) 10,2); + Item *i8= new Item_int((int32) 8,1); + func= new Item_func_conv(arg1, i10, i8); + return 0; +} + +create_func_ord create_func_ord::s_singleton; -Item *create_func_is_free_lock(Item* a) +int create_func_ord::create( + THD *thd, Item *arg1, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_free_lock(a); + func= new Item_func_ord(arg1); + return 0; } -Item *create_func_is_used_lock(Item* a) +create_func_overlaps create_func_overlaps::s_singleton; + +int create_func_overlaps::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_used_lock(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_OVERLAPS_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_quote(Item* a) +create_func_period_add create_func_period_add::s_singleton; + +int create_func_period_add::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_quote(a); + func= new Item_func_period_add(arg1, arg2); + return 0; } -Item *create_func_xml_extractvalue(Item *a, Item *b) +create_func_period_diff create_func_period_diff::s_singleton; + +int create_func_period_diff::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_xml_extractvalue(a, b); + func= new Item_func_period_diff(arg1, arg2); + return 0; } -Item *create_func_xml_update(Item *a, Item *b, Item *c) +create_func_pi create_func_pi::s_singleton; + +int create_func_pi::create( + THD *thd, Item *& func) { - return new Item_func_xml_update(a, b, c); + func= new Item_static_float_func("pi()", M_PI, 6, 8); + return 0; } +create_func_pointn create_func_pointn::s_singleton; + +int create_func_pointn::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) +{ #ifdef HAVE_SPATIAL -Item *create_func_as_wkt(Item *a) + func= new Item_func_spatial_decomp_n(arg1, arg2, Item_func::SP_POINTN); + return 0; +#else + return error_spatial_disabled(); +#endif +} + +create_func_pow create_func_pow::s_singleton; + +int create_func_pow::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_as_wkt(a); + func= new Item_func_pow(arg1, arg2); + return 0; } -Item *create_func_as_wkb(Item *a) +create_func_quote create_func_quote::s_singleton; + +int create_func_quote::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_as_wkb(a); + func= new Item_func_quote(arg1); + return 0; +} + +create_func_radians create_func_radians::s_singleton; + +int create_func_radians::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_units((char*) "radians", arg1, M_PI/180, 0.0); + return 0; +} + +create_func_rand create_func_rand::s_singleton; + +int create_func_rand::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 0: + { + func= new Item_func_rand(); + thd->lex->uncacheable(UNCACHEABLE_RAND); + break; + } + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_rand(param_1); + thd->lex->uncacheable(UNCACHEABLE_RAND); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; +} + +create_func_release_lock create_func_release_lock::s_singleton; + +int create_func_release_lock::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_release_lock(arg1); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; +} + +create_func_reverse create_func_reverse::s_singleton; + +int create_func_reverse::create( + THD *thd, Item *arg1, Item *& func) +{ + func= new Item_func_reverse(arg1); + return 0; +} + +create_func_round create_func_round::s_singleton; + +int create_func_round::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) +{ + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + Item *i0 = new Item_int((char*)"0", 0, 1); + func= new Item_func_round(param_1, i0, 0); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_round(param_1, param_2, 0); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_srid(Item *a) +create_func_row_count create_func_row_count::s_singleton; + +int create_func_row_count::create( + THD *thd, Item *& func) { - return new Item_func_srid(a); + func= new Item_func_row_count(); + thd->lex->safe_to_cache_query= 0; + return 0; } -Item *create_func_startpoint(Item *a) +create_func_rpad create_func_rpad::s_singleton; + +int create_func_rpad::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) { - return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT); + func= new Item_func_rpad(arg1, arg2, arg3); + return 0; } -Item *create_func_endpoint(Item *a) +create_func_rtrim create_func_rtrim::s_singleton; + +int create_func_rtrim::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT); + func= new Item_func_rtrim(arg1); + return 0; } -Item *create_func_exteriorring(Item *a) +create_func_sec_to_time create_func_sec_to_time::s_singleton; + +int create_func_sec_to_time::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING); + func= new Item_func_sec_to_time(arg1); + return 0; } -Item *create_func_pointn(Item *a, Item *b) +create_func_sha create_func_sha::s_singleton; + +int create_func_sha::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN); + func= new Item_func_sha(arg1); + return 0; } -Item *create_func_interiorringn(Item *a, Item *b) +create_func_sign create_func_sign::s_singleton; + +int create_func_sign::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN); + func= new Item_func_sign(arg1); + return 0; } -Item *create_func_geometryn(Item *a, Item *b) +create_func_sin create_func_sin::s_singleton; + +int create_func_sin::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN); + func= new Item_func_sin(arg1); + return 0; } -Item *create_func_centroid(Item *a) +create_func_sleep create_func_sleep::s_singleton; + +int create_func_sleep::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_centroid(a); + func= new Item_func_sleep(arg1); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return 0; } -Item *create_func_envelope(Item *a) +create_func_soundex create_func_soundex::s_singleton; + +int create_func_soundex::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_envelope(a); + func= new Item_func_soundex(arg1); + return 0; } -Item *create_func_equals(Item *a, Item *b) +create_func_space create_func_space::s_singleton; + +int create_func_space::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC); + // TODO : investigate using the collation at compile time ? runtime ? + CHARSET_INFO *cs= thd->variables.collation_connection; + Item *sp; + + if (cs->mbminlen > 1) + { + uint dummy_errors; + sp= new Item_string("", 0, cs); + sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors); + } + else + { + sp= new Item_string(" ", 1, cs); + } + + func= new Item_func_repeat(sp, arg1); + return 0; } -Item *create_func_disjoint(Item *a, Item *b) +create_func_sqrt create_func_sqrt::s_singleton; + +int create_func_sqrt::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC); + func= new Item_func_sqrt(arg1); + return 0; } -Item *create_func_intersects(Item *a, Item *b) +create_func_srid create_func_srid::s_singleton; + +int create_func_srid::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC); +#ifdef HAVE_SPATIAL + func= new Item_func_srid(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_touches(Item *a, Item *b) +create_func_startpoint create_func_startpoint::s_singleton; + +int create_func_startpoint::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_decomp(arg1, Item_func::SP_STARTPOINT); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_crosses(Item *a, Item *b) +create_func_str_to_date create_func_str_to_date::s_singleton; + +int create_func_str_to_date::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC); + func= new Item_func_str_to_date(arg1, arg2); + return 0; } -Item *create_func_within(Item *a, Item *b) +create_func_strcmp create_func_strcmp::s_singleton; + +int create_func_strcmp::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC); + func= new Item_func_strcmp(arg1, arg2); + return 0; } -Item *create_func_contains(Item *a, Item *b) +create_func_substr_index create_func_substr_index::s_singleton; + +int create_func_substr_index::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC); + func= new Item_func_substr_index(arg1, arg2, arg3); + return 0; } -Item *create_func_overlaps(Item *a, Item *b) +create_func_subtime create_func_subtime::s_singleton; + +int create_func_subtime::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC); + func= new Item_func_add_time(arg1, arg2, 0, 1); + return 0; } -Item *create_func_isempty(Item *a) +create_func_tan create_func_tan::s_singleton; + +int create_func_tan::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_isempty(a); + func= new Item_func_tan(arg1); + return 0; } -Item *create_func_issimple(Item *a) +create_func_time_format create_func_time_format::s_singleton; + +int create_func_time_format::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_issimple(a); + func= new Item_func_date_format(arg1, arg2, 1); + return 0; } -Item *create_func_isclosed(Item *a) +create_func_time_to_sec create_func_time_to_sec::s_singleton; + +int create_func_time_to_sec::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_isclosed(a); + func= new Item_func_time_to_sec(arg1); + return 0; } -Item *create_func_geometry_type(Item *a) +create_func_timediff create_func_timediff::s_singleton; + +int create_func_timediff::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_geometry_type(a); + func= new Item_func_timediff(arg1, arg2); + return 0; } -Item *create_func_dimension(Item *a) +create_func_to_days create_func_to_days::s_singleton; + +int create_func_to_days::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_dimension(a); + func= new Item_func_to_days(arg1); + return 0; } -Item *create_func_x(Item *a) +create_func_touches create_func_touches::s_singleton; + +int create_func_touches::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_x(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_TOUCHES_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_y(Item *a) +create_func_ucase create_func_ucase::s_singleton; + +int create_func_ucase::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_y(a); + func= new Item_func_ucase(arg1); + return 0; } -Item *create_func_numpoints(Item *a) +create_func_uncompress create_func_uncompress::s_singleton; + +int create_func_uncompress::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_numpoints(a); + func= new Item_func_uncompress(arg1); + return 0; } -Item *create_func_numinteriorring(Item *a) +create_func_uncompressed_length create_func_uncompressed_length::s_singleton; + +int create_func_uncompressed_length::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_numinteriorring(a); + func= new Item_func_uncompressed_length(arg1); + return 0; } -Item *create_func_numgeometries(Item *a) +create_func_unhex create_func_unhex::s_singleton; + +int create_func_unhex::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_numgeometries(a); + func= new Item_func_unhex(arg1); + return 0; } -Item *create_func_area(Item *a) +create_func_unix_timestamp create_func_unix_timestamp::s_singleton; + +int create_func_unix_timestamp::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_area(a); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 0: + { + func= new Item_func_unix_timestamp(); + thd->lex->safe_to_cache_query= 0; + break; + } + case 1: + { + Item *param_1= item_list->pop(); + func= new Item_func_unix_timestamp(param_1); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_glength(Item *a) +create_func_uuid create_func_uuid::s_singleton; + +int create_func_uuid::create( + THD *thd, Item *& func) { - return new Item_func_glength(a); + func= new(thd->mem_root) Item_func_uuid(); +#ifdef HAVE_ROW_BASED_REPLICATION + thd->lex->binlog_row_based_if_mixed= TRUE; +#endif + return 0; } -Item *create_func_point(Item *a, Item *b) +create_func_version create_func_version::s_singleton; + +int create_func_version::create( + THD *thd, Item *& func) { - return new Item_func_point(a, b); + func= new Item_static_string_func( + "version()", + server_version, + (uint) strlen(server_version), + system_charset_info, + DERIVATION_SYSCONST); + + return 0; } -#endif /*HAVE_SPATIAL*/ -Item *create_func_crc32(Item* a) +create_func_weekday create_func_weekday::s_singleton; + +int create_func_weekday::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_crc32(a); + func= new Item_func_weekday(arg1, 0); + return 0; } -Item *create_func_compress(Item* a) +create_func_weekofyear create_func_weekofyear::s_singleton; + +int create_func_weekofyear::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_compress(a); + func= new Item_func_week(arg1, new Item_int((char*) "0", 3, 1)); + return 0; } -Item *create_func_uncompress(Item* a) +create_func_within create_func_within::s_singleton; + +int create_func_within::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_uncompress(a); +#ifdef HAVE_SPATIAL + func= new Item_func_spatial_rel(arg1, arg2, Item_func::SP_WITHIN_FUNC); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_uncompressed_length(Item* a) +create_func_x create_func_x::s_singleton; + +int create_func_x::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_uncompressed_length(a); +#ifdef HAVE_SPATIAL + func= new Item_func_x(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_datediff(Item *a, Item *b) +create_func_xml_extractvalue create_func_xml_extractvalue::s_singleton; + +int create_func_xml_extractvalue::create( + THD *thd, Item *arg1, Item *arg2, Item *& func) { - return new Item_func_minus(new Item_func_to_days(a), - new Item_func_to_days(b)); + func= new Item_func_xml_extractvalue(arg1, arg2); + return 0; } -Item *create_func_weekofyear(Item *a) +create_func_xml_update create_func_xml_update::s_singleton; + +int create_func_xml_update::create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) { - return new Item_func_week(a, new Item_int((char*) "0", 3, 1)); + func= new Item_func_xml_update(arg1, arg2, arg3); + return 0; } -Item *create_func_makedate(Item* a,Item* b) +create_func_y create_func_y::s_singleton; + +int create_func_y::create( + THD *thd, Item *arg1, Item *& func) { - return new Item_func_makedate(a, b); +#ifdef HAVE_SPATIAL + func= new Item_func_y(arg1); + return 0; +#else + return error_spatial_disabled(); +#endif } -Item *create_func_addtime(Item* a,Item* b) +create_func_year_week create_func_year_week::s_singleton; + +int create_func_year_week::create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func) { - return new Item_func_add_time(a, b, 0, 0); + int error= 0; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + func= NULL; + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + Item *i0= new Item_int((char*) "0", 0, 1); + func= new Item_func_yearweek(param_1, i0); + break; + } + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new Item_func_yearweek(param_1, param_2); + break; + } + default: + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + error= 1; + break; + } + } + + return error; } -Item *create_func_subtime(Item* a,Item* b) +struct sql_func_registry { - return new Item_func_add_time(a, b, 0, 1); + LEX_STRING name; + create_func *builder; +}; + +/* + MySQL built-in functions. + MAINTAINER: + - Keep sorted for human lookup. At runtime, a hash table is used. + - do **NOT** use #ifdef / #ifndef for conditional entries: + doing so will cause user code that works against a --without-XYZ binary + to fail with name collisions against a --with-XYZ binary. + */ +static sql_func_registry func_array[] = +{ + { C_STRING_WITH_LEN("ABS"), & create_func_abs::s_singleton}, + { C_STRING_WITH_LEN("ACOS"), & create_func_acos::s_singleton}, + { C_STRING_WITH_LEN("ADDTIME"), & create_func_addtime::s_singleton}, + { C_STRING_WITH_LEN("AES_ENCRYPT"), & create_func_aes_encrypt::s_singleton}, + { C_STRING_WITH_LEN("AES_DECRYPT"), & create_func_aes_decrypt::s_singleton}, + { C_STRING_WITH_LEN("AREA"), & create_func_area::s_singleton}, + { C_STRING_WITH_LEN("ASBINARY"), & create_func_as_wkb::s_singleton}, + { C_STRING_WITH_LEN("ASTEXT"), & create_func_as_wkt::s_singleton}, + { C_STRING_WITH_LEN("ASWKB"), & create_func_as_wkb::s_singleton}, + { C_STRING_WITH_LEN("ASWKT"), & create_func_as_wkt::s_singleton}, + + { C_STRING_WITH_LEN("ASIN"), & create_func_asin::s_singleton}, + { C_STRING_WITH_LEN("ATAN"), & create_func_atan::s_singleton}, + { C_STRING_WITH_LEN("ATAN2"), & create_func_atan::s_singleton}, + { C_STRING_WITH_LEN("BENCHMARK"), & create_func_benchmark::s_singleton}, + { C_STRING_WITH_LEN("BIN"), & create_func_bin::s_singleton}, + { C_STRING_WITH_LEN("BIT_COUNT"), & create_func_bit_count::s_singleton}, + { C_STRING_WITH_LEN("BIT_LENGTH"), & create_func_bit_length::s_singleton}, + { C_STRING_WITH_LEN("CEIL"), & create_func_ceiling::s_singleton}, + { C_STRING_WITH_LEN("CEILING"), & create_func_ceiling::s_singleton}, + { C_STRING_WITH_LEN("CENTROID"), & create_func_centroid::s_singleton}, + { C_STRING_WITH_LEN("CHAR_LENGTH"), & create_func_char_length::s_singleton}, + { C_STRING_WITH_LEN("CHARACTER_LENGTH"), & create_func_char_length::s_singleton}, + { C_STRING_WITH_LEN("COERCIBILITY"), & create_func_coercibility::s_singleton}, + { C_STRING_WITH_LEN("CONCAT"), & create_func_concat::s_singleton}, + { C_STRING_WITH_LEN("CONCAT_WS"), & create_func_concat_ws::s_singleton}, + { C_STRING_WITH_LEN("COMPRESS"), & create_func_compress::s_singleton}, + { C_STRING_WITH_LEN("CONNECTION_ID"), & create_func_connection_id::s_singleton}, + { C_STRING_WITH_LEN("MBRCONTAINS"), & create_func_contains::s_singleton}, + { C_STRING_WITH_LEN("CONV"), & create_func_conv::s_singleton}, + { C_STRING_WITH_LEN("CONVERT_TZ"), & create_func_convert_tz::s_singleton}, + { C_STRING_WITH_LEN("COS"), & create_func_cos::s_singleton}, + { C_STRING_WITH_LEN("COT"), & create_func_cot::s_singleton}, + { C_STRING_WITH_LEN("CRC32"), & create_func_crc32::s_singleton}, + { C_STRING_WITH_LEN("CROSSES"), & create_func_crosses::s_singleton}, + { C_STRING_WITH_LEN("DATE_FORMAT"), & create_func_date_format::s_singleton}, + { C_STRING_WITH_LEN("DATEDIFF"), & create_func_datediff::s_singleton}, + { C_STRING_WITH_LEN("DAYNAME"), & create_func_dayname::s_singleton}, + { C_STRING_WITH_LEN("DAYOFMONTH"), & create_func_dayofmonth::s_singleton}, + { C_STRING_WITH_LEN("DAYOFWEEK"), & create_func_dayofweek::s_singleton}, + { C_STRING_WITH_LEN("DAYOFYEAR"), & create_func_dayofyear::s_singleton}, + { C_STRING_WITH_LEN("DECODE"), & create_func_decode::s_singleton}, + { C_STRING_WITH_LEN("DEGREES"), & create_func_degrees::s_singleton}, + + { C_STRING_WITH_LEN("DES_DECRYPT"), & create_func_des_decrypt::s_singleton}, + { C_STRING_WITH_LEN("DES_ENCRYPT"), & create_func_des_encrypt::s_singleton}, + { C_STRING_WITH_LEN("DIMENSION"), & create_func_dimension::s_singleton}, + { C_STRING_WITH_LEN("DISJOINT"), & create_func_disjoint::s_singleton}, + { C_STRING_WITH_LEN("ENDPOINT"), & create_func_endpoint::s_singleton}, + { C_STRING_WITH_LEN("ENVELOPE"), & create_func_envelope::s_singleton}, + { C_STRING_WITH_LEN("EQUALS"), & create_func_equals::s_singleton}, + { C_STRING_WITH_LEN("EXP"), & create_func_exp::s_singleton}, + { C_STRING_WITH_LEN("EXPORT_SET"), & create_func_export_set::s_singleton}, + { C_STRING_WITH_LEN("EXTERIORRING"), & create_func_exteriorring::s_singleton}, + { C_STRING_WITH_LEN("FIND_IN_SET"), & create_func_find_in_set::s_singleton}, + { C_STRING_WITH_LEN("FLOOR"), & create_func_floor::s_singleton}, + { C_STRING_WITH_LEN("FORMAT"), & create_func_format::s_singleton}, + { C_STRING_WITH_LEN("FOUND_ROWS"), & create_func_found_rows::s_singleton}, + { C_STRING_WITH_LEN("FROM_DAYS"), & create_func_from_days::s_singleton}, + { C_STRING_WITH_LEN("FROM_UNIXTIME"), & create_func_from_unixtime::s_singleton}, + + { C_STRING_WITH_LEN("FIELD"), & create_func_field::s_singleton}, + { C_STRING_WITH_LEN("ELT"), & create_func_elt::s_singleton}, + { C_STRING_WITH_LEN("ENCODE"), & create_func_encode::s_singleton}, + { C_STRING_WITH_LEN("ENCRYPT"), & create_func_encrypt::s_singleton}, + + // FIXME: lots of aliases + { C_STRING_WITH_LEN("POINTFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("GEOMFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("GEOMETRYFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MLINEFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MPOINTFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MPOLYFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("POLYFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("POLYGONFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("LINEFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + { C_STRING_WITH_LEN("LINESTRINGFROMTEXT"), & create_func_geometry_from_text::s_singleton}, + + // FIXME: lots of aliases + { C_STRING_WITH_LEN("GEOMCOLLFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("GEOMETRYFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("GEOMFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("LINEFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("LINESTRINGFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MLINEFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MPOINTFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MPOLYFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MULTIPOINTFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("POINTFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("POLYFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + { C_STRING_WITH_LEN("POLYGONFROMWKB"), & create_func_geometry_from_wkb::s_singleton}, + + { C_STRING_WITH_LEN("GEOMETRYTYPE"), & create_func_geometry_type::s_singleton}, + { C_STRING_WITH_LEN("GEOMETRYN"), & create_func_geometryn::s_singleton}, + { C_STRING_WITH_LEN("GET_LOCK"), & create_func_get_lock::s_singleton}, + { C_STRING_WITH_LEN("GLENGTH"), & create_func_glength::s_singleton}, + { C_STRING_WITH_LEN("GREATEST"), & create_func_greatest::s_singleton}, + { C_STRING_WITH_LEN("HEX"), & create_func_hex::s_singleton}, + { C_STRING_WITH_LEN("IFNULL"), & create_func_ifnull::s_singleton}, + { C_STRING_WITH_LEN("INET_NTOA"), & create_func_inet_ntoa::s_singleton}, + { C_STRING_WITH_LEN("INET_ATON"), & create_func_inet_aton::s_singleton}, + { C_STRING_WITH_LEN("INSTR"), & create_func_instr::s_singleton}, + { C_STRING_WITH_LEN("INTERIORRINGN"), & create_func_interiorringn::s_singleton}, + { C_STRING_WITH_LEN("INTERSECTS"), & create_func_intersects::s_singleton}, + { C_STRING_WITH_LEN("IS_FREE_LOCK"), & create_func_is_free_lock::s_singleton}, + { C_STRING_WITH_LEN("IS_USED_LOCK"), & create_func_is_used_lock::s_singleton}, + { C_STRING_WITH_LEN("ISCLOSED"), & create_func_isclosed::s_singleton}, + { C_STRING_WITH_LEN("ISEMPTY"), & create_func_isempty::s_singleton}, + { C_STRING_WITH_LEN("ISNULL"), & create_func_isnull::s_singleton}, + { C_STRING_WITH_LEN("ISSIMPLE"), & create_func_issimple::s_singleton}, + { C_STRING_WITH_LEN("LAST_DAY"), & create_func_last_day::s_singleton}, + { C_STRING_WITH_LEN("LAST_INSERT_ID"), & create_func_last_insert_id::s_singleton}, + { C_STRING_WITH_LEN("LCASE"), & create_func_lcase::s_singleton}, + { C_STRING_WITH_LEN("LOWER"), & create_func_lcase::s_singleton}, + + { C_STRING_WITH_LEN("LEAST"), & create_func_least::s_singleton}, + { C_STRING_WITH_LEN("LENGTH"), & create_func_length::s_singleton}, + { C_STRING_WITH_LEN("OCTET_LENGTH"), & create_func_length::s_singleton}, + + { C_STRING_WITH_LEN("LN"), & create_func_ln::s_singleton}, + { C_STRING_WITH_LEN("LOAD_FILE"), & create_func_load_file::s_singleton}, + { C_STRING_WITH_LEN("LOCATE"), & create_func_locate::s_singleton}, + { C_STRING_WITH_LEN("LOG"), & create_func_log::s_singleton}, + { C_STRING_WITH_LEN("LOG10"), & create_func_log10::s_singleton}, + { C_STRING_WITH_LEN("LOG2"), & create_func_log2::s_singleton}, + { C_STRING_WITH_LEN("LPAD"), & create_func_lpad::s_singleton}, + { C_STRING_WITH_LEN("LTRIM"), & create_func_ltrim::s_singleton}, + { C_STRING_WITH_LEN("MAKEDATE"), & create_func_makedate::s_singleton}, + { C_STRING_WITH_LEN("MAKETIME"), & create_func_maketime::s_singleton}, + { C_STRING_WITH_LEN("MAKE_SET"), & create_func_make_set::s_singleton}, + { C_STRING_WITH_LEN("MD5"), & create_func_md5::s_singleton}, + { C_STRING_WITH_LEN("MASTER_POS_WAIT"), & create_func_master_pos_wait::s_singleton}, + { C_STRING_WITH_LEN("MONTHNAME"), & create_func_monthname::s_singleton}, + { C_STRING_WITH_LEN("NAME_CONST"), & create_func_name_const::s_singleton}, + { C_STRING_WITH_LEN("NULLIF"), & create_func_nullif::s_singleton}, + { C_STRING_WITH_LEN("NUMGEOMETRIES"), & create_func_numgeometries::s_singleton}, + { C_STRING_WITH_LEN("NUMINTERIORRINGS"), & create_func_numinteriorring::s_singleton}, + { C_STRING_WITH_LEN("NUMPOINTS"), & create_func_numpoints::s_singleton}, + { C_STRING_WITH_LEN("OCT"), & create_func_oct::s_singleton}, + { C_STRING_WITH_LEN("ORD"), & create_func_ord::s_singleton}, + { C_STRING_WITH_LEN("OVERLAPS"), & create_func_overlaps::s_singleton}, + { C_STRING_WITH_LEN("PERIOD_ADD"), & create_func_period_add::s_singleton}, + { C_STRING_WITH_LEN("PERIOD_DIFF"), & create_func_period_diff::s_singleton}, + { C_STRING_WITH_LEN("PI"), & create_func_pi::s_singleton}, + { C_STRING_WITH_LEN("POINTN"), & create_func_pointn::s_singleton}, + { C_STRING_WITH_LEN("POW"), & create_func_pow::s_singleton}, + { C_STRING_WITH_LEN("POWER"), & create_func_pow::s_singleton}, + { C_STRING_WITH_LEN("QUOTE"), & create_func_quote::s_singleton}, + { C_STRING_WITH_LEN("RADIANS"), & create_func_radians::s_singleton}, + { C_STRING_WITH_LEN("RAND"), & create_func_rand::s_singleton}, + { C_STRING_WITH_LEN("RELEASE_LOCK"), & create_func_release_lock::s_singleton}, + { C_STRING_WITH_LEN("REVERSE"), & create_func_reverse::s_singleton}, + { C_STRING_WITH_LEN("ROUND"), & create_func_round::s_singleton}, + { C_STRING_WITH_LEN("ROW_COUNT"), & create_func_row_count::s_singleton}, + { C_STRING_WITH_LEN("RPAD"), & create_func_rpad::s_singleton}, + { C_STRING_WITH_LEN("RTRIM"), & create_func_rtrim::s_singleton}, + { C_STRING_WITH_LEN("SEC_TO_TIME"), & create_func_sec_to_time::s_singleton}, + { C_STRING_WITH_LEN("SHA"), & create_func_sha::s_singleton}, + { C_STRING_WITH_LEN("SHA1"), & create_func_sha::s_singleton}, + { C_STRING_WITH_LEN("SIGN"), & create_func_sign::s_singleton}, + { C_STRING_WITH_LEN("SIN"), & create_func_sin::s_singleton}, + { C_STRING_WITH_LEN("SLEEP"), & create_func_sleep::s_singleton}, + { C_STRING_WITH_LEN("SPACE"), & create_func_space::s_singleton}, + { C_STRING_WITH_LEN("SOUNDEX"), & create_func_soundex::s_singleton}, + { C_STRING_WITH_LEN("SQRT"), & create_func_sqrt::s_singleton}, + { C_STRING_WITH_LEN("SRID"), & create_func_srid::s_singleton}, + + { C_STRING_WITH_LEN("STARTPOINT"), & create_func_startpoint::s_singleton}, + { C_STRING_WITH_LEN("STR_TO_DATE"), & create_func_str_to_date::s_singleton}, + { C_STRING_WITH_LEN("SUBSTRING_INDEX"), & create_func_substr_index::s_singleton}, + { C_STRING_WITH_LEN("STRCMP"), & create_func_strcmp::s_singleton}, + { C_STRING_WITH_LEN("SUBTIME"), & create_func_subtime::s_singleton}, + { C_STRING_WITH_LEN("TAN"), & create_func_tan::s_singleton}, + { C_STRING_WITH_LEN("TIME_FORMAT"), & create_func_time_format::s_singleton}, + { C_STRING_WITH_LEN("TIME_TO_SEC"), & create_func_time_to_sec::s_singleton}, + { C_STRING_WITH_LEN("TIMEDIFF"), & create_func_timediff::s_singleton}, + { C_STRING_WITH_LEN("TO_DAYS"), & create_func_to_days::s_singleton}, + { C_STRING_WITH_LEN("TOUCHES"), & create_func_touches::s_singleton}, + { C_STRING_WITH_LEN("UCASE"), & create_func_ucase::s_singleton}, + { C_STRING_WITH_LEN("UPPER"), & create_func_ucase::s_singleton}, + + { C_STRING_WITH_LEN("UNCOMPRESS"), & create_func_uncompress::s_singleton}, + { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH"), & create_func_uncompressed_length::s_singleton}, + { C_STRING_WITH_LEN("UNHEX"), & create_func_unhex::s_singleton}, + { C_STRING_WITH_LEN("UUID"), & create_func_uuid::s_singleton}, + { C_STRING_WITH_LEN("UNIX_TIMESTAMP"), & create_func_unix_timestamp::s_singleton}, + { C_STRING_WITH_LEN("VERSION"), & create_func_version::s_singleton}, + { C_STRING_WITH_LEN("WEEKDAY"), & create_func_weekday::s_singleton}, + { C_STRING_WITH_LEN("WEEKOFYEAR"), & create_func_weekofyear::s_singleton}, + { C_STRING_WITH_LEN("WITHIN"), & create_func_within::s_singleton}, + { C_STRING_WITH_LEN("X"), & create_func_x::s_singleton}, + { C_STRING_WITH_LEN("EXTRACTVALUE"), & create_func_xml_extractvalue::s_singleton}, + { C_STRING_WITH_LEN("UPDATEXML"), & create_func_xml_update::s_singleton}, + { C_STRING_WITH_LEN("Y"), & create_func_y::s_singleton}, + { C_STRING_WITH_LEN("YEARWEEK"), & create_func_year_week::s_singleton}, + + { {0, 0}, NULL} +}; + +/* + Hash size 509: + - is prime number, + - big enought to ensure a low load factor for approx 200 built-in functions. + There is only 1 instance of this hash table, and it's totally static. + */ +const int BUILTIN_FUNCTIONS_HASH_SIZE= 509; +static HASH g_builtin_functions_hash; + +extern "C" byte* +get_builtin_fct_hash_key(const byte *buff, uint *length, my_bool /* unused */) +{ + sql_func_registry *func= (sql_func_registry*) buff; + *length= func->name.length; + return (byte*) func->name.str; +} + +/* + Load the hash table for builtin functions. + Note: this code is not thread safe, and is intended to be used at server + startup only (before going multi-threaded) + */ +void item_create_init() +{ + sql_func_registry * cursor; + + DBUG_ENTER("item_create_init"); + + (void) hash_init( + & g_builtin_functions_hash, + system_charset_info, + BUILTIN_FUNCTIONS_HASH_SIZE, + 0, + 0, + (hash_get_key) get_builtin_fct_hash_key, + NULL, /* Nothing to free */ + MYF(0)); + + for (cursor= func_array; cursor->builder != NULL; cursor++) + { + (void) my_hash_insert(& g_builtin_functions_hash, (byte*) cursor); + } + +#ifndef DBUG_OFF + for (uint i=0 ; i < g_builtin_functions_hash.records ; i++) + { + cursor= (sql_func_registry*) hash_element(& g_builtin_functions_hash, i); + DBUG_PRINT("info", ("builtin function %s, length %d", + cursor->name.str, cursor->name.length)); + } +#endif + + DBUG_VOID_RETURN; } -Item *create_func_timediff(Item* a,Item* b) +/* + Empty the hash table for builtin 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() { - return new Item_func_timediff(a, b); + DBUG_ENTER("item_create_cleanup"); + hash_free(& g_builtin_functions_hash); + DBUG_VOID_RETURN; } -Item *create_func_maketime(Item* a,Item* b,Item* c) +create_func * find_sql_function_builder(THD *thd, LEX_STRING name) { - return new Item_func_maketime(a, b, c); + sql_func_registry *func; + create_func *builder= NULL; + + /* Thread safe */ + func= (sql_func_registry*) hash_search( + & g_builtin_functions_hash, + (byte*) name.str, + name.length); + + if (func) + { + builder= func->builder; + } + + return builder; } -Item *create_func_str_to_date(Item* a,Item* b) +create_qfunc * find_sp_function_builder(THD *thd) { - return new Item_func_str_to_date(a, b); + return & create_sp_func::s_singleton; } -Item *create_func_last_day(Item *a) +Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, + CHARSET_INFO *cs) { - return new Item_func_last_day(a); + Item *res; + int tmp_len; + LINT_INIT(res); + + switch (cast_type) { + case ITEM_CAST_BINARY: res= new Item_func_binary(a); break; + case ITEM_CAST_SIGNED_INT: res= new Item_func_signed(a); break; + case ITEM_CAST_UNSIGNED_INT: res= new Item_func_unsigned(a); break; + case ITEM_CAST_DATE: res= new Item_date_typecast(a); break; + case ITEM_CAST_TIME: res= new Item_time_typecast(a); break; + case ITEM_CAST_DATETIME: res= new Item_datetime_typecast(a); break; + case ITEM_CAST_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; + } + return res; } + --- 1.45/sql/item_create.h 2006-09-27 17:01:46 -07:00 +++ 1.46/sql/item_create.h 2006-09-27 17:01:46 -07:00 @@ -14,148 +14,2133 @@ 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 */ + +// PUBLIC Function builder interface + +class create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, + List<Item> *item_list, Item *& func) = 0; + +protected: + create_func() {} + virtual ~create_func() {} +}; + +class create_qfunc : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, + List<Item> *item_list, Item *& func); + + virtual int create( + THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list, Item *& func) = 0; + +protected: + create_qfunc() {} + virtual ~create_qfunc() {} +}; + +extern create_func * find_sql_function_builder(THD *thd, LEX_STRING name); +extern create_qfunc * find_sp_function_builder(THD *thd); + +// PUBLIC Function builder interface, for UDF (User Defined Functions) +// This interface is more specialized, +// and is used if a udf_func is already available. + +#ifdef HAVE_DLOPEN +class create_udf_func : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, + List<Item> *item_list, Item *& func); + + int create( + THD *thd, udf_func *fct, + List<Item> *item_list, Item *& func); + + static create_udf_func s_singleton; + +protected: + create_udf_func() {} + virtual ~create_udf_func() {} +}; +#endif + +// Abstract functions builders + +class create_func_arg0 : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + virtual int create( + THD *thd, Item *& func) = 0; + +protected: + create_func_arg0() {} + virtual ~create_func_arg0() {} +}; + +class create_func_arg1 : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + virtual int create( + THD *thd, Item *arg1, Item *& func) = 0; + +protected: + create_func_arg1() {} + virtual ~create_func_arg1() {} +}; + +class create_func_arg2 : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func) = 0; + +protected: + create_func_arg2() {} + virtual ~create_func_arg2() {} +}; + +class create_func_arg3 : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func) = 0; + +protected: + create_func_arg3() {} + virtual ~create_func_arg3() {} +}; + +// Concrete functions builders (Stored Functions) + +class create_sp_func : public create_qfunc +{ +public: + virtual int create( + THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list, Item *& func); + + static create_sp_func s_singleton; + +protected: + create_sp_func() {} + virtual ~create_sp_func() {} +}; + +// Concrete functions builders (native MySQL functions) + +class create_func_abs : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_abs s_singleton; + +protected: + create_func_abs() {} + virtual ~create_func_abs() {} +}; + +class create_func_acos : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_acos s_singleton; + +protected: + create_func_acos() {} + virtual ~create_func_acos() {} +}; + +class create_func_addtime : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_aes_decrypt s_singleton; + +protected: + create_func_aes_decrypt() {} + virtual ~create_func_aes_decrypt() {} +}; + +class create_func_area : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_area s_singleton; + +protected: + create_func_area() {} + virtual ~create_func_area() {} +}; + +class create_func_as_wkb : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_as_wkb s_singleton; + +protected: + create_func_as_wkb() {} + virtual ~create_func_as_wkb() {} +}; + +class create_func_as_wkt : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_as_wkt s_singleton; + +protected: + create_func_as_wkt() {} + virtual ~create_func_as_wkt() {} +}; + +class create_func_asin : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_asin s_singleton; + +protected: + create_func_asin() {} + virtual ~create_func_asin() {} +}; + +class create_func_atan : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_atan s_singleton; + +protected: + create_func_atan() {} + virtual ~create_func_atan() {} +}; + +class create_func_benchmark : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_benchmark s_singleton; + +protected: + create_func_benchmark() {} + virtual ~create_func_benchmark() {} +}; + +class create_func_bin : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_ceiling s_singleton; + +protected: + create_func_ceiling() {} + virtual ~create_func_ceiling() {} +}; + +class create_func_centroid : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_centroid s_singleton; + +protected: + create_func_centroid() {} + virtual ~create_func_centroid() {} +}; + +class create_func_char_length : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_coercibility s_singleton; + +protected: + create_func_coercibility() {} + virtual ~create_func_coercibility() {} +}; + +class create_func_compress : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_compress s_singleton; + +protected: + create_func_compress() {} + virtual ~create_func_compress() {} +}; + +class create_func_concat : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_concat s_singleton; + +protected: + create_func_concat() {} + virtual ~create_func_concat() {} +}; + +class create_func_concat_ws : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *& func); + + static create_func_connection_id s_singleton; + +protected: + create_func_connection_id() {} + virtual ~create_func_connection_id() {} +}; + +class create_func_contains : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_contains s_singleton; + +protected: + create_func_contains() {} + virtual ~create_func_contains() {} +}; + +class create_func_conv : public create_func_arg3 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_cos s_singleton; + +protected: + create_func_cos() {} + virtual ~create_func_cos() {} +}; + +class create_func_cot : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_cot s_singleton; + +protected: + create_func_cot() {} + virtual ~create_func_cot() {} +}; + +class create_func_crc32 : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_crc32 s_singleton; + +protected: + create_func_crc32() {} + virtual ~create_func_crc32() {} +}; + +class create_func_crosses : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_crosses s_singleton; + +protected: + create_func_crosses() {} + virtual ~create_func_crosses() {} +}; + +class create_func_date_format : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_datediff s_singleton; + +protected: + create_func_datediff() {} + virtual ~create_func_datediff() {} +}; + +class create_func_dayname : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_dayname s_singleton; + +protected: + create_func_dayname() {} + virtual ~create_func_dayname() {} +}; + +class create_func_dayofmonth : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_dayofmonth s_singleton; + +protected: + create_func_dayofmonth() {} + virtual ~create_func_dayofmonth() {} +}; + +class create_func_dayofweek : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_dayofweek s_singleton; + +protected: + create_func_dayofweek() {} + virtual ~create_func_dayofweek() {} +}; + +class create_func_dayofyear : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_dayofyear s_singleton; + +protected: + create_func_dayofyear() {} + virtual ~create_func_dayofyear() {} +}; + +class create_func_decode : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_decode s_singleton; + +protected: + create_func_decode() {} + virtual ~create_func_decode() {} +}; + +class create_func_degrees : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_degrees s_singleton; + +protected: + create_func_degrees() {} + virtual ~create_func_degrees() {} +}; + +class create_func_des_decrypt : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_des_encrypt s_singleton; + +protected: + create_func_des_encrypt() {} + virtual ~create_func_des_encrypt() {} +}; + +class create_func_dimension : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_dimension s_singleton; + +protected: + create_func_dimension() {} + virtual ~create_func_dimension() {} +}; + +class create_func_disjoint : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_disjoint s_singleton; + +protected: + create_func_disjoint() {} + virtual ~create_func_disjoint() {} +}; + +class create_func_elt : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_elt s_singleton; + +protected: + create_func_elt() {} + virtual ~create_func_elt() {} +}; + +class create_func_encode : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_encode s_singleton; + +protected: + create_func_encode() {} + virtual ~create_func_encode() {} +}; + +class create_func_encrypt : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_encrypt s_singleton; + +protected: + create_func_encrypt() {} + virtual ~create_func_encrypt() {} +}; + +class create_func_endpoint : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_endpoint s_singleton; + +protected: + create_func_endpoint() {} + virtual ~create_func_endpoint() {} +}; + +class create_func_envelope : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_envelope s_singleton; + +protected: + create_func_envelope() {} + virtual ~create_func_envelope() {} +}; + +class create_func_equals : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_equals s_singleton; + +protected: + create_func_equals() {} + virtual ~create_func_equals() {} +}; + +class create_func_exp : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_exp s_singleton; + +protected: + create_func_exp() {} + virtual ~create_func_exp() {} +}; + +class create_func_export_set : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_export_set s_singleton; + +protected: + create_func_export_set() {} + virtual ~create_func_export_set() {} +}; + +class create_func_exteriorring : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_exteriorring s_singleton; + +protected: + create_func_exteriorring() {} + virtual ~create_func_exteriorring() {} +}; + +class create_func_field : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_floor s_singleton; + +protected: + create_func_floor() {} + virtual ~create_func_floor() {} +}; + +class create_func_format : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_from_unixtime s_singleton; + +protected: + create_func_from_unixtime() {} + virtual ~create_func_from_unixtime() {} +}; + +class create_func_geometry_from_text : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_geometry_from_text s_singleton; + +protected: + create_func_geometry_from_text() {} + virtual ~create_func_geometry_from_text() {} +}; + +class create_func_geometry_from_wkb : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_geometry_from_wkb s_singleton; + +protected: + create_func_geometry_from_wkb() {} + virtual ~create_func_geometry_from_wkb() {} +}; + +class create_func_geometry_type : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_geometry_type s_singleton; + +protected: + create_func_geometry_type() {} + virtual ~create_func_geometry_type() {} +}; + +class create_func_geometryn : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_geometryn s_singleton; + +protected: + create_func_geometryn() {} + virtual ~create_func_geometryn() {} +}; + +class create_func_get_lock : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_get_lock s_singleton; + +protected: + create_func_get_lock() {} + virtual ~create_func_get_lock() {} +}; + +class create_func_glength : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_glength s_singleton; + +protected: + create_func_glength() {} + virtual ~create_func_glength() {} +}; + +class create_func_greatest : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_greatest s_singleton; + +protected: + create_func_greatest() {} + virtual ~create_func_greatest() {} +}; + +class create_func_hex : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_hex s_singleton; + +protected: + create_func_hex() {} + virtual ~create_func_hex() {} +}; + +class create_func_ifnull : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_instr s_singleton; + +protected: + create_func_instr() {} + virtual ~create_func_instr() {} +}; + +class create_func_interiorringn : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_interiorringn s_singleton; + +protected: + create_func_interiorringn() {} + virtual ~create_func_interiorringn() {} +}; + +class create_func_intersects : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_intersects s_singleton; + +protected: + create_func_intersects() {} + virtual ~create_func_intersects() {} +}; + +class create_func_is_free_lock : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_is_used_lock s_singleton; + +protected: + create_func_is_used_lock() {} + virtual ~create_func_is_used_lock() {} +}; + +class create_func_isclosed : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_isclosed s_singleton; + +protected: + create_func_isclosed() {} + virtual ~create_func_isclosed() {} +}; + +class create_func_isempty : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_isempty s_singleton; + +protected: + create_func_isempty() {} + virtual ~create_func_isempty() {} +}; + +class create_func_isnull : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_isnull s_singleton; + +protected: + create_func_isnull() {} + virtual ~create_func_isnull() {} +}; + +class create_func_issimple : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_issimple s_singleton; + +protected: + create_func_issimple() {} + virtual ~create_func_issimple() {} +}; + +class create_func_last_day : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_lcase s_singleton; + +protected: + create_func_lcase() {} + virtual ~create_func_lcase() {} +}; + +class create_func_least : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_least s_singleton; + +protected: + create_func_least() {} + virtual ~create_func_least() {} +}; + +class create_func_length : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_length s_singleton; + +protected: + create_func_length() {} + virtual ~create_func_length() {} +}; + +class create_func_ln : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_locate s_singleton; + +protected: + create_func_locate() {} + virtual ~create_func_locate() {} +}; + +class create_func_log : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_log s_singleton; + +protected: + create_func_log() {} + virtual ~create_func_log() {} +}; + +class create_func_log10 : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_log10 s_singleton; + +protected: + create_func_log10() {} + virtual ~create_func_log10() {} +}; + +class create_func_log2 : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_log2 s_singleton; + +protected: + create_func_log2() {} + virtual ~create_func_log2() {} +}; + +class create_func_lpad : public create_func_arg3 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + static create_func_lpad s_singleton; + +protected: + create_func_lpad() {} + virtual ~create_func_lpad() {} +}; + +class create_func_ltrim : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_ltrim s_singleton; + +protected: + create_func_ltrim() {} + virtual ~create_func_ltrim() {} +}; + +class create_func_makedate : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_makedate s_singleton; + +protected: + create_func_makedate() {} + virtual ~create_func_makedate() {} +}; + +class create_func_maketime : public create_func_arg3 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + static create_func_maketime s_singleton; + +protected: + create_func_maketime() {} + virtual ~create_func_maketime() {} +}; + +class create_func_make_set : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_md5 s_singleton; + +protected: + create_func_md5() {} + virtual ~create_func_md5() {} +}; + +class create_func_monthname : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_nullif s_singleton; + +protected: + create_func_nullif() {} + virtual ~create_func_nullif() {} +}; + +class create_func_numgeometries : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_numgeometries s_singleton; + +protected: + create_func_numgeometries() {} + virtual ~create_func_numgeometries() {} +}; + +class create_func_numinteriorring : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_numinteriorring s_singleton; + +protected: + create_func_numinteriorring() {} + virtual ~create_func_numinteriorring() {} +}; + +class create_func_numpoints : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_numpoints s_singleton; + +protected: + create_func_numpoints() {} + virtual ~create_func_numpoints() {} +}; + +class create_func_oct : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_oct s_singleton; + +protected: + create_func_oct() {} + virtual ~create_func_oct() {} +}; + +class create_func_ord : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_ord s_singleton; + +protected: + create_func_ord() {} + virtual ~create_func_ord() {} +}; + +class create_func_overlaps : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_overlaps s_singleton; + +protected: + create_func_overlaps() {} + virtual ~create_func_overlaps() {} +}; + +class create_func_period_add : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *& func); + + static create_func_pi s_singleton; + +protected: + create_func_pi() {} + virtual ~create_func_pi() {} +}; + +class create_func_pointn : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_pointn s_singleton; + +protected: + create_func_pointn() {} + virtual ~create_func_pointn() {} +}; + +class create_func_pow : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_pow s_singleton; + +protected: + create_func_pow() {} + virtual ~create_func_pow() {} +}; + +class create_func_quote : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_quote s_singleton; + +protected: + create_func_quote() {} + virtual ~create_func_quote() {} +}; + +class create_func_radians : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_radians s_singleton; + +protected: + create_func_radians() {} + virtual ~create_func_radians() {} +}; + +class create_func_rand : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_reverse s_singleton; + +protected: + create_func_reverse() {} + virtual ~create_func_reverse() {} +}; + +class create_func_round : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + static create_func_rpad s_singleton; + +protected: + create_func_rpad() {} + virtual ~create_func_rpad() {} +}; + +class create_func_rtrim : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_sha s_singleton; + +protected: + create_func_sha() {} + virtual ~create_func_sha() {} +}; + +class create_func_sign : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_sign s_singleton; + +protected: + create_func_sign() {} + virtual ~create_func_sign() {} +}; + +class create_func_sin : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_sin s_singleton; + +protected: + create_func_sin() {} + virtual ~create_func_sin() {} +}; + +class create_func_sleep : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_sleep s_singleton; + +protected: + create_func_sleep() {} + virtual ~create_func_sleep() {} +}; + +class create_func_soundex : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_soundex s_singleton; + +protected: + create_func_soundex() {} + virtual ~create_func_soundex() {} +}; + +class create_func_space : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_space s_singleton; + +protected: + create_func_space() {} + virtual ~create_func_space() {} +}; + +class create_func_sqrt : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_sqrt s_singleton; + +protected: + create_func_sqrt() {} + virtual ~create_func_sqrt() {} +}; + +class create_func_srid : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_srid s_singleton; + +protected: + create_func_srid() {} + virtual ~create_func_srid() {} +}; + +class create_func_startpoint : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_startpoint s_singleton; + +protected: + create_func_startpoint() {} + virtual ~create_func_startpoint() {} +}; + +class create_func_str_to_date : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_subtime s_singleton; + +protected: + create_func_subtime() {} + virtual ~create_func_subtime() {} +}; + +class create_func_tan : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_to_days s_singleton; + +protected: + create_func_to_days() {} + virtual ~create_func_to_days() {} +}; + +class create_func_touches : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_touches s_singleton; + +protected: + create_func_touches() {} + virtual ~create_func_touches() {} +}; + +class create_func_ucase : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_ucase s_singleton; + +protected: + create_func_ucase() {} + virtual ~create_func_ucase() {} +}; + +class create_func_uncompress : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_unhex s_singleton; + +protected: + create_func_unhex() {} + virtual ~create_func_unhex() {} +}; + +class create_func_unix_timestamp : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + 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 int create( + THD *thd, Item *& func); + + static create_func_uuid s_singleton; + +protected: + create_func_uuid() {} + virtual ~create_func_uuid() {} +}; + +class create_func_version : public create_func_arg0 +{ +public: + virtual int create( + THD *thd, Item *& func); + + static create_func_version s_singleton; + +protected: + create_func_version() {} + virtual ~create_func_version() {} +}; + +class create_func_weekday : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_weekday s_singleton; + +protected: + create_func_weekday() {} + virtual ~create_func_weekday() {} +}; + +class create_func_weekofyear : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_weekofyear s_singleton; + +protected: + create_func_weekofyear() {} + virtual ~create_func_weekofyear() {} +}; + +class create_func_within : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + static create_func_within s_singleton; + +protected: + create_func_within() {} + virtual ~create_func_within() {} +}; + +class create_func_x : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_x s_singleton; + +protected: + create_func_x() {} + virtual ~create_func_x() {} +}; + +class create_func_xml_extractvalue : public create_func_arg2 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *arg2, Item *& func); + + 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 int create( + THD *thd, Item *arg1, Item *arg2, Item *arg3, Item *& func); + + static create_func_xml_update s_singleton; + +protected: + create_func_xml_update() {} + virtual ~create_func_xml_update() {} +}; + +class create_func_y : public create_func_arg1 +{ +public: + virtual int create( + THD *thd, Item *arg1, Item *& func); + + static create_func_y s_singleton; + +protected: + create_func_y() {} + virtual ~create_func_y() {} +}; + +class create_func_year_week : public create_func +{ +public: + virtual int create( + THD *thd, LEX_STRING name, List<Item> *item_list, Item *& func); + + static create_func_year_week s_singleton; + +protected: + create_func_year_week() {} + virtual ~create_func_year_week() {} +}; + +// create_func_cast does not fit the pattern, +// the syntax is not a pure function call + +Item *create_func_cast( + Item *a, Cast_target cast_type, int len, int dec, CHARSET_INFO *cs); -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.163/sql/lex.h 2006-09-27 17:01:46 -07:00 +++ 1.164/sql/lex.h 2006-09-27 17:01:46 -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 @@ -589,235 +580,35 @@ 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)}, + { "MID", SYM(SUBSTRING)}, /* unireg function */ { "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)}, { "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)}, { "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-09-27 17:01:46 -07:00 +++ 1.8/sql/lex_symbol.h 2006-09-27 17:01:46 -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.433/sql/mysql_priv.h 2006-09-27 17:01:46 -07:00 +++ 1.434/sql/mysql_priv.h 2006-09-27 17:01:46 -07:00 @@ -2034,5 +2034,9 @@ 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 */ +void item_create_init(); +void item_create_cleanup(); + #endif /* MYSQL_SERVER */ #endif /* MYSQL_CLIENT */ --- 1.581/sql/mysqld.cc 2006-09-27 17:01:46 -07:00 +++ 1.582/sql/mysqld.cc 2006-09-27 17:01:46 -07:00 @@ -1177,6 +1177,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 */ @@ -2686,6 +2687,7 @@ static int init_common_variables(const c return 1; init_client_errs(); lex_init(); + item_create_init(); item_init(); set_var_init(); mysys_uses_curses=0; --- 1.496/sql/sql_yacc.yy 2006-09-27 17:01:46 -07:00 +++ 1.497/sql/sql_yacc.yy 2006-09-27 17:01:47 -07:00 @@ -58,10 +58,14 @@ 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) { - 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 Item_int((char *) (v1 ? "TRUE" : "FALSE"), v1, 1); + Item * v1_f= new Item_int((char *) (v1 ? "FALSE" : "TRUE"),!v1, 1); + Item * v2_t= new Item_int((char *) (v2 ? "TRUE" : "FALSE"), v2, 1); + + return new Item_func_if( + new Item_func_ifnull(A, v2_t), + v1_t, + v1_f); } #ifndef DBUG_OFF @@ -142,213 +146,206 @@ 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 + FUTUR-USE : Reserved for futur use + + This makes the code grep-able, and helps maintenance. +*/ +%token END_OF_INPUT /* INTERNAL */ -%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 /* FUTUR-USE */ +%token AT_SYM /* SQL-2003-R */ %token AUTHORS_SYM %token AUTO_INC %token AUTOEXTEND_SIZE_SYM %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 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 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 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 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 ESCAPE_SYM /* SQL-2003-R */ %token EVENT_SYM %token EVENTS_SYM -%token EVERY_SYM -%token EXECUTE_SYM -%token EXISTS +%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 +353,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 +364,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_SYM /* SQL-2003-N */ %token KEY_BLOCK_SIZE %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,83 +430,79 @@ 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 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 PARSER_SYM -%token PARTIAL -%token PARTITION_SYM +%token PARTIAL /* SQL-2003-N */ +%token PARTITION_SYM /* SQL-2003-R */ %token PARTITIONING_SYM %token PARTITIONS_SYM %token PASSWORD @@ -524,50 +510,47 @@ bool my_yyoverflow(short **a, YYSTYPE ** %token PHASE_SYM %token PLUGIN_SYM %token PLUGINS_SYM -%token POINTFROMTEXT %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 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,65 +558,64 @@ 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 */ +/* ROW_COUNT_SYM : treated as a function. SQL-2003-N */ %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 SCHEDULER_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 /* FUTUR-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 START_SYM /* SQL-2003-R */ %token STARTS_SYM %token STATUS_SYM %token STD_SYM -%token STDDEV_SAMP_SYM +%token STDDEV_SAMP_SYM /* SQL-2003-N */ %token STOP_SYM %token STORAGE_SYM %token STRAIGHT_JOIN @@ -642,92 +624,95 @@ bool my_yyoverflow(short **a, YYSTYPE ** %token SUBJECT_SYM %token SUBPARTITION_SYM %token SUBPARTITIONS_SYM -%token SUBSTRING -%token SUBSTRING_INDEX -%token SUM_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_SYM /* SQL-2003-R */ +%token TEMPORARY /* SQL-2003-N */ %token TEMPTABLE_SYM %token TERMINATED %token TEXT_STRING %token TEXT_SYM -%token TIMESTAMP +%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 TRIGGER_SYM /* SQL-2003-R */ %token TRIGGERS_SYM -%token TRIM -%token TRUE_SYM +%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 UNDO_SYM /* FUTUR-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 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 +%token TABLE_REF_PRIORITY +%token BETWEEN_SYM /* SQL-2003-R */ +%token CASE_SYM /* SQL-2003-R */ +%token THEN_SYM /* SQL-2003-R */ +%token ELSE /* SQL-2003-R */ +%token NEG %left JOIN_SYM INNER_SYM STRAIGHT_JOIN CROSS LEFT RIGHT /* A dummy token to force the priority of table_ref production in a join. */ @@ -771,7 +756,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** type int_type real_type order_dir lock_option udf_type if_exists opt_local opt_table_options table_options table_option opt_if_not_exists opt_no_write_to_binlog - delete_option opt_temporary all_or_any opt_distinct + delete_option opt_temporary opt_distinct opt_ignore_leaves fulltext_options spatial_type union_option start_transaction_opts opt_chain opt_release union_opt select_derived_init option_type2 @@ -794,7 +779,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** %type <item> literal text_literal insert_ident order_ident simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr - bool_term bool_factor bool_test bool_pri + bool_term bool_factor bool_test bool_pri predicate bit_expr bit_term bit_factor value_expr term factor table_wild simple_expr udf_expr expr_or_default set_expr_or_default interval_expr @@ -805,6 +790,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 @@ -812,6 +801,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 @@ -850,7 +840,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 @@ -5921,8 +5911,10 @@ bool_pri: | bool_pri EQUAL_SYM predicate { $$= new Item_func_equal($1,$3); } | bool_pri comp_op predicate %prec EQ { $$= (*$2)(0)->create($1,$3); } - | bool_pri comp_op all_or_any in_subselect %prec EQ - { $$= all_any_subquery_creator($1, $2, $3, $4); } + | bool_pri comp_op ALL in_subselect %prec EQ + { $$= all_any_subquery_creator($1, $2, 1, $4); } + | bool_pri comp_op ANY_SYM in_subselect %prec EQ + { $$= all_any_subquery_creator($1, $2, 0, $4); } | predicate ; predicate: @@ -6021,16 +6013,16 @@ comp_op: EQ { $$ = &comp_eq_creator; } | NE { $$ = &comp_ne_creator; } ; -all_or_any: ALL { $$ = 1; } - | ANY_SYM { $$ = 0; } - ; - interval_expr: INTERVAL_SYM expr { $$=$2; } ; 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, @@ -6091,7 +6083,6 @@ simple_expr: { $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); } | BINARY simple_expr %prec NEG { $$= create_func_cast($2, ITEM_CAST_CHAR, -1, 0, &my_charset_bin); @@ -6132,255 +6123,132 @@ simple_expr: } | 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 '(' expr ',' expr ',' expr ')' + { $$= new Item_func_if($3,$5,$7); } + | interval_expr interval '+' expr + /* we cannot put interval before - */ + { $$= new Item_date_add_interval($4,$1,$2,0); } + | interval_expr { - if (!$1.symbol->create_func) - { - my_error(ER_FEATURE_DISABLED, MYF(0), - $1.symbol->group->name, - $1.symbol->group->needed_define); - YYABORT; - } - $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5); - } - | FUNC_ARG3 '(' expr ',' expr ',' expr ')' + if ($1->type() != Item::ROW_ITEM) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + $$= new Item_func_interval((Item_row *)$1); + } + | UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')' { - 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); + $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9); } - | 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 ')' + ; + +/* + 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 Item_func_char(*$3); } | CHAR_SYM '(' expr_list USING charset_name ')' { $$= new Item_func_char(*$3, $5); } - | CHARSET '(' expr ')' - { $$= new Item_func_charset($3); } - | COALESCE '(' expr_list ')' - { $$= new Item_func_coalesce(* $3); } - | COLLATION_SYM '(' expr ')' - { $$= new Item_func_collation($3); } - | CONCAT '(' expr_list ')' - { $$= new Item_func_concat(* $3); } - | CONCAT_WS '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_concat_ws(*$5); } - | CONVERT_TZ_SYM '(' expr ',' expr ',' expr ')' - { - if (Lex->add_time_zone_tables_to_query_tables(YYTHD)) - YYABORT; - $$= new Item_func_convert_tz($3, $5, $7); - } - | CURDATE optional_braces - { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; } - | CURTIME optional_braces - { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; } - | CURTIME '(' expr ')' - { - $$= new Item_func_curtime_local($3); - Lex->safe_to_cache_query=0; - } | CURRENT_USER optional_braces { $$= new Item_func_current_user(Lex->current_context()); Lex->safe_to_cache_query= 0; } - | DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')' - { $$= new Item_date_add_interval($3,$5,$6,0); } - | DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')' - { $$= new Item_date_add_interval($3,$5,$6,1); } - | DATABASE '(' ')' - { - $$= new Item_func_database(); - Lex->safe_to_cache_query=0; - } | DATE_SYM '(' expr ')' { $$= new Item_date_typecast($3); } | DAY_SYM '(' expr ')' { $$= new Item_func_dayofmonth($3); } - | ELT_FUNC '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_elt(*$5); } - | MAKE_SET_SYM '(' expr ',' expr_list ')' - { $$= new Item_func_make_set($3, *$5); } - | ENCRYPT '(' expr ')' - { - $$= new Item_func_encrypt($3); - Lex->uncacheable(UNCACHEABLE_RAND); - } - | ENCRYPT '(' expr ',' expr ')' { $$= new Item_func_encrypt($3,$5); } - | DECODE_SYM '(' expr ',' TEXT_STRING_literal ')' - { $$= new Item_func_decode($3,$5.str); } - | ENCODE_SYM '(' expr ',' TEXT_STRING_literal ')' - { $$= new Item_func_encode($3,$5.str); } - | DES_DECRYPT_SYM '(' expr ')' - { $$= new Item_func_des_decrypt($3); } - | DES_DECRYPT_SYM '(' expr ',' expr ')' - { $$= new Item_func_des_decrypt($3,$5); } - | DES_ENCRYPT_SYM '(' expr ')' - { $$= new Item_func_des_encrypt($3); } - | DES_ENCRYPT_SYM '(' expr ',' expr ')' - { $$= new Item_func_des_encrypt($3,$5); } - | EXPORT_SET '(' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7); } - | EXPORT_SET '(' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7, $9); } - | EXPORT_SET '(' expr ',' expr ',' expr ',' expr ',' expr ')' - { $$= new Item_func_export_set($3, $5, $7, $9, $11); } - | FORMAT_SYM '(' expr ',' NUM ')' - { $$= new Item_func_format($3,atoi($5.str)); } - | FROM_UNIXTIME '(' expr ')' - { $$= new Item_func_from_unixtime($3); } - | FROM_UNIXTIME '(' expr ',' expr ')' - { - $$= new Item_func_date_format (new Item_func_from_unixtime($3),$5,0); - } - | FIELD_FUNC '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_field(*$5); } - | geometry_function - { -#ifdef HAVE_SPATIAL - $$= $1; -#else - my_error(ER_FEATURE_DISABLED, MYF(0), - sym_group_geom.name, sym_group_geom.needed_define); - YYABORT; -#endif - } - | GET_FORMAT '(' date_time_type ',' expr ')' - { $$= new Item_func_get_format($3, $5); } | HOUR_SYM '(' expr ')' { $$= new Item_func_hour($3); } - | IF '(' expr ',' expr ',' expr ')' - { $$= new Item_func_if($3,$5,$7); } | INSERT '(' expr ',' expr ',' expr ',' expr ')' { $$= new Item_func_insert($3,$5,$7,$9); } - | interval_expr interval '+' expr - /* we cannot put interval before - */ - { $$= new Item_date_add_interval($4,$1,$2,0); } - | interval_expr - { - if ($1->type() != Item::ROW_ITEM) - { - yyerror(ER(ER_SYNTAX_ERROR)); - YYABORT; - } - $$= new Item_func_interval((Item_row *)$1); - } - | LAST_INSERT_ID '(' ')' - { - $$= new Item_func_last_insert_id(); - Lex->safe_to_cache_query= 0; - } - | LAST_INSERT_ID '(' expr ')' - { - $$= new Item_func_last_insert_id($3); - Lex->safe_to_cache_query= 0; - } | LEFT '(' expr ',' expr ')' { $$= new Item_func_left($3,$5); } - | LOCATE '(' expr ',' expr ')' - { $$= new Item_func_locate($5,$3); } - | LOCATE '(' expr ',' expr ',' expr ')' - { $$= new Item_func_locate($5,$3,$7); } - | GREATEST_SYM '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_max(*$5); } - | LEAST_SYM '(' expr ',' expr_list ')' - { $5->push_front($3); $$= new Item_func_min(*$5); } - | LOG_SYM '(' expr ')' - { $$= new Item_func_log($3); } - | LOG_SYM '(' expr ',' expr ')' - { $$= new Item_func_log($3, $5); } - | MASTER_POS_WAIT '(' expr ',' expr ')' - { - $$= new Item_master_pos_wait($3, $5); - Lex->safe_to_cache_query=0; - } - | MASTER_POS_WAIT '(' expr ',' expr ',' expr ')' - { - $$= new Item_master_pos_wait($3, $5, $7); - Lex->safe_to_cache_query=0; - } - | MICROSECOND_SYM '(' expr ')' - { $$= new Item_func_microsecond($3); } | MINUTE_SYM '(' expr ')' { $$= new Item_func_minute($3); } - | MOD_SYM '(' expr ',' expr ')' - { $$ = new Item_func_mod( $3, $5); } | MONTH_SYM '(' expr ')' { $$= new Item_func_month($3); } + | RIGHT '(' expr ',' expr ')' + { $$= new Item_func_right($3,$5); } + | SECOND_SYM '(' expr ')' + { $$= new Item_func_second($3); } + | 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); } + | 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); } + | USER '(' ')' + { $$= new Item_func_user(); Lex->safe_to_cache_query=0; } + | YEAR_SYM '(' expr ')' + { $$= new 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_date_add_interval($3, $5, INTERVAL_DAY, 0);} + | ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')' + { $$= new Item_date_add_interval($3, $6, $7, 0); } + | CURDATE optional_braces + { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; } + | CURTIME optional_braces + { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; } + | CURTIME '(' expr ')' + { + $$= new Item_func_curtime_local($3); + Lex->safe_to_cache_query=0; + } + | 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); } + | EXTRACT_SYM '(' interval FROM expr ')' + { $$=new Item_extract( $3, $5); } + | GET_FORMAT '(' date_time_type ',' expr ')' + { $$= new Item_func_get_format($3, $5); } | NOW_SYM optional_braces { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;} | NOW_SYM '(' expr ')' { $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0;} - | PASSWORD '(' expr ')' - { - $$= YYTHD->variables.old_passwords ? - (Item *) new Item_func_old_password($3) : - (Item *) new Item_func_password($3); - } - | OLD_PASSWORD '(' expr ')' - { $$= new Item_func_old_password($3); } | POSITION_SYM '(' bit_expr IN_SYM expr ')' { $$ = new Item_func_locate($5,$3); } - | QUARTER_SYM '(' expr ')' - { $$ = new Item_func_quarter($3); } - | RAND '(' expr ')' - { $$= new Item_func_rand($3); Lex->uncacheable(UNCACHEABLE_RAND);} - | RAND '(' ')' - { $$= new Item_func_rand(); Lex->uncacheable(UNCACHEABLE_RAND);} - | REPLACE '(' expr ',' expr ',' expr ')' - { $$= new Item_func_replace($3,$5,$7); } - | RIGHT '(' expr ',' expr ')' - { $$= new Item_func_right($3,$5); } - | ROUND '(' expr ')' - { $$= new Item_func_round($3, new Item_int((char*)"0",0,1),0); } - | ROUND '(' expr ',' expr ')' { $$= new Item_func_round($3,$5,0); } - | ROW_COUNT_SYM '(' ')' - { - $$= new Item_func_row_count(); - Lex->safe_to_cache_query= 0; - } | SUBDATE_SYM '(' expr ',' expr ')' { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);} | SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')' { $$= new Item_date_add_interval($3, $6, $7, 1); } - | SECOND_SYM '(' expr ')' - { $$= new Item_func_second($3); } | SUBSTRING '(' expr ',' expr ',' expr ')' { $$= new Item_func_substr($3,$5,$7); } | SUBSTRING '(' expr ',' expr ')' @@ -6389,8 +6257,6 @@ simple_expr: { $$= new Item_func_substr($3,$5,$7); } | SUBSTRING '(' expr FROM expr ')' { $$= new Item_func_substr($3,$5); } - | SUBSTRING_INDEX '(' expr ',' expr ',' expr ')' - { $$= new Item_func_substr_index($3,$5,$7); } | SYSDATE optional_braces { if (global_system_variables.sysdate_is_now == 0) @@ -6405,186 +6271,57 @@ simple_expr: else $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0; } - | TIME_SYM '(' expr ')' - { $$= new Item_time_typecast($3); } - | TIMESTAMP '(' expr ')' - { $$= new Item_datetime_typecast($3); } - | TIMESTAMP '(' expr ',' expr ')' - { $$= new Item_func_add_time($3, $5, 1, 0); } | TIMESTAMP_ADD '(' interval_time_st ',' expr ',' expr ')' { $$= new Item_date_add_interval($7,$5,$3,0); } | TIMESTAMP_DIFF '(' interval_time_st ',' expr ',' expr ')' { $$= new Item_func_timestamp_diff($5,$7,$3); } - | TRIM '(' expr ')' - { $$= new Item_func_trim($3); } - | TRIM '(' LEADING expr FROM expr ')' - { $$= new Item_func_ltrim($6,$4); } - | TRIM '(' TRAILING expr FROM expr ')' - { $$= new Item_func_rtrim($6,$4); } - | TRIM '(' BOTH expr FROM expr ')' - { $$= new Item_func_trim($6,$4); } - | TRIM '(' LEADING FROM expr ')' - { $$= new Item_func_ltrim($5); } - | TRIM '(' TRAILING FROM expr ')' - { $$= new Item_func_rtrim($5); } - | TRIM '(' BOTH FROM expr ')' - { $$= new Item_func_trim($5); } - | TRIM '(' expr FROM expr ')' - { $$= new Item_func_trim($5,$3); } - | TRUNCATE_SYM '(' expr ',' expr ')' - { $$= new Item_func_round($3,$5,1); } - | ident '.' ident '(' udf_expr_list ')' - { - LEX *lex= Lex; - sp_name *name= new sp_name($1, $3); - - name->init_qname(YYTHD); - sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION); - if ($5) - $$= new Item_func_sp(Lex->current_context(), name, *$5); - else - $$= new Item_func_sp(Lex->current_context(), name); - lex->safe_to_cache_query=0; - } - | IDENT_sys '(' - { -#ifdef HAVE_DLOPEN - udf_func *udf= 0; - if (using_udf_functions && - (udf= find_udf($1.str, $1.length)) && - udf->type == UDFTYPE_AGGREGATE) - { - LEX *lex= Lex; - if (lex->current_select->inc_in_sum_expr()) - { - yyerror(ER(ER_SYNTAX_ERROR)); - YYABORT; - } - } - $<udf>$= udf; -#endif - } - udf_expr_list ')' - { -#ifdef HAVE_DLOPEN - 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; - } - } - else -#endif /* HAVE_DLOPEN */ - { - LEX *lex= Lex; - THD *thd= lex->thd; - LEX_STRING db; - if (thd->copy_db_to(&db.str, &db.length)) - YYABORT; - sp_name *name= new sp_name(db, $1); - if (name) - name->init_qname(thd); - - sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION); - if ($4) - $$= new Item_func_sp(Lex->current_context(), name, *$4); - else - $$= new Item_func_sp(Lex->current_context(), name); - lex->safe_to_cache_query=0; - } - } - | 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;} + ; + +/* + 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 Item_func_ascii($3); } + | CHARSET '(' expr ')' + { $$= new Item_func_charset($3); } + | COALESCE '(' expr_list ')' + { $$= new Item_func_coalesce(* $3); } + | COLLATION_SYM '(' expr ')' + { $$= new Item_func_collation($3); } + | DATABASE '(' ')' + { + $$= new Item_func_database(); + Lex->safe_to_cache_query=0; + } + | MICROSECOND_SYM '(' expr ')' + { $$= new Item_func_microsecond($3); } + | MOD_SYM '(' expr ',' expr ')' + { $$ = new Item_func_mod( $3, $5); } + | OLD_PASSWORD '(' expr ')' + { $$= new Item_func_old_password($3); } + | PASSWORD '(' expr ')' + { + $$= YYTHD->variables.old_passwords ? + (Item *) new Item_func_old_password($3) : + (Item *) new Item_func_password($3); + } + | QUARTER_SYM '(' expr ')' + { $$ = new Item_func_quarter($3); } + | REPEAT_SYM '(' expr ',' expr ')' + { $$= new Item_func_repeat($3,$5); } + | REPLACE '(' expr ',' expr ',' expr ')' + { $$= new Item_func_replace($3,$5,$7); } + | TRUNCATE_SYM '(' expr ',' expr ')' + { $$= new Item_func_round($3,$5,1); } | WEEK_SYM '(' expr ')' { $$= new Item_func_week($3,new Item_int((char*) "0", @@ -6592,31 +6329,21 @@ simple_expr: } | 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); }; + | geometry_function + { +#ifdef HAVE_SPATIAL + $$= $1; +#else + my_error(ER_FEATURE_DISABLED, MYF(0), + sym_group_geom.name, sym_group_geom.needed_define); + YYABORT; +#endif + } + ; geometry_function: CONTAINS_SYM '(' expr ',' expr ')' { $$= GEOM_NEW(Item_func_spatial_rel($3, $5, Item_func::SP_CONTAINS_FUNC)); } - | GEOMFROMTEXT '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3)); } - | GEOMFROMTEXT '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); } - | GEOMFROMWKB '(' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_wkb($3)); } - | GEOMFROMWKB '(' expr ',' expr ')' - { $$= GEOM_NEW(Item_func_geometry_from_wkb($3, $5)); } | GEOMETRYCOLLECTION '(' expr_list ')' { $$= GEOM_NEW(Item_func_spatial_collection(* $3, Geometry::wkb_geometrycollection, @@ -6627,18 +6354,6 @@ geometry_function: | 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)); } @@ -6647,26 +6362,110 @@ geometry_function: 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)); } - ; + ; + +/* + Regular function calls. + The function name is *not* a token, and therefore is guaranteed to not + introduce side effects to the language in general. + MAINTAINER: + All the new functions implemented for new features should fit into + this category. The place to implement the function itself is + in sql/item_create.cc + */ +function_call_generic: + IDENT_sys '(' + { +#ifdef HAVE_DLOPEN + udf_func *udf= 0; + if (using_udf_functions && + (udf= find_udf($1.str, $1.length)) && + udf->type == UDFTYPE_AGGREGATE) + { + LEX *lex= Lex; + if (lex->current_select->inc_in_sum_expr()) + { + yyerror(ER(ER_SYNTAX_ERROR)); + YYABORT; + } + } + // Temporary placing the result of find_udf in $3 + $<udf>$= udf; +#endif + } + expr_list_opt ')' + { + THD *thd= YYTHD; + LEX *lex= Lex; + create_func *builder; + Item *item= NULL; + int error; + + /* + Implementation note: + names are resolved with the following order: + - MySQL native builtin functions, + - User Defined Functions, + - Stored Functions (assuming the current <use> database) + + This will be revised with WL#2128 (SQL PATH) + */ + builder= find_sql_function_builder(thd, $1); + if (builder) + { + error= builder->create(thd, $1, $4, item); + } + else + { +#ifdef HAVE_DLOPEN + // Retrieving the result of find_udf + udf_func *udf= $<udf>3; + + if (udf) + { + if (udf->type == UDFTYPE_AGGREGATE) + Select->in_sum_expr--; + + lex->binlog_row_based_if_mixed= TRUE; + + error= create_udf_func::s_singleton.create(thd, udf, $4, item); + } + else +#endif + { + builder= find_sp_function_builder(thd); + DBUG_ASSERT(builder); + error= builder->create(thd, $1, $4, item); + } + } + + if (error) + { + YYABORT; + } + $$ = item; + } + | ident '.' ident '(' udf_expr_list ')' + { + THD *thd= YYTHD; + create_qfunc *builder; + Item *item= NULL; + int error; + + builder= find_sp_function_builder(thd); + DBUG_ASSERT(builder); + error= builder->create(thd, $1, $3, $5, item); + + if (error) + { + YYABORT; + } + $$ = item; + } + ; fulltext_options: opt_natural_language_mode opt_query_expansion @@ -6836,6 +6635,13 @@ cast_type: | DECIMAL_SYM float_options { $$=ITEM_CAST_DECIMAL; Lex->charset= NULL; } ; +expr_list_opt: + /* empty */ + { $$ = NULL; } + | expr_list + { $$ = $1;} + ; + expr_list: { Select->expr_list.push_front(new List<Item>); } expr_list2 @@ -9432,7 +9238,18 @@ keyword_sp: | AGAINST {} | AGGREGATE_SYM {} | ALGORITHM_SYM {} - | ANY_SYM {} + | ANY_SYM + { + /* + This is a SQL-2003 *reserved* keyword, + that should not have been allowed, + and cause Shift/Reduce conflicts. + See + bool_pri : + bool_pri comp_op ANY_SYM in_subselect %prec EQ + TODO: WARN_DEPRECATED() + */ + } | AT_SYM {} | AUTHORS_SYM {} | AUTO_INC {} --- 1.120/sql/share/errmsg.txt 2006-09-27 17:01:47 -07:00 +++ 1.121/sql/share/errmsg.txt 2006-09-27 17:01:47 -07:00 @@ -5960,3 +5960,7 @@ ER_HOSTNAME eng "host name" ER_WRONG_STRING_LENGTH eng "String '%-.70s' is too long for %s (should be no longer than %d)" +ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT 42000 + eng "Incorrect parameter count to builtin function '%-.64s'" +ER_WRONG_PARAMETERS_TO_BUILTIN_FCT 42000 + eng "Incorrect parameters to builtin function '%-.64s'" --- 1.174/mysql-test/r/view.result 2006-09-27 17:01:47 -07:00 +++ 1.175/mysql-test/r/view.result 2006-09-27 17:01:47 -07:00 @@ -793,13 +793,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.155/mysql-test/t/view.test 2006-09-27 17:01:47 -07:00 +++ 1.156/mysql-test/t/view.test 2006-09-27 17:01:47 -07:00 @@ -708,11 +708,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/09/27 17:01:36 ## ## 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 $FCT= <value_1>; ## -- source parser_stress_func.inc ## let $FCT= <value_2>; ## -- source parser_stress_func.inc -- disable_warnings drop table if exists $FCT; drop table if exists bug21114_child; -- enable_warnings 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; eval SHOW CREATE TABLE $FCT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; eval DROP TABLE $FCT; --- New file --- +++ mysql-test/r/parser_stress_func_innodb.result 06/09/27 17:01:36 drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ABS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ABS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ABS (col1, col2) ) ENGINE InnoDb; 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 $FCT; drop table if exists bug21114_child; CREATE TABLE FIELD( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FIELD(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FIELD (col1, col2) ) ENGINE InnoDb; 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 $FCT; drop table if exists bug21114_child; CREATE TABLE FORMAT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FORMAT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FORMAT (col1, col2) ) ENGINE InnoDb; 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 $FCT; drop table if exists bug21114_child; CREATE TABLE ACOS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ACOS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ACOS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ACOS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ACOS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ADDDATE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ADDDATE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ADDDATE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ADDDATE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ADDDATE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ADDTIME( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ADDTIME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ADDTIME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ADDTIME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ADDTIME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE AES_DECRYPT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 AES_DECRYPT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES AES_DECRYPT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE AES_DECRYPT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE AES_DECRYPT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE AES_ENCRYPT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 AES_ENCRYPT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES AES_ENCRYPT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE AES_ENCRYPT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE AES_ENCRYPT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE AREA( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 AREA(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES AREA (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE AREA; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE AREA; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ASBINARY( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ASBINARY(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ASBINARY (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ASBINARY; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ASBINARY; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ASIN( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ASIN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ASIN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ASIN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ASIN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ASTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ASTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ASTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ASTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ASTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ASWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ASWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ASWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ASWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ASWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ASWKT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ASWKT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ASWKT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ASWKT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ASWKT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ATAN( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ATAN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ATAN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ATAN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ATAN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ATAN2( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ATAN2(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ATAN2 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ATAN2; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ATAN2; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE BENCHMARK( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 BENCHMARK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES BENCHMARK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE BENCHMARK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE BENCHMARK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE BIN( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 BIN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES BIN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE BIN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE BIN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE BIT_COUNT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 BIT_COUNT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES BIT_COUNT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE BIT_COUNT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE BIT_COUNT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE BIT_LENGTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 BIT_LENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES BIT_LENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE BIT_LENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE BIT_LENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CEIL( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CEIL(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CEIL (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CEIL; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CEIL; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CEILING( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CEILING(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CEILING (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CEILING; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CEILING; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CENTROID( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CENTROID(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CENTROID (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CENTROID; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CENTROID; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CHARACTER_LENGTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CHARACTER_LENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CHARACTER_LENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CHARACTER_LENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CHARACTER_LENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CHAR_LENGTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CHAR_LENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CHAR_LENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CHAR_LENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CHAR_LENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE COERCIBILITY( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 COERCIBILITY(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES COERCIBILITY (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE COERCIBILITY; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE COERCIBILITY; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE COMPRESS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 COMPRESS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES COMPRESS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE COMPRESS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE COMPRESS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CONCAT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CONCAT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CONCAT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CONCAT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CONCAT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CONCAT_WS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CONCAT_WS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CONCAT_WS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CONCAT_WS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CONCAT_WS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CONNECTION_ID( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CONNECTION_ID(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CONNECTION_ID (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CONNECTION_ID; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CONNECTION_ID; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CONV( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CONV(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CONV (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CONV; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CONV; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CONVERT_TZ( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CONVERT_TZ(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CONVERT_TZ (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CONVERT_TZ; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CONVERT_TZ; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE COS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 COS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES COS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE COS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE COS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE COT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 COT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES COT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE COT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE COT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CRC32( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CRC32(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CRC32 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CRC32; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CRC32; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE CROSSES( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 CROSSES(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES CROSSES (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE CROSSES; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE CROSSES; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DATEDIFF( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DATEDIFF(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DATEDIFF (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DATEDIFF; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DATEDIFF; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DATE_FORMAT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DATE_FORMAT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DATE_FORMAT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DATE_FORMAT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DATE_FORMAT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DAYNAME( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DAYNAME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DAYNAME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DAYNAME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DAYNAME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DAYOFMONTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DAYOFMONTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DAYOFMONTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DAYOFMONTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DAYOFMONTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DAYOFWEEK( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DAYOFWEEK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DAYOFWEEK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DAYOFWEEK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DAYOFWEEK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DAYOFYEAR( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DAYOFYEAR(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DAYOFYEAR (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DAYOFYEAR; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DAYOFYEAR; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DECODE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DECODE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DECODE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DECODE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DECODE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DEGREES( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DEGREES(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DEGREES (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DEGREES; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DEGREES; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DES_DECRYPT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DES_DECRYPT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DES_DECRYPT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DES_DECRYPT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DES_DECRYPT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DES_ENCRYPT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DES_ENCRYPT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DES_ENCRYPT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DES_ENCRYPT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DES_ENCRYPT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DIMENSION( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DIMENSION(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DIMENSION (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DIMENSION; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DIMENSION; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE DISJOINT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 DISJOINT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES DISJOINT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE DISJOINT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE DISJOINT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ELT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ELT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ELT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ELT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ELT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ENCODE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ENCODE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ENCODE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ENCODE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ENCODE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ENCRYPT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ENCRYPT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ENCRYPT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ENCRYPT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ENCRYPT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ENDPOINT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ENDPOINT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ENDPOINT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ENDPOINT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ENDPOINT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ENVELOPE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ENVELOPE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ENVELOPE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ENVELOPE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ENVELOPE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE EQUALS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 EQUALS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES EQUALS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE EQUALS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE EQUALS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE EXP( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 EXP(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES EXP (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE EXP; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE EXP; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE EXPORT_SET( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 EXPORT_SET(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES EXPORT_SET (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE EXPORT_SET; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE EXPORT_SET; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE EXTERIORRING( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 EXTERIORRING(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES EXTERIORRING (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE EXTERIORRING; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE EXTERIORRING; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE EXTRACTVALUE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 EXTRACTVALUE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES EXTRACTVALUE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE EXTRACTVALUE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE EXTRACTVALUE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE FIND_IN_SET( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FIND_IN_SET(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FIND_IN_SET (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE FIND_IN_SET; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE FIND_IN_SET; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE FLOOR( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FLOOR(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FLOOR (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE FLOOR; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE FLOOR; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE FOUND_ROWS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FOUND_ROWS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FOUND_ROWS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE FOUND_ROWS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE FOUND_ROWS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE FROM_DAYS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FROM_DAYS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FROM_DAYS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE FROM_DAYS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE FROM_DAYS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE FROM_UNIXTIME( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 FROM_UNIXTIME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES FROM_UNIXTIME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE FROM_UNIXTIME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE FROM_UNIXTIME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMCOLLFROMTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMCOLLFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMCOLLFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMCOLLFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMCOLLFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMCOLLFROMWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMCOLLFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMCOLLFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMCOLLFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMCOLLFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYCOLLECTIONFROMTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYCOLLECTIONFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYCOLLECTIONFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYCOLLECTIONFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYCOLLECTIONFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYCOLLECTIONFROMWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYCOLLECTIONFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYCOLLECTIONFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYCOLLECTIONFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYCOLLECTIONFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYFROMTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYFROMWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYN( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMETRYTYPE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMETRYTYPE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMETRYTYPE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMETRYTYPE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMETRYTYPE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMFROMTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GEOMFROMWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GEOMFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GEOMFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GEOMFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GEOMFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GET_LOCK( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GET_LOCK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GET_LOCK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GET_LOCK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GET_LOCK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GLENGTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GLENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GLENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GLENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GLENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE GREATEST( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 GREATEST(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES GREATEST (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE GREATEST; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE GREATEST; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE HEX( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 HEX(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES HEX (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE HEX; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE HEX; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE IFNULL( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 IFNULL(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES IFNULL (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE IFNULL; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE IFNULL; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE INET_ATON( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 INET_ATON(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES INET_ATON (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE INET_ATON; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE INET_ATON; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE INET_NTOA( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 INET_NTOA(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES INET_NTOA (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE INET_NTOA; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE INET_NTOA; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE INSTR( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 INSTR(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES INSTR (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE INSTR; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE INSTR; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE INTERIORRINGN( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 INTERIORRINGN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES INTERIORRINGN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE INTERIORRINGN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE INTERIORRINGN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE INTERSECTS( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 INTERSECTS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES INTERSECTS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE INTERSECTS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE INTERSECTS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ISCLOSED( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ISCLOSED(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ISCLOSED (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ISCLOSED; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ISCLOSED; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ISEMPTY( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ISEMPTY(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ISEMPTY (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ISEMPTY; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ISEMPTY; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ISNULL( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ISNULL(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ISNULL (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ISNULL; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ISNULL; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ISSIMPLE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 ISSIMPLE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ISSIMPLE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ISSIMPLE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ISSIMPLE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE IS_FREE_LOCK( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 IS_FREE_LOCK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES IS_FREE_LOCK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE IS_FREE_LOCK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE IS_FREE_LOCK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE IS_USED_LOCK( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 IS_USED_LOCK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES IS_USED_LOCK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE IS_USED_LOCK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE IS_USED_LOCK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LAST_DAY( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LAST_DAY(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LAST_DAY (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LAST_DAY; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LAST_DAY; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LAST_INSERT_ID( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LAST_INSERT_ID(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LAST_INSERT_ID (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LAST_INSERT_ID; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LAST_INSERT_ID; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LCASE( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LCASE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LCASE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LCASE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LCASE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LEAST( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LEAST(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LEAST (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LEAST; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LEAST; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LENGTH( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LINEFROMTEXT( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2) ) ENGINE InnoDb; 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 LINEFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LINEFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LINEFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LINEFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LINEFROMWKB( col1 int not null, col2 int not null, col3 varchar(10), CONSTRAINT pk PRIMARY KEY (col1, col2)
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (malff:1.2307) | marc.alff | 28 Sep |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 2.339 sec. using MySQL 5.1.14-beta-log