| List: | Commits | « Previous MessageNext Message » | |
| From: | marc.alff | Date: | October 17 2006 11:54pm |
| Subject: | bk commit into 5.1 tree (malff:1.2307) BUG#21114 | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1 repository of marcsql. When marcsql does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet@stripped, 2006-10-17 14:54:44-07:00, malff@weblab.(none) +20 -0 Bug#21114 (Foreign key creation fails to table with name format) Before the change, A) MySQL native functions Depending on the exact name of the function, 1 or more of the following could happen for a given name: - "foo" "(" was always interpreted by the parser as a function call - "foo" <space> "(", depending on the sql_mode (IGNORE_SPACE), was: - sometime a native function call, - sometime a UDF, - sometime a stored function in the current <use> database. For example, see connection_id() - "foo" "(" or "foo" <space> "(", regardless of the sql_mode, was interpreted as a function call. For example, see database() B) Pollution of the DDL (Data Definition Language) Each identifier name recognized at the lexical level (sql_lex.h) would be returned to the parser as a function (FUNC_ARG0, ...), regardless of the parsing context. This in particular caused incompatibilities when a valid identifier followed by a '(' would collide with a MySQL *non* reserved function name, in a context where no functions calls are expected. In particular, CREATE TABLE foo ( ... REFERENCES FOREIGN KEY foo (... would not parse for valid table names. C) Pollution of the grammar Some functions, using *non* reserved names, were implemented as a token in the grammar. Doing so in effect makes the name reserved, and can break user code. See for example benchmark() D) Risk of regressions and incompatibilities Each time a new function is implemented for a feature, a risk exist that implementing the function following the existing design pattern will introduce new incompatibilities, and break otherwise valid user code. After the change, A) MySQL native functions - spaces are not significant, so that "foo" "(" and "foo" <space> "(" always refer to the same object, regardless of the current sql_mode. B) Non pollution of the DDL (Data Definition Language) - an identifier followed by '(' is a function call *only* if it's found when parsing what is expected to be an expression. C) Pollution of the grammar - some tokens have simply been removed, preventing any pollution. D) Risk of regressions and incompatibilities This risk has been reduced. The current design enforces that new function names are introduced in item_create.cc, which does not affect the overall grammar or the lexical parsing. The change consist of 1) removing any CREATE_FUNC builder from sql/lex.h sql_functions[] 2) documenting reserved / non reserved keywords in sql/sql_yacc.yy 3) reorganizing the grammar to better classify and document rules 4) change the CREATE_FUNC factory/builder pattern from a C-style function pointer call back to a C++ virtual function call. This is critical since the pattern has been generalized to take into account functions with a variable number or arguments, which in turn is critical to avoid even naming a function like EXPORT_SET in the bison parser (see point C). The builder pattern works with the following class structure: Create_func - Create_func_arg0 - Create_func_connection_id, ... - Create_func_arg1 - Create_func_cos, ... - Create_func_arg2 - Create_func_addtime, ... - Create_func_arg3 - Create_func_maketime, ... - Create_func_export_set, ... Impact on the bison parser The complexity of the generated code has decreased significantly. The net change (in BEFORE --> AFTER (DELTA) format) is: /* YYLAST -- Last index in YYTABLE. */ 47613 --> 42003 (-5610) /* YYNTOKENS -- Number of terminals. */ 612 --> 570 (-42) /* YYNNTS -- Number of nonterminals. */ 814 --> 818 (+4) /* YYNRULES -- Number of rules. */ 2344 --> 2284 (-60) /* YYNRULES -- Number of states. */ 4183 --> 3918 (-265) Incompatible change Previous user code that would: - run only in IGNORE_SPACE=false sql_mode - define stored functions with a name that collide with a MySQL built in function - call the stored function using "foo" <space> "(" will now parse differently, interpreting the call as a call to a native function. Note that this historical behavior is not standard (see below), and that the same user code would execute differently or fail with sql_mode=ANSI. Last note The SQL standard defines a "PATH" syntax to help clarify how "foo" "(" should be interpreted, and in particular define the order of databases to search for a function named <db>.foo(). See WL 2128 for details. This patch, by removing name resolution from the lex ad yacc parser (a single grammar rule, function_call_generic, is used in the grammar, so name resolution is technically separated from the grammar now) makes the implementation of WL 2128 possible. BitKeeper/deleted/.del-Doxyfile@stripped, 2006-10-17 10:34:43-07:00, malff@weblab.(none) +0 -0 Delete: Doxyfile Doxyfile@stripped, 2006-10-17 10:32:51-07:00, malff@weblab.(none) +308 -0 Intermediate Change set, do not review Doxyfile@stripped, 2006-10-17 10:32:51-07:00, malff@weblab.(none) +0 -0 mysql-test/include/parser_stress_func.inc@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +44 -0 New tests mysql-test/include/parser_stress_func.inc@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +0 -0 mysql-test/r/func_math.result@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +12 -0 Improved test coverage mysql-test/r/func_misc.result@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +112 -0 Testing edge conditions for built in functions mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +4703 -0 New tests mysql-test/r/parser_stress_func_innodb.result@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +0 -0 mysql-test/r/view.result@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +4 -4 Name collision, x() is a geometry built in function mysql-test/t/func_math.test@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +5 -0 Improved test coverage mysql-test/t/func_misc.test@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +143 -0 Testing edge conditions for built in functions mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +419 -0 New tests mysql-test/t/parser_stress_func_innodb.test@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +0 -0 mysql-test/t/view.test@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +3 -3 Name collision, x() is a geometry built in function sql/item_create.cc@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +2255 -316 Revised the create_func implementation sql/item_create.h@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +141 -144 Revised the create_func implementation sql/item_create_priv.h@stripped, 2006-10-17 10:30:42-07:00, malff@weblab.(none) +2061 -0 Split from item_create.h sql/item_create_priv.h@stripped, 2006-10-17 10:30:42-07:00, malff@weblab.(none) +0 -0 sql/lex.h@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +6 -213 Removed function parsing from the lexical parser sql/lex_symbol.h@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +0 -1 Removed function parsing from the lexical parser sql/mysql_priv.h@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +4 -0 Server initialization and shutdown sql/mysqld.cc@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +2 -0 Server initialization and shutdown sql/share/errmsg.txt@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +4 -0 New error messages sql/sql_yacc.yy@stripped, 2006-10-17 11:18:58-07:00, malff@weblab.(none) +533 -719 Documented the tokens, reorganized the functions tests/mysql_client_test.c@stripped, 2006-10-17 11:18:58-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-10-17 14:54:51 -07:00 +++ 1.67/sql/item_create.cc 2006-10-17 14:54:51 -07:00 @@ -17,725 +17,2664 @@ /* Functions to create an item. Used by lex.h */ #include "mysql_priv.h" +#include "item_create.h" +#include "item_create_priv.h" +#include "sp_head.h" +#include "sp.h" + +// Helpers +#ifndef HAVE_SPATIAL +Create_func_no_geom Create_func_no_geom::s_singleton; + +Item* +Create_func_no_geom::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + // FIXME: error message can't be translated. + my_error(ER_FEATURE_DISABLED, MYF(0), + sym_group_geom.name, sym_group_geom.needed_define); + return NULL; +} +#endif + +Item* +Create_qfunc::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + LEX_STRING db; + if (thd->copy_db_to(&db.str, &db.length)) + { + return NULL; + } + + return create(thd, db, name, item_list); +} + +#ifdef HAVE_DLOPEN +Create_udf_func Create_udf_func::s_singleton; + +Item* +Create_udf_func::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + udf_func *udf= find_udf(name.str, name.length); + DBUG_ASSERT(udf); + return create(thd, udf, item_list); +} -Item *create_func_abs(Item* a) +Item* +Create_udf_func::create(THD *thd, udf_func *udf, List<Item> *item_list) { - return new Item_func_abs(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + +#ifdef HAVE_ROW_BASED_REPLICATION + thd->lex->binlog_row_based_if_mixed= TRUE; +#endif + + DBUG_ASSERT( (udf->type == UDFTYPE_FUNCTION) + || (udf->type == UDFTYPE_AGGREGATE)); + + switch(udf->returns) + { + case STRING_RESULT: + { + if (udf->type == UDFTYPE_FUNCTION) + { + if (arg_count) + func= new 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"); + } + } + return func; +} +#endif + +Create_sp_func Create_sp_func::s_singleton; + +Item* +Create_sp_func::create(THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list) +{ + int arg_count= 0; + Item *func= NULL; + LEX *lex= thd->lex; + sp_name *qname= new 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 func; } -Item *create_func_acos(Item* a) + +Item* +Create_func_arg0::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_acos(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + if (arg_count != 0) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + func= create(thd); + } + + return func; } -Item *create_func_aes_encrypt(Item* a, Item* b) +Item* +Create_func_arg1::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_aes_encrypt(a, b); + Item* func= NULL; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + if (arg_count != 1) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + Item *param_1= item_list->pop(); + func= create(thd, param_1); + } + + return func; } -Item *create_func_aes_decrypt(Item* a, Item* b) +Item* +Create_func_arg2::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_aes_decrypt(a, b); + Item *func= NULL; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + if (arg_count != 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= create(thd, param_1, param_2); + } + + return func; } -Item *create_func_ascii(Item* a) + +Item* +Create_func_arg3::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_ascii(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list) + { + arg_count= item_list->elements; + } + + if (arg_count != 3) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *param_3= item_list->pop(); + func= create(thd, param_1, param_2, param_3); + } + + return func; } -Item *create_func_ord(Item* a) +Create_func_abs Create_func_abs::s_singleton; + +Item* +Create_func_abs::create(THD *thd, Item *arg1) { - return new Item_func_ord(a); + return new Item_func_abs(arg1); } -Item *create_func_asin(Item* a) +Create_func_acos Create_func_acos::s_singleton; + +Item* +Create_func_acos::create(THD *thd, Item *arg1) { - return new Item_func_asin(a); + return new Item_func_acos(arg1); } -Item *create_func_bin(Item* a) +Create_func_addtime Create_func_addtime::s_singleton; + +Item* +Create_func_addtime::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 2,1)); + return new Item_func_add_time(arg1, arg2, 0, 0); } -Item *create_func_bit_count(Item* a) +Create_func_aes_encrypt Create_func_aes_encrypt::s_singleton; + +Item* +Create_func_aes_encrypt::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_bit_count(a); + return new Item_func_aes_encrypt(arg1, arg2); } -Item *create_func_ceiling(Item* a) +Create_func_aes_decrypt Create_func_aes_decrypt::s_singleton; + +Item* +Create_func_aes_decrypt::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_ceiling(a); + return new Item_func_aes_decrypt(arg1, arg2); } -Item *create_func_connection_id(void) +#ifdef HAVE_SPATIAL +Create_func_area Create_func_area::s_singleton; + +Item* +Create_func_area::create(THD *thd, Item *arg1) { - current_thd->lex->safe_to_cache_query= 0; - return new Item_func_connection_id(); + return new Item_func_area(arg1); } +#endif + +#ifdef HAVE_SPATIAL +Create_func_as_wkb Create_func_as_wkb::s_singleton; + +Item* +Create_func_as_wkb::create(THD *thd, Item *arg1) +{ + return new Item_func_as_wkb(arg1); +} +#endif + +#ifdef HAVE_SPATIAL +Create_func_as_wkt Create_func_as_wkt::s_singleton; + +Item* +Create_func_as_wkt::create(THD *thd, Item *arg1) +{ + return new Item_func_as_wkt(arg1); +} +#endif + +Create_func_asin Create_func_asin::s_singleton; + +Item* +Create_func_asin::create(THD *thd, Item *arg1) +{ + return new Item_func_asin(arg1); +} + +Create_func_atan Create_func_atan::s_singleton; -Item *create_func_conv(Item* a, Item *b, Item *c) +Item* +Create_func_atan::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_conv(a,b,c); + Item* func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_cos(Item* a) +Create_func_benchmark Create_func_benchmark::s_singleton; + +Item* +Create_func_benchmark::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_cos(a); + Item *func= NULL; + + /* + Previously, this constraint was in the parser grammar. + Just accepting an int constant for the first parameter. + TODO: Item_func_benchmark 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"); + } + else + { + func= new Item_func_benchmark(arg1->val_int(), arg2); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + } + + return func; } -Item *create_func_cot(Item* a) +Create_func_bin Create_func_bin::s_singleton; + +Item* +Create_func_bin::create(THD *thd, Item *arg1) { - 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); + return new Item_func_conv(arg1, i10, i2); } -Item *create_func_date_format(Item* a,Item *b) +Create_func_bit_count Create_func_bit_count::s_singleton; + +Item* +Create_func_bit_count::create(THD *thd, Item *arg1) { - return new Item_func_date_format(a,b,0); + return new Item_func_bit_count(arg1); } -Item *create_func_dayofmonth(Item* a) +Create_func_bit_length Create_func_bit_length::s_singleton; + +Item* +Create_func_bit_length::create(THD *thd, Item *arg1) { - return new Item_func_dayofmonth(a); + return new Item_func_bit_length(arg1); } -Item *create_func_dayofweek(Item* a) +Create_func_ceiling Create_func_ceiling::s_singleton; + +Item* +Create_func_ceiling::create(THD *thd, Item *arg1) { - return new Item_func_weekday(a, 1); + return new Item_func_ceiling(arg1); } -Item *create_func_dayofyear(Item* a) +#ifdef HAVE_SPATIAL +Create_func_centroid Create_func_centroid::s_singleton; + +Item* +Create_func_centroid::create(THD *thd, Item *arg1) { - return new Item_func_dayofyear(a); + return new Item_func_centroid(arg1); } +#endif + +Create_func_char_length Create_func_char_length::s_singleton; -Item *create_func_dayname(Item* a) +Item* +Create_func_char_length::create(THD *thd, Item *arg1) { - return new Item_func_dayname(a); + return new Item_func_char_length(arg1); } -Item *create_func_degrees(Item *a) +Create_func_coercibility Create_func_coercibility::s_singleton; + +Item* +Create_func_coercibility::create(THD *thd, Item *arg1) { - return new Item_func_units((char*) "degrees",a,180/M_PI,0.0); + return new Item_func_coercibility(arg1); } -Item *create_func_exp(Item* a) +Create_func_concat Create_func_concat::s_singleton; + +Item* +Create_func_concat::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_exp(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + if (arg_count < 1) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + func= new Item_func_concat(*item_list); + } + + return func; } -Item *create_func_find_in_set(Item* a, Item *b) +Create_func_concat_ws Create_func_concat_ws::s_singleton; + +Item* +Create_func_concat_ws::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_find_in_set(a, b); + Item* func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + // 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); + } + else + { + func= new Item_func_concat_ws(*item_list); + } + + return func; } -Item *create_func_floor(Item* a) +Create_func_compress Create_func_compress::s_singleton; + +Item* +Create_func_compress::create(THD *thd, Item *arg1) { - return new Item_func_floor(a); + return new Item_func_compress(arg1); } -Item *create_func_found_rows(void) +Create_func_connection_id Create_func_connection_id::s_singleton; + +Item* +Create_func_connection_id::create(THD *thd) { - THD *thd=current_thd; thd->lex->safe_to_cache_query= 0; - return new Item_func_found_rows(); + return new Item_func_connection_id(); } -Item *create_func_from_days(Item* a) +#ifdef HAVE_SPATIAL +Create_func_contains Create_func_contains::s_singleton; + +Item* +Create_func_contains::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_from_days(a); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_CONTAINS_FUNC); } +#endif + +Create_func_conv Create_func_conv::s_singleton; -Item *create_func_get_lock(Item* a, Item *b) +Item* +Create_func_conv::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_get_lock(a, b); + return new Item_func_conv(arg1, arg2, arg3); } -Item *create_func_hex(Item *a) +Create_func_convert_tz Create_func_convert_tz::s_singleton; + +Item* +Create_func_convert_tz::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_hex(a); + if (thd->lex->add_time_zone_tables_to_query_tables(thd)) + { + return NULL; + } + return new Item_func_convert_tz(arg1, arg2, arg3); } -Item *create_func_inet_ntoa(Item* a) +Create_func_cos Create_func_cos::s_singleton; + +Item* +Create_func_cos::create(THD *thd, Item *arg1) { - return new Item_func_inet_ntoa(a); + return new Item_func_cos(arg1); } -Item *create_func_inet_aton(Item* a) +Create_func_cot Create_func_cot::s_singleton; + +Item* +Create_func_cot::create(THD *thd, Item *arg1) { - return new Item_func_inet_aton(a); + Item *i1= new Item_int((char*) "1", 1, 1); + return new Item_func_div(i1, new Item_func_tan(arg1)); } +Create_func_crc32 Create_func_crc32::s_singleton; -Item *create_func_ifnull(Item* a, Item *b) +Item* +Create_func_crc32::create(THD *thd, Item *arg1) { - return new Item_func_ifnull(a,b); + return new Item_func_crc32(arg1); } -Item *create_func_nullif(Item* a, Item *b) +#ifdef HAVE_SPATIAL +Create_func_crosses Create_func_crosses::s_singleton; + +Item* +Create_func_crosses::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_nullif(a,b); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_CROSSES_FUNC); } +#endif + +Create_func_date_format Create_func_date_format::s_singleton; -Item *create_func_locate(Item* a, Item *b) +Item* +Create_func_date_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_locate(b,a); + return new Item_func_date_format(arg1, arg2, 0); } -Item *create_func_instr(Item* a, Item *b) +Create_func_datediff Create_func_datediff::s_singleton; + +Item* +Create_func_datediff::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_locate(a,b); + return new Item_func_minus(new Item_func_to_days(arg1), + new Item_func_to_days(arg2)); } -Item *create_func_isnull(Item* a) +Create_func_dayname Create_func_dayname::s_singleton; + +Item* +Create_func_dayname::create(THD *thd, Item *arg1) { - return new Item_func_isnull(a); + return new Item_func_dayname(arg1); } -Item *create_func_lcase(Item* a) +Create_func_dayofmonth Create_func_dayofmonth::s_singleton; + +Item* +Create_func_dayofmonth::create(THD *thd, Item *arg1) { - return new Item_func_lcase(a); + return new Item_func_dayofmonth(arg1); } -Item *create_func_length(Item* a) +Create_func_dayofweek Create_func_dayofweek::s_singleton; + +Item* +Create_func_dayofweek::create(THD *thd, Item *arg1) { - return new Item_func_length(a); + return new Item_func_weekday(arg1, 1); } -Item *create_func_bit_length(Item* a) +Create_func_dayofyear Create_func_dayofyear::s_singleton; + +Item* +Create_func_dayofyear::create(THD *thd, Item *arg1) { - return new Item_func_bit_length(a); + return new Item_func_dayofyear(arg1); } -Item *create_func_coercibility(Item* a) +Create_func_decode Create_func_decode::s_singleton; + +Item* +Create_func_decode::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_coercibility(a); + Item *func= NULL; + + /* + 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"); + } + else + { + String dummy; + String *val = arg2->val_str(& dummy); + DBUG_ASSERT(val); + func= new Item_func_decode(arg1, val->c_ptr()); + } + + return func; } -Item *create_func_char_length(Item* a) +Create_func_degrees Create_func_degrees::s_singleton; + +Item* +Create_func_degrees::create(THD *thd, Item *arg1) { - return new Item_func_char_length(a); + return new Item_func_units((char*) "degrees", arg1 ,180/M_PI, 0.0); } -Item *create_func_ln(Item* a) +Create_func_des_decrypt Create_func_des_decrypt::s_singleton; + +Item* +Create_func_des_decrypt::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_ln(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_log2(Item* a) +Create_func_des_encrypt Create_func_des_encrypt::s_singleton; + +Item* +Create_func_des_encrypt::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_log2(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_log10(Item* a) +#ifdef HAVE_SPATIAL +Create_func_dimension Create_func_dimension::s_singleton; + +Item* +Create_func_dimension::create(THD *thd, Item *arg1) { - return new Item_func_log10(a); + return new Item_func_dimension(arg1); } +#endif -Item *create_func_lpad(Item* a, Item *b, Item *c) +#ifdef HAVE_SPATIAL +Create_func_disjoint Create_func_disjoint::s_singleton; + +Item* +Create_func_disjoint::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_lpad(a,b,c); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_DISJOINT_FUNC); } +#endif -Item *create_func_ltrim(Item* a) +Create_func_elt Create_func_elt::s_singleton; + +Item* +Create_func_elt::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_ltrim(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + func= new Item_func_elt(*item_list); + } + + return func; } -Item *create_func_md5(Item* a) +Create_func_encode Create_func_encode::s_singleton; + +Item* +Create_func_encode::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_md5(a); + Item *func= NULL; + + /* + 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"); + } + else + { + String dummy; + String *val = arg2->val_str(& dummy); + DBUG_ASSERT(val); + func= new Item_func_encode(arg1, val->c_ptr()); + } + + return func; } -Item *create_func_mod(Item* a, Item *b) +Create_func_encrypt Create_func_encrypt::s_singleton; + +Item* +Create_func_encrypt::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_mod(a,b); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_name_const(Item *a, Item *b) +#ifdef HAVE_SPATIAL +Create_func_endpoint Create_func_endpoint::s_singleton; + +Item* +Create_func_endpoint::create(THD *thd, Item *arg1) { - return new Item_name_const(a,b); + return new Item_func_spatial_decomp(arg1, Item_func::SP_ENDPOINT); } +#endif -Item *create_func_monthname(Item* a) +#ifdef HAVE_SPATIAL +Create_func_envelope Create_func_envelope::s_singleton; + +Item* +Create_func_envelope::create(THD *thd, Item *arg1) { - return new Item_func_monthname(a); + return new Item_func_envelope(arg1); } +#endif -Item *create_func_month(Item* a) +#ifdef HAVE_SPATIAL +Create_func_equals Create_func_equals::s_singleton; + +Item* +Create_func_equals::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_month(a); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_EQUALS_FUNC); } +#endif -Item *create_func_oct(Item *a) +Create_func_exp Create_func_exp::s_singleton; + +Item* +Create_func_exp::create(THD *thd, Item *arg1) { - return new Item_func_conv(a,new Item_int((int32) 10,2), - new Item_int((int32) 8,1)); + return new Item_func_exp(arg1); } -Item *create_func_period_add(Item* a, Item *b) +Create_func_export_set Create_func_export_set::s_singleton; + +Item* +Create_func_export_set::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_period_add(a,b); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 3: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + Item *param_3= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_period_diff(Item* a, Item *b) +#ifdef HAVE_SPATIAL +Create_func_exteriorring Create_func_exteriorring::s_singleton; + +Item* +Create_func_exteriorring::create(THD *thd, Item *arg1) { - return new Item_func_period_diff(a,b); + return new Item_func_spatial_decomp(arg1, Item_func::SP_EXTERIORRING); } +#endif + +Create_func_field Create_func_field::s_singleton; -Item *create_func_pi(void) +Item* +Create_func_field::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_static_float_func("pi()", M_PI, 6, 8); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + func= new Item_func_field(*item_list); + } + + return func; } -Item *create_func_pow(Item* a, Item *b) +Create_func_find_in_set Create_func_find_in_set::s_singleton; + +Item* +Create_func_find_in_set::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_pow(a,b); + return new Item_func_find_in_set(arg1, arg2); } -Item *create_func_radians(Item *a) +Create_func_floor Create_func_floor::s_singleton; + +Item* +Create_func_floor::create(THD *thd, Item *arg1) { - return new Item_func_units((char*) "radians",a,M_PI/180,0.0); + return new Item_func_floor(arg1); } -Item *create_func_release_lock(Item* a) +Create_func_format Create_func_format::s_singleton; + +Item* +Create_func_format::create(THD *thd, Item *arg1, Item *arg2) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_release_lock(a); + Item *func= NULL; + + /* + 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"); + } + else + { + func= new Item_func_format(arg1, arg2->val_int()); + } + + return func; } -Item *create_func_repeat(Item* a, Item *b) +Create_func_found_rows Create_func_found_rows::s_singleton; + +Item* +Create_func_found_rows::create(THD *thd) { - return new Item_func_repeat(a,b); + thd->lex->safe_to_cache_query= 0; + return new Item_func_found_rows(); } -Item *create_func_reverse(Item* a) +Create_func_from_days Create_func_from_days::s_singleton; + +Item* +Create_func_from_days::create(THD *thd, Item *arg1) { - return new Item_func_reverse(a); + return new Item_func_from_days(arg1); } -Item *create_func_rpad(Item* a, Item *b, Item *c) +Create_func_from_unixtime Create_func_from_unixtime::s_singleton; + +Item* +Create_func_from_unixtime::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_rpad(a,b,c); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } -Item *create_func_rtrim(Item* a) +#ifdef HAVE_SPATIAL +Create_func_geometry_from_text Create_func_geometry_from_text::s_singleton; + +Item* +Create_func_geometry_from_text::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_rtrim(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } +#endif + +#ifdef HAVE_SPATIAL +Create_func_geometry_from_wkb Create_func_geometry_from_wkb::s_singleton; -Item *create_func_sec_to_time(Item* a) +Item* +Create_func_geometry_from_wkb::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_sec_to_time(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; } +#endif + +#ifdef HAVE_SPATIAL +Create_func_geometry_type Create_func_geometry_type::s_singleton; -Item *create_func_sign(Item* a) +Item* +Create_func_geometry_type::create(THD *thd, Item *arg1) { - return new Item_func_sign(a); + return new Item_func_geometry_type(arg1); } +#endif + +#ifdef HAVE_SPATIAL +Create_func_geometryn Create_func_geometryn::s_singleton; -Item *create_func_sin(Item* a) +Item* +Create_func_geometryn::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sin(a); + return new Item_func_spatial_decomp_n(arg1, arg2, Item_func::SP_GEOMETRYN); } +#endif + +Create_func_get_lock Create_func_get_lock::s_singleton; -Item *create_func_sha(Item* a) +Item* +Create_func_get_lock::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sha(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_func_get_lock(arg1, arg2); } -Item *create_func_sleep(Item* a) +#ifdef HAVE_SPATIAL +Create_func_glength Create_func_glength::s_singleton; + +Item* +Create_func_glength::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_sleep(a); + return new Item_func_glength(arg1); } +#endif -Item *create_func_space(Item *a) +Create_func_greatest Create_func_greatest::s_singleton; + +Item* +Create_func_greatest::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - CHARSET_INFO *cs= current_thd->variables.collation_connection; - Item *sp; + Item *func= NULL; + int arg_count= 0; - if (cs->mbminlen > 1) + if (item_list != NULL) { - 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; + } + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); } else { - sp= new Item_string(" ",1,cs); + func= new Item_func_max(*item_list); } - return sp ? new Item_func_repeat(sp, a) : 0; + + return func; } -Item *create_func_soundex(Item* a) +Create_func_hex Create_func_hex::s_singleton; + +Item* +Create_func_hex::create(THD *thd, Item *arg1) { - return new Item_func_soundex(a); + return new Item_func_hex(arg1); } -Item *create_func_sqrt(Item* a) +Create_func_ifnull Create_func_ifnull::s_singleton; + +Item* +Create_func_ifnull::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_sqrt(a); + return new Item_func_ifnull(arg1, arg2); } -Item *create_func_strcmp(Item* a, Item *b) +Create_func_inet_ntoa Create_func_inet_ntoa::s_singleton; + +Item* +Create_func_inet_ntoa::create(THD *thd, Item *arg1) { - return new Item_func_strcmp(a,b); + return new Item_func_inet_ntoa(arg1); } -Item *create_func_tan(Item* a) +Create_func_inet_aton Create_func_inet_aton::s_singleton; + +Item* +Create_func_inet_aton::create(THD *thd, Item *arg1) { - return new Item_func_tan(a); + return new Item_func_inet_aton(arg1); } -Item *create_func_time_format(Item *a, Item *b) +Create_func_instr Create_func_instr::s_singleton; + +Item* +Create_func_instr::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_date_format(a,b,1); + return new Item_func_locate(arg1, arg2); } -Item *create_func_time_to_sec(Item* a) +#ifdef HAVE_SPATIAL +Create_func_interiorringn Create_func_interiorringn::s_singleton; + +Item* +Create_func_interiorringn::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_time_to_sec(a); + return new Item_func_spatial_decomp_n(arg1, arg2, + Item_func::SP_INTERIORRINGN); } +#endif + +#ifdef HAVE_SPATIAL +Create_func_intersects Create_func_intersects::s_singleton; -Item *create_func_to_days(Item* a) +Item* +Create_func_intersects::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_to_days(a); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_INTERSECTS_FUNC); } +#endif + +Create_func_is_free_lock Create_func_is_free_lock::s_singleton; -Item *create_func_ucase(Item* a) +Item* +Create_func_is_free_lock::create(THD *thd, Item *arg1) { - return new Item_func_ucase(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_func_is_free_lock(arg1); } -Item *create_func_unhex(Item* a) +Create_func_is_used_lock Create_func_is_used_lock::s_singleton; + +Item* +Create_func_is_used_lock::create(THD *thd, Item *arg1) { - return new Item_func_unhex(a); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_func_is_used_lock(arg1); } -Item *create_func_uuid(void) +#ifdef HAVE_SPATIAL +Create_func_isclosed Create_func_isclosed::s_singleton; + +Item* +Create_func_isclosed::create(THD *thd, Item *arg1) { - THD *thd= current_thd; -#ifdef HAVE_ROW_BASED_REPLICATION - thd->lex->binlog_row_based_if_mixed= TRUE; + return new Item_func_isclosed(arg1); +} #endif - return new(thd->mem_root) Item_func_uuid(); + +#ifdef HAVE_SPATIAL +Create_func_isempty Create_func_isempty::s_singleton; + +Item* +Create_func_isempty::create(THD *thd, Item *arg1) +{ + return new Item_func_isempty(arg1); } +#endif -Item *create_func_version(void) +Create_func_isnull Create_func_isnull::s_singleton; + +Item* +Create_func_isnull::create(THD *thd, Item *arg1) { - return new Item_static_string_func("version()", server_version, - (uint) strlen(server_version), - system_charset_info, DERIVATION_SYSCONST); + return new Item_func_isnull(arg1); } -Item *create_func_weekday(Item* a) +#ifdef HAVE_SPATIAL +Create_func_issimple Create_func_issimple::s_singleton; + +Item* +Create_func_issimple::create(THD *thd, Item *arg1) { - return new Item_func_weekday(a, 0); + return new Item_func_issimple(arg1); } +#endif + +Create_func_last_day Create_func_last_day::s_singleton; -Item *create_func_year(Item* a) +Item* +Create_func_last_day::create(THD *thd, Item *arg1) { - return new Item_func_year(a); + return new Item_func_last_day(arg1); } -Item *create_load_file(Item* a) +Create_func_last_insert_id Create_func_last_insert_id::s_singleton; + +Item* +Create_func_last_insert_id::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_load_file(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + 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); + break; + } + } + + return func; } +Create_func_lcase Create_func_lcase::s_singleton; -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs) +Item* +Create_func_lcase::create(THD *thd, Item *arg1) { - Item *res; - int tmp_len; - LINT_INIT(res); + return new Item_func_lcase(arg1); +} + +Create_func_least Create_func_least::s_singleton; - 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; +Item* +Create_func_least::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; } - return res; + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + func= new Item_func_min(*item_list); + } + + return func; +} + +Create_func_length Create_func_length::s_singleton; + +Item* +Create_func_length::create(THD *thd, Item *arg1) +{ + return new Item_func_length(arg1); +} + +Create_func_ln Create_func_ln::s_singleton; + +Item* +Create_func_ln::create(THD *thd, Item *arg1) +{ + return new Item_func_ln(arg1); +} + +Create_func_load_file Create_func_load_file::s_singleton; + +Item* +Create_func_load_file::create(THD *thd, Item *arg1) +{ + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_load_file(arg1); +} + +Create_func_locate Create_func_locate::s_singleton; + +Item* +Create_func_locate::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + // Yes, parameters in that order : 2, 1 + func= new 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); + break; + } + } + + return func; +} + +Create_func_log Create_func_log::s_singleton; + +Item* +Create_func_log::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + func= new 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); + break; + } + } + + return func; +} + +Create_func_log10 Create_func_log10::s_singleton; + +Item* +Create_func_log10::create(THD *thd, Item *arg1) +{ + return new Item_func_log10(arg1); +} + +Create_func_log2 Create_func_log2::s_singleton; + +Item* +Create_func_log2::create(THD *thd, Item *arg1) +{ + return new Item_func_log2(arg1); +} + +Create_func_lpad Create_func_lpad::s_singleton; + +Item* +Create_func_lpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new Item_func_lpad(arg1, arg2, arg3); +} + +Create_func_ltrim Create_func_ltrim::s_singleton; + +Item* +Create_func_ltrim::create(THD *thd, Item *arg1) +{ + return new Item_func_ltrim(arg1); +} + +Create_func_makedate Create_func_makedate::s_singleton; + +Item* +Create_func_makedate::create(THD *thd, Item *arg1, Item *arg2) +{ + return new Item_func_makedate(arg1, arg2); +} + +Create_func_maketime Create_func_maketime::s_singleton; + +Item* +Create_func_maketime::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) +{ + return new Item_func_maketime(arg1, arg2, arg3); +} + +Create_func_make_set Create_func_make_set::s_singleton; + +Item* +Create_func_make_set::create(THD *thd, LEX_STRING name, List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + if (arg_count < 2) + { + my_error(ER_WRONG_PARAMCOUNT_TO_BUILTIN_FCT, MYF(0), name.str); + } + else + { + Item *param_1= item_list->pop(); + func= new Item_func_make_set(param_1, *item_list); + } + + return func; +} + +Create_func_master_pos_wait Create_func_master_pos_wait::s_singleton; + +Item* +Create_func_master_pos_wait::create(THD *thd, LEX_STRING name, + List<Item> *item_list) +{ + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 2: + { + Item *param_1= item_list->pop(); + Item *param_2= item_list->pop(); + func= new 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); + break; + } + } + + return func; +} + +Create_func_md5 Create_func_md5::s_singleton; + +Item* +Create_func_md5::create(THD *thd, Item *arg1) +{ + return new Item_func_md5(arg1); +} + +Create_func_monthname Create_func_monthname::s_singleton; + +Item* +Create_func_monthname::create(THD *thd, Item *arg1) +{ + return new Item_func_monthname(arg1); +} + +Create_func_name_const Create_func_name_const::s_singleton; + +Item* +Create_func_name_const::create(THD *thd, Item *arg1, Item *arg2) +{ + return new Item_name_const(arg1, arg2); +} + +Create_func_nullif Create_func_nullif::s_singleton; + +Item* +Create_func_nullif::create(THD *thd, Item *arg1, Item *arg2) +{ + return new Item_func_nullif(arg1, arg2); +} + +#ifdef HAVE_SPATIAL +Create_func_numgeometries Create_func_numgeometries::s_singleton; + +Item* +Create_func_numgeometries::create(THD *thd, Item *arg1) +{ + return new Item_func_numgeometries(arg1); +} +#endif + +#ifdef HAVE_SPATIAL +Create_func_numinteriorring Create_func_numinteriorring::s_singleton; + +Item* +Create_func_numinteriorring::create(THD *thd, Item *arg1) +{ + return new Item_func_numinteriorring(arg1); +} +#endif + +#ifdef HAVE_SPATIAL +Create_func_numpoints Create_func_numpoints::s_singleton; + +Item* +Create_func_numpoints::create(THD *thd, Item *arg1) +{ + return new Item_func_numpoints(arg1); +} +#endif + +Create_func_oct Create_func_oct::s_singleton; + +Item* +Create_func_oct::create(THD *thd, Item *arg1) +{ + Item *i10= new Item_int((int32) 10,2); + Item *i8= new Item_int((int32) 8,1); + return new Item_func_conv(arg1, i10, i8); } -Item *create_func_is_free_lock(Item* a) +Create_func_ord Create_func_ord::s_singleton; + +Item* +Create_func_ord::create(THD *thd, Item *arg1) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_free_lock(a); + return new Item_func_ord(arg1); } -Item *create_func_is_used_lock(Item* a) +#ifdef HAVE_SPATIAL +Create_func_overlaps Create_func_overlaps::s_singleton; + +Item* +Create_func_overlaps::create(THD *thd, Item *arg1, Item *arg2) { - current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); - return new Item_func_is_used_lock(a); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_OVERLAPS_FUNC); } +#endif + +Create_func_period_add Create_func_period_add::s_singleton; -Item *create_func_quote(Item* a) +Item* +Create_func_period_add::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_quote(a); + return new Item_func_period_add(arg1, arg2); } -Item *create_func_xml_extractvalue(Item *a, Item *b) +Create_func_period_diff Create_func_period_diff::s_singleton; + +Item* +Create_func_period_diff::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_xml_extractvalue(a, b); + return new Item_func_period_diff(arg1, arg2); } -Item *create_func_xml_update(Item *a, Item *b, Item *c) +Create_func_pi Create_func_pi::s_singleton; + +Item* +Create_func_pi::create(THD *thd) { - return new Item_func_xml_update(a, b, c); + return new Item_static_float_func("pi()", M_PI, 6, 8); } #ifdef HAVE_SPATIAL -Item *create_func_as_wkt(Item *a) +Create_func_pointn Create_func_pointn::s_singleton; + +Item* +Create_func_pointn::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_as_wkt(a); + return new Item_func_spatial_decomp_n(arg1, arg2, Item_func::SP_POINTN); } +#endif + +Create_func_pow Create_func_pow::s_singleton; -Item *create_func_as_wkb(Item *a) +Item* +Create_func_pow::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_as_wkb(a); + return new Item_func_pow(arg1, arg2); } -Item *create_func_srid(Item *a) +Create_func_quote Create_func_quote::s_singleton; + +Item* +Create_func_quote::create(THD *thd, Item *arg1) { - return new Item_func_srid(a); + return new Item_func_quote(arg1); } -Item *create_func_startpoint(Item *a) +Create_func_radians Create_func_radians::s_singleton; + +Item* +Create_func_radians::create(THD *thd, Item *arg1) { - return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT); + return new Item_func_units((char*) "radians", arg1, M_PI/180, 0.0); } -Item *create_func_endpoint(Item *a) +Create_func_rand Create_func_rand::s_singleton; + +Item* +Create_func_rand::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + 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); + break; + } + } + + return func; } -Item *create_func_exteriorring(Item *a) +Create_func_release_lock Create_func_release_lock::s_singleton; + +Item* +Create_func_release_lock::create(THD *thd, Item *arg1) { - return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_func_release_lock(arg1); } -Item *create_func_pointn(Item *a, Item *b) +Create_func_reverse Create_func_reverse::s_singleton; + +Item* +Create_func_reverse::create(THD *thd, Item *arg1) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN); + return new Item_func_reverse(arg1); } -Item *create_func_interiorringn(Item *a, Item *b) +Create_func_round Create_func_round::s_singleton; + +Item* +Create_func_round::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 1: + { + Item *param_1= item_list->pop(); + Item *i0 = new 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); + break; + } + } + + return func; } -Item *create_func_geometryn(Item *a, Item *b) +Create_func_row_count Create_func_row_count::s_singleton; + +Item* +Create_func_row_count::create(THD *thd) { - return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN); + thd->lex->safe_to_cache_query= 0; + return new Item_func_row_count(); } -Item *create_func_centroid(Item *a) +Create_func_rpad Create_func_rpad::s_singleton; + +Item* +Create_func_rpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_centroid(a); + return new Item_func_rpad(arg1, arg2, arg3); } -Item *create_func_envelope(Item *a) +Create_func_rtrim Create_func_rtrim::s_singleton; + +Item* +Create_func_rtrim::create(THD *thd, Item *arg1) { - return new Item_func_envelope(a); + return new Item_func_rtrim(arg1); } -Item *create_func_equals(Item *a, Item *b) +Create_func_sec_to_time Create_func_sec_to_time::s_singleton; + +Item* +Create_func_sec_to_time::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC); + return new Item_func_sec_to_time(arg1); } -Item *create_func_disjoint(Item *a, Item *b) +Create_func_sha Create_func_sha::s_singleton; + +Item* +Create_func_sha::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC); + return new Item_func_sha(arg1); } -Item *create_func_intersects(Item *a, Item *b) +Create_func_sign Create_func_sign::s_singleton; + +Item* +Create_func_sign::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC); + return new Item_func_sign(arg1); } -Item *create_func_touches(Item *a, Item *b) +Create_func_sin Create_func_sin::s_singleton; + +Item* +Create_func_sin::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC); + return new Item_func_sin(arg1); } -Item *create_func_crosses(Item *a, Item *b) +Create_func_sleep Create_func_sleep::s_singleton; + +Item* +Create_func_sleep::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC); + thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT); + return new Item_func_sleep(arg1); } -Item *create_func_within(Item *a, Item *b) +Create_func_soundex Create_func_soundex::s_singleton; + +Item* +Create_func_soundex::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC); + return new Item_func_soundex(arg1); } -Item *create_func_contains(Item *a, Item *b) +Create_func_space Create_func_space::s_singleton; + +Item* +Create_func_space::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC); + // TODO : investigate using the collation at parse 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); + } + + return new Item_func_repeat(sp, arg1); } -Item *create_func_overlaps(Item *a, Item *b) +Create_func_sqrt Create_func_sqrt::s_singleton; + +Item* +Create_func_sqrt::create(THD *thd, Item *arg1) { - return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC); + return new Item_func_sqrt(arg1); } -Item *create_func_isempty(Item *a) +#ifdef HAVE_SPATIAL +Create_func_srid Create_func_srid::s_singleton; + +Item* +Create_func_srid::create(THD *thd, Item *arg1) { - return new Item_func_isempty(a); + return new Item_func_srid(arg1); } +#endif -Item *create_func_issimple(Item *a) +#ifdef HAVE_SPATIAL +Create_func_startpoint Create_func_startpoint::s_singleton; + +Item* +Create_func_startpoint::create(THD *thd, Item *arg1) { - return new Item_func_issimple(a); + return new Item_func_spatial_decomp(arg1, Item_func::SP_STARTPOINT); } +#endif -Item *create_func_isclosed(Item *a) +Create_func_str_to_date Create_func_str_to_date::s_singleton; + +Item* +Create_func_str_to_date::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_isclosed(a); + return new Item_func_str_to_date(arg1, arg2); } -Item *create_func_geometry_type(Item *a) +Create_func_strcmp Create_func_strcmp::s_singleton; + +Item* +Create_func_strcmp::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_geometry_type(a); + return new Item_func_strcmp(arg1, arg2); } -Item *create_func_dimension(Item *a) +Create_func_substr_index Create_func_substr_index::s_singleton; + +Item* +Create_func_substr_index::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_dimension(a); + return new Item_func_substr_index(arg1, arg2, arg3); } -Item *create_func_x(Item *a) +Create_func_subtime Create_func_subtime::s_singleton; + +Item* +Create_func_subtime::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_x(a); + return new Item_func_add_time(arg1, arg2, 0, 1); } -Item *create_func_y(Item *a) +Create_func_tan Create_func_tan::s_singleton; + +Item* +Create_func_tan::create(THD *thd, Item *arg1) { - return new Item_func_y(a); + return new Item_func_tan(arg1); } -Item *create_func_numpoints(Item *a) +Create_func_time_format Create_func_time_format::s_singleton; + +Item* +Create_func_time_format::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_numpoints(a); + return new Item_func_date_format(arg1, arg2, 1); } -Item *create_func_numinteriorring(Item *a) +Create_func_time_to_sec Create_func_time_to_sec::s_singleton; + +Item* +Create_func_time_to_sec::create(THD *thd, Item *arg1) { - return new Item_func_numinteriorring(a); + return new Item_func_time_to_sec(arg1); } -Item *create_func_numgeometries(Item *a) +Create_func_timediff Create_func_timediff::s_singleton; + +Item* +Create_func_timediff::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_numgeometries(a); + return new Item_func_timediff(arg1, arg2); } -Item *create_func_area(Item *a) +Create_func_to_days Create_func_to_days::s_singleton; + +Item* +Create_func_to_days::create(THD *thd, Item *arg1) { - return new Item_func_area(a); + return new Item_func_to_days(arg1); } -Item *create_func_glength(Item *a) +#ifdef HAVE_SPATIAL +Create_func_touches Create_func_touches::s_singleton; + +Item* +Create_func_touches::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_glength(a); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_TOUCHES_FUNC); } +#endif -Item *create_func_point(Item *a, Item *b) +Create_func_ucase Create_func_ucase::s_singleton; + +Item* +Create_func_ucase::create(THD *thd, Item *arg1) { - return new Item_func_point(a, b); + return new Item_func_ucase(arg1); } -#endif /*HAVE_SPATIAL*/ -Item *create_func_crc32(Item* a) +Create_func_uncompress Create_func_uncompress::s_singleton; + +Item* +Create_func_uncompress::create(THD *thd, Item *arg1) { - return new Item_func_crc32(a); + return new Item_func_uncompress(arg1); } -Item *create_func_compress(Item* a) +Create_func_uncompressed_length Create_func_uncompressed_length::s_singleton; + +Item* +Create_func_uncompressed_length::create(THD *thd, Item *arg1) { - return new Item_func_compress(a); + return new Item_func_uncompressed_length(arg1); } -Item *create_func_uncompress(Item* a) +Create_func_unhex Create_func_unhex::s_singleton; + +Item* +Create_func_unhex::create(THD *thd, Item *arg1) { - return new Item_func_uncompress(a); + return new Item_func_unhex(arg1); } -Item *create_func_uncompressed_length(Item* a) +Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton; + +Item* +Create_func_unix_timestamp::create(THD *thd, LEX_STRING name, + List<Item> *item_list) { - return new Item_func_uncompressed_length(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + 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); + break; + } + } + + return func; } -Item *create_func_datediff(Item *a, Item *b) +Create_func_uuid Create_func_uuid::s_singleton; + +Item* +Create_func_uuid::create(THD *thd) +{ +#ifdef HAVE_ROW_BASED_REPLICATION + thd->lex->binlog_row_based_if_mixed= TRUE; +#endif + return new(thd->mem_root) Item_func_uuid(); +} + +Create_func_version Create_func_version::s_singleton; + +Item* +Create_func_version::create(THD *thd) { - return new Item_func_minus(new Item_func_to_days(a), - new Item_func_to_days(b)); + return new Item_static_string_func("version()", + server_version, + (uint) strlen(server_version), + system_charset_info, + DERIVATION_SYSCONST); } -Item *create_func_weekofyear(Item *a) +Create_func_weekday Create_func_weekday::s_singleton; + +Item* +Create_func_weekday::create(THD *thd, Item *arg1) { - return new Item_func_week(a, new Item_int((char*) "0", 3, 1)); + return new Item_func_weekday(arg1, 0); } -Item *create_func_makedate(Item* a,Item* b) +Create_func_weekofyear Create_func_weekofyear::s_singleton; + +Item* +Create_func_weekofyear::create(THD *thd, Item *arg1) { - return new Item_func_makedate(a, b); + return new Item_func_week(arg1, new Item_int((char*) "0", 3, 1)); } -Item *create_func_addtime(Item* a,Item* b) +#ifdef HAVE_SPATIAL +Create_func_within Create_func_within::s_singleton; + +Item* +Create_func_within::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_add_time(a, b, 0, 0); + return new Item_func_spatial_rel(arg1, arg2, Item_func::SP_WITHIN_FUNC); } +#endif + +#ifdef HAVE_SPATIAL +Create_func_x Create_func_x::s_singleton; -Item *create_func_subtime(Item* a,Item* b) +Item* +Create_func_x::create(THD *thd, Item *arg1) { - return new Item_func_add_time(a, b, 0, 1); + return new Item_func_x(arg1); } +#endif + +Create_func_xml_extractvalue Create_func_xml_extractvalue::s_singleton; -Item *create_func_timediff(Item* a,Item* b) +Item* +Create_func_xml_extractvalue::create(THD *thd, Item *arg1, Item *arg2) { - return new Item_func_timediff(a, b); + return new Item_func_xml_extractvalue(arg1, arg2); } -Item *create_func_maketime(Item* a,Item* b,Item* c) +Create_func_xml_update Create_func_xml_update::s_singleton; + +Item* +Create_func_xml_update::create(THD *thd, Item *arg1, Item *arg2, Item *arg3) { - return new Item_func_maketime(a, b, c); + return new Item_func_xml_update(arg1, arg2, arg3); } -Item *create_func_str_to_date(Item* a,Item* b) +#ifdef HAVE_SPATIAL +Create_func_y Create_func_y::s_singleton; + +Item* +Create_func_y::create(THD *thd, Item *arg1) { - return new Item_func_str_to_date(a, b); + return new Item_func_y(arg1); } +#endif + +Create_func_year_week Create_func_year_week::s_singleton; -Item *create_func_last_day(Item *a) +Item* +Create_func_year_week::create(THD *thd, LEX_STRING name, List<Item> *item_list) { - return new Item_func_last_day(a); + Item *func= NULL; + int arg_count= 0; + + if (item_list != NULL) + { + arg_count= item_list->elements; + } + + switch (arg_count) + { + case 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); + break; + } + } + + return func; } + +struct sql_func_registry +{ + LEX_STRING name; + Create_func *builder; +}; + +#define BUILDER(F) & F::s_singleton + +#ifdef HAVE_SPATIAL + #define GEOM_BUILDER(F) & F::s_singleton +#else + #define GEOM_BUILDER(F) & Create_func_no_geom::s_singleton +#endif + +/* + MySQL built-in functions. + MAINTAINER: + - Keep sorted for human lookup. At runtime, a hash table is used. + - do **NOT** conditionaly (#ifdef, #ifndef) define a function *NAME*: + doing so will cause user code that works against a --without-XYZ binary + to fail with name collisions against a --with-XYZ binary. + Use something similar to GEOM_BUILDER instead. + - keep 1 line per entry, it makes grep | sort easier +*/ +static sql_func_registry func_array[] = +{ + { C_STRING_WITH_LEN("ABS"), BUILDER(Create_func_abs)}, + { C_STRING_WITH_LEN("ACOS"), BUILDER(Create_func_acos)}, + { C_STRING_WITH_LEN("ADDTIME"), BUILDER(Create_func_addtime)}, + { C_STRING_WITH_LEN("AES_DECRYPT"), BUILDER(Create_func_aes_decrypt)}, + { C_STRING_WITH_LEN("AES_ENCRYPT"), BUILDER(Create_func_aes_encrypt)}, + { C_STRING_WITH_LEN("AREA"), GEOM_BUILDER(Create_func_area)}, + { C_STRING_WITH_LEN("ASBINARY"), GEOM_BUILDER(Create_func_as_wkb)}, + { C_STRING_WITH_LEN("ASIN"), BUILDER(Create_func_asin)}, + { C_STRING_WITH_LEN("ASTEXT"), GEOM_BUILDER(Create_func_as_wkt)}, + { C_STRING_WITH_LEN("ASWKB"), GEOM_BUILDER(Create_func_as_wkb)}, + { C_STRING_WITH_LEN("ASWKT"), GEOM_BUILDER(Create_func_as_wkt)}, + { C_STRING_WITH_LEN("ATAN"), BUILDER(Create_func_atan)}, + { C_STRING_WITH_LEN("ATAN2"), BUILDER(Create_func_atan)}, + { C_STRING_WITH_LEN("BENCHMARK"), BUILDER(Create_func_benchmark)}, + { C_STRING_WITH_LEN("BIN"), BUILDER(Create_func_bin)}, + { C_STRING_WITH_LEN("BIT_COUNT"), BUILDER(Create_func_bit_count)}, + { C_STRING_WITH_LEN("BIT_LENGTH"), BUILDER(Create_func_bit_length)}, + { C_STRING_WITH_LEN("CEIL"), BUILDER(Create_func_ceiling)}, + { C_STRING_WITH_LEN("CEILING"), BUILDER(Create_func_ceiling)}, + { C_STRING_WITH_LEN("CENTROID"), GEOM_BUILDER(Create_func_centroid)}, + { C_STRING_WITH_LEN("CHARACTER_LENGTH"), BUILDER(Create_func_char_length)}, + { C_STRING_WITH_LEN("CHAR_LENGTH"), BUILDER(Create_func_char_length)}, + { C_STRING_WITH_LEN("COERCIBILITY"), BUILDER(Create_func_coercibility)}, + { C_STRING_WITH_LEN("COMPRESS"), BUILDER(Create_func_compress)}, + { C_STRING_WITH_LEN("CONCAT"), BUILDER(Create_func_concat)}, + { C_STRING_WITH_LEN("CONCAT_WS"), BUILDER(Create_func_concat_ws)}, + { C_STRING_WITH_LEN("CONNECTION_ID"), BUILDER(Create_func_connection_id)}, + { C_STRING_WITH_LEN("CONV"), BUILDER(Create_func_conv)}, + { C_STRING_WITH_LEN("CONVERT_TZ"), BUILDER(Create_func_convert_tz)}, + { C_STRING_WITH_LEN("COS"), BUILDER(Create_func_cos)}, + { C_STRING_WITH_LEN("COT"), BUILDER(Create_func_cot)}, + { C_STRING_WITH_LEN("CRC32"), BUILDER(Create_func_crc32)}, + { C_STRING_WITH_LEN("CROSSES"), GEOM_BUILDER(Create_func_crosses)}, + { C_STRING_WITH_LEN("DATEDIFF"), BUILDER(Create_func_datediff)}, + { C_STRING_WITH_LEN("DATE_FORMAT"), BUILDER(Create_func_date_format)}, + { C_STRING_WITH_LEN("DAYNAME"), BUILDER(Create_func_dayname)}, + { C_STRING_WITH_LEN("DAYOFMONTH"), BUILDER(Create_func_dayofmonth)}, + { C_STRING_WITH_LEN("DAYOFWEEK"), BUILDER(Create_func_dayofweek)}, + { C_STRING_WITH_LEN("DAYOFYEAR"), BUILDER(Create_func_dayofyear)}, + { C_STRING_WITH_LEN("DECODE"), BUILDER(Create_func_decode)}, + { C_STRING_WITH_LEN("DEGREES"), BUILDER(Create_func_degrees)}, + { C_STRING_WITH_LEN("DES_DECRYPT"), BUILDER(Create_func_des_decrypt)}, + { C_STRING_WITH_LEN("DES_ENCRYPT"), BUILDER(Create_func_des_encrypt)}, + { C_STRING_WITH_LEN("DIMENSION"), GEOM_BUILDER(Create_func_dimension)}, + { C_STRING_WITH_LEN("DISJOINT"), GEOM_BUILDER(Create_func_disjoint)}, + { C_STRING_WITH_LEN("ELT"), BUILDER(Create_func_elt)}, + { C_STRING_WITH_LEN("ENCODE"), BUILDER(Create_func_encode)}, + { C_STRING_WITH_LEN("ENCRYPT"), BUILDER(Create_func_encrypt)}, + { C_STRING_WITH_LEN("ENDPOINT"), GEOM_BUILDER(Create_func_endpoint)}, + { C_STRING_WITH_LEN("ENVELOPE"), GEOM_BUILDER(Create_func_envelope)}, + { C_STRING_WITH_LEN("EQUALS"), GEOM_BUILDER(Create_func_equals)}, + { C_STRING_WITH_LEN("EXP"), BUILDER(Create_func_exp)}, + { C_STRING_WITH_LEN("EXPORT_SET"), BUILDER(Create_func_export_set)}, + { C_STRING_WITH_LEN("EXTERIORRING"), GEOM_BUILDER(Create_func_exteriorring)}, + { C_STRING_WITH_LEN("EXTRACTVALUE"), BUILDER(Create_func_xml_extractvalue)}, + { C_STRING_WITH_LEN("FIELD"), BUILDER(Create_func_field)}, + { C_STRING_WITH_LEN("FIND_IN_SET"), BUILDER(Create_func_find_in_set)}, + { C_STRING_WITH_LEN("FLOOR"), BUILDER(Create_func_floor)}, + { C_STRING_WITH_LEN("FORMAT"), BUILDER(Create_func_format)}, + { C_STRING_WITH_LEN("FOUND_ROWS"), BUILDER(Create_func_found_rows)}, + { C_STRING_WITH_LEN("FROM_DAYS"), BUILDER(Create_func_from_days)}, + { C_STRING_WITH_LEN("FROM_UNIXTIME"), BUILDER(Create_func_from_unixtime)}, + { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMCOLLFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMETRYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GEOMETRYN"), GEOM_BUILDER(Create_func_geometryn)}, + { C_STRING_WITH_LEN("GEOMETRYTYPE"), GEOM_BUILDER(Create_func_geometry_type)}, + { C_STRING_WITH_LEN("GEOMFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("GEOMFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("GET_LOCK"), BUILDER(Create_func_get_lock)}, + { C_STRING_WITH_LEN("GLENGTH"), GEOM_BUILDER(Create_func_glength)}, + { C_STRING_WITH_LEN("GREATEST"), BUILDER(Create_func_greatest)}, + { C_STRING_WITH_LEN("HEX"), BUILDER(Create_func_hex)}, + { C_STRING_WITH_LEN("IFNULL"), BUILDER(Create_func_ifnull)}, + { C_STRING_WITH_LEN("INET_ATON"), BUILDER(Create_func_inet_aton)}, + { C_STRING_WITH_LEN("INET_NTOA"), BUILDER(Create_func_inet_ntoa)}, + { C_STRING_WITH_LEN("INSTR"), BUILDER(Create_func_instr)}, + { C_STRING_WITH_LEN("INTERIORRINGN"), GEOM_BUILDER(Create_func_interiorringn)}, + { C_STRING_WITH_LEN("INTERSECTS"), GEOM_BUILDER(Create_func_intersects)}, + { C_STRING_WITH_LEN("ISCLOSED"), GEOM_BUILDER(Create_func_isclosed)}, + { C_STRING_WITH_LEN("ISEMPTY"), GEOM_BUILDER(Create_func_isempty)}, + { C_STRING_WITH_LEN("ISNULL"), BUILDER(Create_func_isnull)}, + { C_STRING_WITH_LEN("ISSIMPLE"), GEOM_BUILDER(Create_func_issimple)}, + { C_STRING_WITH_LEN("IS_FREE_LOCK"), BUILDER(Create_func_is_free_lock)}, + { C_STRING_WITH_LEN("IS_USED_LOCK"), BUILDER(Create_func_is_used_lock)}, + { C_STRING_WITH_LEN("LAST_DAY"), BUILDER(Create_func_last_day)}, + { C_STRING_WITH_LEN("LAST_INSERT_ID"), BUILDER(Create_func_last_insert_id)}, + { C_STRING_WITH_LEN("LCASE"), BUILDER(Create_func_lcase)}, + { C_STRING_WITH_LEN("LEAST"), BUILDER(Create_func_least)}, + { C_STRING_WITH_LEN("LENGTH"), BUILDER(Create_func_length)}, + { C_STRING_WITH_LEN("LINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("LINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("LINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("LINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("LN"), BUILDER(Create_func_ln)}, + { C_STRING_WITH_LEN("LOAD_FILE"), BUILDER(Create_func_load_file)}, + { C_STRING_WITH_LEN("LOCATE"), BUILDER(Create_func_locate)}, + { C_STRING_WITH_LEN("LOG"), BUILDER(Create_func_log)}, + { C_STRING_WITH_LEN("LOG10"), BUILDER(Create_func_log10)}, + { C_STRING_WITH_LEN("LOG2"), BUILDER(Create_func_log2)}, + { C_STRING_WITH_LEN("LOWER"), BUILDER(Create_func_lcase)}, + { C_STRING_WITH_LEN("LPAD"), BUILDER(Create_func_lpad)}, + { C_STRING_WITH_LEN("LTRIM"), BUILDER(Create_func_ltrim)}, + { C_STRING_WITH_LEN("MAKEDATE"), BUILDER(Create_func_makedate)}, + { C_STRING_WITH_LEN("MAKETIME"), BUILDER(Create_func_maketime)}, + { C_STRING_WITH_LEN("MAKE_SET"), BUILDER(Create_func_make_set)}, + { C_STRING_WITH_LEN("MASTER_POS_WAIT"), BUILDER(Create_func_master_pos_wait)}, + { C_STRING_WITH_LEN("MBRCONTAINS"), GEOM_BUILDER(Create_func_contains)}, + { C_STRING_WITH_LEN("MD5"), BUILDER(Create_func_md5)}, + { C_STRING_WITH_LEN("MLINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MLINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MONTHNAME"), BUILDER(Create_func_monthname)}, + { C_STRING_WITH_LEN("MPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MPOLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MPOLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTIPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("NAME_CONST"), BUILDER(Create_func_name_const)}, + { C_STRING_WITH_LEN("NULLIF"), BUILDER(Create_func_nullif)}, + { C_STRING_WITH_LEN("NUMGEOMETRIES"), GEOM_BUILDER(Create_func_numgeometries)}, + { C_STRING_WITH_LEN("NUMINTERIORRINGS"), GEOM_BUILDER(Create_func_numinteriorring)}, + { C_STRING_WITH_LEN("NUMPOINTS"), GEOM_BUILDER(Create_func_numpoints)}, + { C_STRING_WITH_LEN("OCT"), BUILDER(Create_func_oct)}, + { C_STRING_WITH_LEN("OCTET_LENGTH"), BUILDER(Create_func_length)}, + { C_STRING_WITH_LEN("ORD"), BUILDER(Create_func_ord)}, + { C_STRING_WITH_LEN("OVERLAPS"), GEOM_BUILDER(Create_func_overlaps)}, + { C_STRING_WITH_LEN("PERIOD_ADD"), BUILDER(Create_func_period_add)}, + { C_STRING_WITH_LEN("PERIOD_DIFF"), BUILDER(Create_func_period_diff)}, + { C_STRING_WITH_LEN("PI"), BUILDER(Create_func_pi)}, + { C_STRING_WITH_LEN("POINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POINTN"), GEOM_BUILDER(Create_func_pointn)}, + { C_STRING_WITH_LEN("POLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)}, + { C_STRING_WITH_LEN("POLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)}, + { C_STRING_WITH_LEN("POW"), BUILDER(Create_func_pow)}, + { C_STRING_WITH_LEN("POWER"), BUILDER(Create_func_pow)}, + { C_STRING_WITH_LEN("QUOTE"), BUILDER(Create_func_quote)}, + { C_STRING_WITH_LEN("RADIANS"), BUILDER(Create_func_radians)}, + { C_STRING_WITH_LEN("RAND"), BUILDER(Create_func_rand)}, + { C_STRING_WITH_LEN("RELEASE_LOCK"), BUILDER(Create_func_release_lock)}, + { C_STRING_WITH_LEN("REVERSE"), BUILDER(Create_func_reverse)}, + { C_STRING_WITH_LEN("ROUND"), BUILDER(Create_func_round)}, + { C_STRING_WITH_LEN("ROW_COUNT"), BUILDER(Create_func_row_count)}, + { C_STRING_WITH_LEN("RPAD"), BUILDER(Create_func_rpad)}, + { C_STRING_WITH_LEN("RTRIM"), BUILDER(Create_func_rtrim)}, + { C_STRING_WITH_LEN("SEC_TO_TIME"), BUILDER(Create_func_sec_to_time)}, + { C_STRING_WITH_LEN("SHA"), BUILDER(Create_func_sha)}, + { C_STRING_WITH_LEN("SHA1"), BUILDER(Create_func_sha)}, + { C_STRING_WITH_LEN("SIGN"), BUILDER(Create_func_sign)}, + { C_STRING_WITH_LEN("SIN"), BUILDER(Create_func_sin)}, + { C_STRING_WITH_LEN("SLEEP"), BUILDER(Create_func_sleep)}, + { C_STRING_WITH_LEN("SOUNDEX"), BUILDER(Create_func_soundex)}, + { C_STRING_WITH_LEN("SPACE"), BUILDER(Create_func_space)}, + { C_STRING_WITH_LEN("SQRT"), BUILDER(Create_func_sqrt)}, + { C_STRING_WITH_LEN("SRID"), GEOM_BUILDER(Create_func_srid)}, + { C_STRING_WITH_LEN("STARTPOINT"), GEOM_BUILDER(Create_func_startpoint)}, + { C_STRING_WITH_LEN("STRCMP"), BUILDER(Create_func_strcmp)}, + { C_STRING_WITH_LEN("STR_TO_DATE"), BUILDER(Create_func_str_to_date)}, + { C_STRING_WITH_LEN("SUBSTRING_INDEX"), BUILDER(Create_func_substr_index)}, + { C_STRING_WITH_LEN("SUBTIME"), BUILDER(Create_func_subtime)}, + { C_STRING_WITH_LEN("TAN"), BUILDER(Create_func_tan)}, + { C_STRING_WITH_LEN("TIMEDIFF"), BUILDER(Create_func_timediff)}, + { C_STRING_WITH_LEN("TIME_FORMAT"), BUILDER(Create_func_time_format)}, + { C_STRING_WITH_LEN("TIME_TO_SEC"), BUILDER(Create_func_time_to_sec)}, + { C_STRING_WITH_LEN("TOUCHES"), GEOM_BUILDER(Create_func_touches)}, + { C_STRING_WITH_LEN("TO_DAYS"), BUILDER(Create_func_to_days)}, + { C_STRING_WITH_LEN("UCASE"), BUILDER(Create_func_ucase)}, + { C_STRING_WITH_LEN("UNCOMPRESS"), BUILDER(Create_func_uncompress)}, + { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH"), BUILDER(Create_func_uncompressed_length)}, + { C_STRING_WITH_LEN("UNHEX"), BUILDER(Create_func_unhex)}, + { C_STRING_WITH_LEN("UNIX_TIMESTAMP"), BUILDER(Create_func_unix_timestamp)}, + { C_STRING_WITH_LEN("UPDATEXML"), BUILDER(Create_func_xml_update)}, + { C_STRING_WITH_LEN("UPPER"), BUILDER(Create_func_ucase)}, + { C_STRING_WITH_LEN("UUID"), BUILDER(Create_func_uuid)}, + { C_STRING_WITH_LEN("VERSION"), BUILDER(Create_func_version)}, + { C_STRING_WITH_LEN("WEEKDAY"), BUILDER(Create_func_weekday)}, + { C_STRING_WITH_LEN("WEEKOFYEAR"), BUILDER(Create_func_weekofyear)}, + { C_STRING_WITH_LEN("WITHIN"), GEOM_BUILDER(Create_func_within)}, + { C_STRING_WITH_LEN("X"), GEOM_BUILDER(Create_func_x)}, + { C_STRING_WITH_LEN("Y"), GEOM_BUILDER(Create_func_y)}, + { C_STRING_WITH_LEN("YEARWEEK"), BUILDER(Create_func_year_week)}, + + { {0, 0}, NULL} +}; + +static HASH 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, + array_elements(func_array), + 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; +} + +/* + 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() +{ + DBUG_ENTER("item_create_cleanup"); + hash_free(& g_builtin_functions_hash); + DBUG_VOID_RETURN; +} + +Create_func * find_sql_function_builder(THD *thd, LEX_STRING name) +{ + 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; +} + +Create_qfunc * find_sp_function_builder(THD *thd) +{ + return & Create_sp_func::s_singleton; +} + +Item* +create_func_cast(Item *a, Cast_target cast_type, int len, int dec, + CHARSET_INFO *cs) +{ + Item *res; + int tmp_len; + LINT_INIT(res); + + switch (cast_type) + { + case ITEM_CAST_BINARY: res= new Item_func_binary(a); break; + case ITEM_CAST_SIGNED_INT: res= new Item_func_signed(a); break; + case ITEM_CAST_UNSIGNED_INT: res= new Item_func_unsigned(a); break; + case ITEM_CAST_DATE: res= new Item_date_typecast(a); break; + case ITEM_CAST_TIME: res= new Item_time_typecast(a); break; + case ITEM_CAST_DATETIME: res= new Item_datetime_typecast(a); break; + case ITEM_CAST_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: + { + CHARSET_INFO *real_cs= (cs ? cs + : current_thd->variables.collation_connection); + res= new Item_char_typecast(a, len, real_cs); + break; + } + default: + { + DBUG_ASSERT(0); + res= 0; + break; + } + } + return res; +} + --- 1.45/sql/item_create.h 2006-10-17 14:54:51 -07:00 +++ 1.46/sql/item_create.h 2006-10-17 14:54:51 -07:00 @@ -14,148 +14,145 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* Functions to create an item. Used by lex.h */ +/* Functions to create an item. Used by sql/sql_yacc.yy */ + +#ifndef ITEM_CREATE_H +#define ITEM_CREATE_H + +/** + Public function builder interface. + The parser (sql/sql_yacc.yy) uses a factory / builder pattern to + construct an <code>Item</code> object for each function call. + All the concrete function builders implements this interface, + either directly or indirectly with some adapter helpers. + Keeping the function creation separated from the bison grammar allows + to simplify the parser, and avoid the need to introduce a new token + for each function, which has undesirable side effects in the grammar. +*/ +class Create_func +{ +public: + /** + The builder create method. + Given the function name and list or arguments, this method creates + an <code>Item</code> that represents the function call. + In case or errors, a NULL item is returned, and an error is reported. + Note that the <code>thd</code> object may be modified by the builder. + In particular, the following members/methods can be set/called, + depending on the function called and the function possible side effects. + <ul> + <li><code>thd->lex->binlog_row_based_if_mixed</code></li> + <li><code>thd->lex->current_context()</code></li> + <li><code>thd->lex->safe_to_cache_query</code></li> + <li><code>thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT)</code></li> + <li><code>thd->lex->uncacheable(UNCACHEABLE_RAND)</code></li> + <li><code>thd->lex->add_time_zone_tables_to_query_tables(thd)</code></li> + </ul> + @param thd The current thread + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call, or NULL + */ + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list) = 0; + +protected: + /** Constructor */ + Create_func() {} + /** Destructor */ + virtual ~Create_func() {} +}; + +/** + Function builder for qualified functions. + This builder is used with functions call using a qualified function name + syntax, as in <code>db.func(expr, expr, ...)</code>. +*/ +class Create_qfunc : public Create_func +{ +public: + /** + The builder create method, for unqualified functions. + This builder will use the current database for the database name. + @param thd The current thread + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + The builder create method, for qualified functions. + @param thd The current thread + @param db The database name + @param name The function name + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name, + List<Item> *item_list) = 0; + +protected: + /** Constructor. */ + Create_qfunc() {} + /** Destructor. */ + virtual ~Create_qfunc() {} +}; + +/** + Find the native function builder associated with a given function name. + @param thd The current thread + @param name The native function name + @return The native function builder associated with the name, or NULL +*/ +extern Create_func * find_sql_function_builder(THD *thd, LEX_STRING name); + +/** + Find the function builder for stored procedures. + @param thd The current thread + @return A function builder for stored procedures +*/ +extern Create_qfunc * find_sp_function_builder(THD *thd); + +#ifdef HAVE_DLOPEN +/** + Function builder for User Defined Functions. +*/ +class Create_udf_func : public Create_func +{ +public: + virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list); + + /** + The builder create method, for User Defined Functions. + @param thd The current thread + @param fct The User Defined Function metadata + @param item_list The list of arguments to the function, can be NULL + @return An item representing the parsed function call + */ + Item* create(THD *thd, udf_func *fct, List<Item> *item_list); + + /** Singleton. */ + static Create_udf_func s_singleton; + +protected: + /** Constructor. */ + Create_udf_func() {} + /** Destructor. */ + virtual ~Create_udf_func() {} +}; +#endif + +/** + Builder for cast expressions. + @param a The item to cast + @param cast_type the type casted into + @param len TODO + @param dec TODO + @param cs The character set +*/ +Item* +create_func_cast(Item *a, Cast_target cast_type, int len, int dec, + CHARSET_INFO *cs); + +#endif -Item *create_func_abs(Item* a); -Item *create_func_acos(Item* a); -Item *create_func_aes_encrypt(Item* a, Item* b); -Item *create_func_aes_decrypt(Item* a, Item* b); -Item *create_func_ascii(Item* a); -Item *create_func_asin(Item* a); -Item *create_func_bin(Item* a); -Item *create_func_bit_count(Item* a); -Item *create_func_bit_length(Item* a); -Item *create_func_coercibility(Item* a); -Item *create_func_ceiling(Item* a); -Item *create_func_char_length(Item* a); -Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec, - CHARSET_INFO *cs); -Item *create_func_connection_id(void); -Item *create_func_conv(Item* a, Item *b, Item *c); -Item *create_func_cos(Item* a); -Item *create_func_cot(Item* a); -Item *create_func_crc32(Item* a); -Item *create_func_date_format(Item* a,Item *b); -Item *create_func_dayname(Item* a); -Item *create_func_dayofmonth(Item* a); -Item *create_func_dayofweek(Item* a); -Item *create_func_dayofyear(Item* a); -Item *create_func_degrees(Item *); -Item *create_func_exp(Item* a); -Item *create_func_find_in_set(Item* a, Item *b); -Item *create_func_floor(Item* a); -Item *create_func_found_rows(void); -Item *create_func_from_days(Item* a); -Item *create_func_get_lock(Item* a, Item *b); -Item *create_func_hex(Item *a); -Item *create_func_inet_aton(Item* a); -Item *create_func_inet_ntoa(Item* a); - -Item *create_func_ifnull(Item* a, Item *b); -Item *create_func_instr(Item* a, Item *b); -Item *create_func_isnull(Item* a); -Item *create_func_lcase(Item* a); -Item *create_func_length(Item* a); -Item *create_func_ln(Item* a); -Item *create_func_locate(Item* a, Item *b); -Item *create_func_log2(Item* a); -Item *create_func_log10(Item* a); -Item *create_func_lpad(Item* a, Item *b, Item *c); -Item *create_func_ltrim(Item* a); -Item *create_func_md5(Item* a); -Item *create_func_mod(Item* a, Item *b); -Item *create_func_monthname(Item* a); -Item *create_func_name_const(Item *a, Item *b); -Item *create_func_nullif(Item* a, Item *b); -Item *create_func_oct(Item *); -Item *create_func_ord(Item* a); -Item *create_func_period_add(Item* a, Item *b); -Item *create_func_period_diff(Item* a, Item *b); -Item *create_func_pi(void); -Item *create_func_pow(Item* a, Item *b); -Item *create_func_radians(Item *a); -Item *create_func_release_lock(Item* a); -Item *create_func_repeat(Item* a, Item *b); -Item *create_func_reverse(Item* a); -Item *create_func_rpad(Item* a, Item *b, Item *c); -Item *create_func_rtrim(Item* a); -Item *create_func_sec_to_time(Item* a); -Item *create_func_sign(Item* a); -Item *create_func_sin(Item* a); -Item *create_func_sha(Item* a); -Item *create_func_sleep(Item* a); -Item *create_func_soundex(Item* a); -Item *create_func_space(Item *); -Item *create_func_sqrt(Item* a); -Item *create_func_strcmp(Item* a, Item *b); -Item *create_func_tan(Item* a); -Item *create_func_time_format(Item *a, Item *b); -Item *create_func_time_to_sec(Item* a); -Item *create_func_to_days(Item* a); -Item *create_func_ucase(Item* a); -Item *create_func_unhex(Item* a); -Item *create_func_uuid(void); -Item *create_func_version(void); -Item *create_func_weekday(Item* a); -Item *create_load_file(Item* a); -Item *create_func_is_free_lock(Item* a); -Item *create_func_is_used_lock(Item* a); -Item *create_func_quote(Item* a); -Item *create_func_xml_extractvalue(Item *a, Item *b); -Item *create_func_xml_update(Item *a, Item *b, Item *c); -#ifdef HAVE_SPATIAL - -Item *create_func_geometry_from_text(Item *a); -Item *create_func_as_wkt(Item *a); -Item *create_func_as_wkb(Item *a); -Item *create_func_srid(Item *a); -Item *create_func_startpoint(Item *a); -Item *create_func_endpoint(Item *a); -Item *create_func_exteriorring(Item *a); -Item *create_func_centroid(Item *a); -Item *create_func_envelope(Item *a); -Item *create_func_pointn(Item *a, Item *b); -Item *create_func_interiorringn(Item *a, Item *b); -Item *create_func_geometryn(Item *a, Item *b); - -Item *create_func_equals(Item *a, Item *b); -Item *create_func_disjoint(Item *a, Item *b); -Item *create_func_intersects(Item *a, Item *b); -Item *create_func_touches(Item *a, Item *b); -Item *create_func_crosses(Item *a, Item *b); -Item *create_func_within(Item *a, Item *b); -Item *create_func_contains(Item *a, Item *b); -Item *create_func_overlaps(Item *a, Item *b); - -Item *create_func_isempty(Item *a); -Item *create_func_issimple(Item *a); -Item *create_func_isclosed(Item *a); - -Item *create_func_geometry_type(Item *a); -Item *create_func_dimension(Item *a); -Item *create_func_x(Item *a); -Item *create_func_y(Item *a); -Item *create_func_area(Item *a); -Item *create_func_glength(Item *a); - -Item *create_func_numpoints(Item *a); -Item *create_func_numinteriorring(Item *a); -Item *create_func_numgeometries(Item *a); - -Item *create_func_point(Item *a, Item *b); - -#endif /*HAVE_SPATIAL*/ - -Item *create_func_compress(Item *a); -Item *create_func_uncompress(Item *a); -Item *create_func_uncompressed_length(Item *a); - -Item *create_func_datediff(Item *a, Item *b); -Item *create_func_weekofyear(Item *a); -Item *create_func_makedate(Item* a,Item* b); -Item *create_func_addtime(Item* a,Item* b); -Item *create_func_subtime(Item* a,Item* b); -Item *create_func_timediff(Item* a,Item* b); -Item *create_func_maketime(Item* a,Item* b,Item* c); -Item *create_func_str_to_date(Item* a,Item* b); -Item *create_func_last_day(Item *a); --- 1.163/sql/lex.h 2006-10-17 14:54:51 -07:00 +++ 1.164/sql/lex.h 2006-10-17 14:54:51 -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,37 @@ 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)}, + { "SESSION_USER", SYM(USER)}, { "STD", SYM(STD_SYM)}, { "STDDEV", SYM(STD_SYM)}, { "STDDEV_POP", SYM(STD_SYM)}, { "STDDEV_SAMP", SYM(STDDEV_SAMP_SYM)}, - { "STR_TO_DATE", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_str_to_date)}, - { "STRCMP", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_strcmp)}, + { "SUBDATE", SYM(SUBDATE_SYM)}, { "SUBSTR", SYM(SUBSTRING)}, { "SUBSTRING", SYM(SUBSTRING)}, - { "SUBSTRING_INDEX", SYM(SUBSTRING_INDEX)}, - { "SUBTIME", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_subtime)}, { "SUM", SYM(SUM_SYM)}, { "SYSDATE", SYM(SYSDATE)}, - { "SYSTEM_USER", SYM(USER)}, - { "TAN", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_tan)}, - { "TIME_FORMAT", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_time_format)}, - { "TIME_TO_SEC", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_time_to_sec)}, - { "TIMEDIFF", F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_timediff)}, - { "TO_DAYS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_to_days)}, - { "TOUCHES", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)}, + { "SYSTEM_USER", SYM(USER)}, { "TRIM", SYM(TRIM)}, - { "UCASE", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)}, - { "UNCOMPRESS", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompress)}, - { "UNCOMPRESSED_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompressed_length)}, - { "UNHEX", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_unhex)}, { "UNIQUE_USERS", SYM(UNIQUE_USERS)}, - { "UNIX_TIMESTAMP", SYM(UNIX_TIMESTAMP)}, - { "UPDATEXML", F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_xml_update)}, - { "UPPER", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)}, - { "UUID", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_uuid)}, { "VARIANCE", SYM(VARIANCE_SYM)}, - { "VAR_POP", SYM(VARIANCE_SYM)}, { "VAR_SAMP", SYM(VAR_SAMP_SYM)}, - { "VERSION", F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)}, - { "WEEKDAY", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekday)}, - { "WEEKOFYEAR", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekofyear)}, - { "WITHIN", F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)}, - { "X", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_x)}, - { "Y", F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_y)}, - { "YEARWEEK", SYM(YEARWEEK)} }; --- 1.7/sql/lex_symbol.h 2006-10-17 14:54:51 -07:00 +++ 1.8/sql/lex_symbol.h 2006-10-17 14:54:51 -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-10-17 14:54:51 -07:00 +++ 1.434/sql/mysql_priv.h 2006-10-17 14:54:51 -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-10-17 14:54:51 -07:00 +++ 1.582/sql/mysqld.cc 2006-10-17 14:54:51 -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-10-17 14:54:51 -07:00 +++ 1.497/sql/sql_yacc.yy 2006-10-17 14:54:51 -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, @@ -6056,7 +6048,6 @@ simple_expr: } | '@' '@' opt_var_ident_type ident_or_text opt_component { - if ($4.str && $5.str && check_reserved_words(&$4)) { yyerror(ER(ER_SYNTAX_ERROR)); @@ -6091,7 +6082,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 +6122,130 @@ 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 ')' + | 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 +6254,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 +6268,59 @@ 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; + } + | IF '(' expr ',' expr ',' expr ')' + { $$= new Item_func_if($3,$5,$7); } + | 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 +6328,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 +6353,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 +6361,108 @@ 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; + + /* + 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) + { + item= builder->create(thd, $1, $4); + } + 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--; + } + + item= Create_udf_func::s_singleton.create(thd, udf, $4); + } + else +#endif + { + builder= find_sp_function_builder(thd); + DBUG_ASSERT(builder); + item= builder->create(thd, $1, $4); + } + } + + if (! item) + { + YYABORT; + } + $$ = item; + } + | ident '.' ident '(' udf_expr_list ')' + { + THD *thd= YYTHD; + Create_qfunc *builder; + Item *item= NULL; + + builder= find_sp_function_builder(thd); + DBUG_ASSERT(builder); + item= builder->create(thd, $1, $3, $5); + + if (! item) + { + YYABORT; + } + $$ = item; + } + ; fulltext_options: opt_natural_language_mode opt_query_expansion @@ -6836,6 +6632,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 +9235,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-10-17 14:54:51 -07:00 +++ 1.121/sql/share/errmsg.txt 2006-10-17 14:54:51 -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-10-17 14:54:51 -07:00 +++ 1.175/mysql-test/r/view.result 2006-10-17 14:54:51 -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-10-17 14:54:51 -07:00 +++ 1.156/mysql-test/t/view.test 2006-10-17 14:54:51 -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 --- +++ BitKeeper/deleted/.del-Doxyfile 06/10/17 10:32:51 # Doxyfile 1.4.7 #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- PROJECT_NAME = "MySQL 5.1" PROJECT_NUMBER = OUTPUT_DIRECTORY = ./generated/ CREATE_SUBDIRS = NO OUTPUT_LANGUAGE = English USE_WINDOWS_ENCODING = NO BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = YES STRIP_FROM_PATH = /home/jpipes/apps/doxygen-1.4.7/bin/ STRIP_FROM_INC_PATH = SHORT_NAMES = NO JAVADOC_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO DETAILS_AT_TOP = NO INHERIT_DOCS = YES SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 8 ALIASES = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO BUILTIN_STL_SUPPORT = NO DISTRIBUTE_GROUP_DOC = NO SUBGROUPING = YES #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- EXTRACT_ALL = YES EXTRACT_PRIVATE = YES EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_METHODS = NO HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_CLASSES = NO HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = YES CASE_SENSE_NAMES = YES HIDE_SCOPE_NAMES = NO SHOW_INCLUDE_FILES = YES INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_BY_SCOPE_NAME = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_DIRECTORIES = NO FILE_VERSION_FILTER = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES WARN_NO_PARAMDOC = YES WARN_FORMAT = "$file:$line: $text" WARN_LOGFILE = doxygen.err #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- INPUT = . FILE_PATTERNS = *.c \ *.cc \ *.cxx \ *.cpp \ *.c++ \ *.d \ *.java \ *.ii \ *.ixx \ *.ipp \ *.i++ \ *.inl \ *.h \ *.hh \ *.hxx \ *.hpp \ *.h++ \ *.idl \ *.odl \ *.cs \ *.php \ *.php3 \ *.inc \ *.m \ *.mm \ *.dox \ *.py \ *.C \ *.CC \ *.C++ \ *.II \ *.I++ \ *.H \ *.HH \ *.H++ \ *.CS \ *.PHP \ *.PHP3 \ *.M \ *.MM \ *.PY RECURSIVE = YES EXCLUDE = libmysqld \ netware \ Docs \ dbug \ BUILD \ config \ autom4te.cache \ BitKeeper \ man \ scripts \ storage/innobase \ cmd-line-utils \ include/yassl \ include/readline \ extra/yassl \ support-files \ win \ mysql-test EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = */test/* \ */SCCS/* \ */BitKeeper/* \ */scripts/* \ */config/* \ */man/* \ */autom4te.cache/* \ */BUILD/* \ */netware/* \ */libmysqld/* \ */Docs/* \ */dbug/* \ */win/* \ */mysql-test/* \ */support-files/* EXAMPLE_PATH = EXAMPLE_PATTERNS = * EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- SOURCE_BROWSER = YES INLINE_SOURCES = YES STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = YES REFERENCES_RELATION = YES REFERENCES_LINK_SOURCE = YES USE_HTAGS = NO VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- ALPHABETICAL_INDEX = YES COLS_IN_ALPHA_INDEX = 5 IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- GENERATE_HTML = YES HTML_OUTPUT = html-doxygen HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_ALIGN_MEMBERS = YES GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO BINARY_TOC = NO TOC_EXPAND = NO DISABLE_INDEX = NO ENUM_VALUES_PER_LINE = 4 GENERATE_TREEVIEW = NO TREEVIEW_WIDTH = 250 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- GENERATE_LATEX = NO LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4wide EXTRA_PACKAGES = LATEX_HEADER = PDF_HYPERLINKS = NO USE_PDFLATEX = NO LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- GENERATE_RTF = NO RTF_OUTPUT = rtf COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- GENERATE_XML = NO XML_OUTPUT = xml XML_SCHEMA = XML_DTD = XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- ENABLE_PREPROCESSING = YES MACRO_EXPANSION = NO EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = PREDEFINED = EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- TAGFILES = GENERATE_TAGFILE = ALLEXTERNALS = NO EXTERNAL_GROUPS = YES PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- CLASS_DIAGRAMS = YES HIDE_UNDOC_RELATIONS = YES HAVE_DOT = YES CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = YES TEMPLATE_RELATIONS = YES INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = NO CALLER_GRAPH = NO GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DOT_IMAGE_FORMAT = png DOT_PATH = DOTFILE_DIRS = MAX_DOT_GRAPH_WIDTH = 1024 MAX_DOT_GRAPH_HEIGHT = 1024 MAX_DOT_GRAPH_DEPTH = 1000 DOT_TRANSPARENT = NO DOT_MULTI_TARGETS = YES GENERATE_LEGEND = YES DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Configuration::additions related to the search engine #--------------------------------------------------------------------------- SEARCHENGINE = YES --- New file --- +++ mysql-test/include/parser_stress_func.inc 06/10/17 11:18:58 ## ## 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/10/17 11:18:58 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) ) 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 LINEFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LINEFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LINEFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LINEFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LINESTRINGFROMTEXT( 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 LINESTRINGFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LINESTRINGFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LINESTRINGFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LINESTRINGFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LINESTRINGFROMWKB( 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 LINESTRINGFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LINESTRINGFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LINESTRINGFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LINESTRINGFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LN( 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 LN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOAD_FILE( 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 LOAD_FILE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOAD_FILE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOAD_FILE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOAD_FILE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOCATE( 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 LOCATE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOCATE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOCATE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOCATE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOG( 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 LOG(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOG (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOG; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOG; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOG10( 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 LOG10(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOG10 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOG10; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOG10; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOG2( 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 LOG2(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOG2 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOG2; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOG2; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LOWER( 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 LOWER(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LOWER (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LOWER; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LOWER; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LPAD( 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 LPAD(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LPAD (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LPAD; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LPAD; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE LTRIM( 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 LTRIM(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES LTRIM (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE LTRIM; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE LTRIM; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MAKEDATE( 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 MAKEDATE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MAKEDATE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MAKEDATE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MAKEDATE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MAKETIME( 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 MAKETIME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MAKETIME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MAKETIME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MAKETIME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MAKE_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 MAKE_SET(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MAKE_SET (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MAKE_SET; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MAKE_SET; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MASTER_POS_WAIT( 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 MASTER_POS_WAIT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MASTER_POS_WAIT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MASTER_POS_WAIT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MASTER_POS_WAIT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBRCONTAINS( 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 MBRCONTAINS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBRCONTAINS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBRCONTAINS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBRCONTAINS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBRDISJOINT( 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 MBRDISJOINT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBRDISJOINT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBRDISJOINT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBRDISJOINT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBREQUAL( 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 MBREQUAL(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBREQUAL (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBREQUAL; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBREQUAL; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBRINTERSECTS( 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 MBRINTERSECTS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBRINTERSECTS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBRINTERSECTS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBRINTERSECTS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBROVERLAPS( 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 MBROVERLAPS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBROVERLAPS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBROVERLAPS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBROVERLAPS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBRTOUCHES( 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 MBRTOUCHES(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBRTOUCHES (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBRTOUCHES; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBRTOUCHES; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MBRWITHIN( 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 MBRWITHIN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MBRWITHIN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MBRWITHIN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MBRWITHIN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MD5( 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 MD5(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MD5 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MD5; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MD5; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MLINEFROMTEXT( 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 MLINEFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MLINEFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MLINEFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MLINEFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MLINEFROMWKB( 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 MLINEFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MLINEFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MLINEFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MLINEFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MONTHNAME( 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 MONTHNAME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MONTHNAME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MONTHNAME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MONTHNAME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MPOINTFROMTEXT( 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 MPOINTFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MPOINTFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MPOINTFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MPOINTFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MPOINTFROMWKB( 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 MPOINTFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MPOINTFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MPOINTFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MPOINTFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MPOLYFROMTEXT( 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 MPOLYFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MPOLYFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MPOLYFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MPOLYFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MPOLYFROMWKB( 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 MPOLYFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MPOLYFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MPOLYFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MPOLYFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTILINESTRINGFROMTEXT( 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 MULTILINESTRINGFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTILINESTRINGFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTILINESTRINGFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTILINESTRINGFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTILINESTRINGFROMWKB( 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 MULTILINESTRINGFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTILINESTRINGFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTILINESTRINGFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTILINESTRINGFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTIPOINTFROMTEXT( 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 MULTIPOINTFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTIPOINTFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTIPOINTFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTIPOINTFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTIPOINTFROMWKB( 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 MULTIPOINTFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTIPOINTFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTIPOINTFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTIPOINTFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTIPOLYGONFROMTEXT( 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 MULTIPOLYGONFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTIPOLYGONFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTIPOLYGONFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTIPOLYGONFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE MULTIPOLYGONFROMWKB( 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 MULTIPOLYGONFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES MULTIPOLYGONFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE MULTIPOLYGONFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE MULTIPOLYGONFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE NAME_CONST( 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 NAME_CONST(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES NAME_CONST (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE NAME_CONST; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE NAME_CONST; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE NULLIF( 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 NULLIF(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES NULLIF (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE NULLIF; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE NULLIF; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE NUMGEOMETRIES( 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 NUMGEOMETRIES(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES NUMGEOMETRIES (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE NUMGEOMETRIES; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE NUMGEOMETRIES; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE NUMINTERIORRINGS( 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 NUMINTERIORRINGS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES NUMINTERIORRINGS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE NUMINTERIORRINGS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE NUMINTERIORRINGS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE NUMPOINTS( 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 NUMPOINTS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES NUMPOINTS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE NUMPOINTS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE NUMPOINTS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE OCT( 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 OCT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES OCT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE OCT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE OCT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE OCTET_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 OCTET_LENGTH(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES OCTET_LENGTH (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE OCTET_LENGTH; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE OCTET_LENGTH; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ORD( 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 ORD(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ORD (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ORD; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ORD; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE OVERLAPS( 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 OVERLAPS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES OVERLAPS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE OVERLAPS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE OVERLAPS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE PERIOD_ADD( 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 PERIOD_ADD(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES PERIOD_ADD (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE PERIOD_ADD; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE PERIOD_ADD; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE PERIOD_DIFF( 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 PERIOD_DIFF(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES PERIOD_DIFF (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE PERIOD_DIFF; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE PERIOD_DIFF; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE PI( 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 PI(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES PI (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE PI; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE PI; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POINTFROMTEXT( 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 POINTFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POINTFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POINTFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POINTFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POINTFROMWKB( 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 POINTFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POINTFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POINTFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POINTFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POINTN( 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 POINTN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POINTN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POINTN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POINTN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POLYFROMTEXT( 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 POLYFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POLYFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POLYFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POLYFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POLYFROMWKB( 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 POLYFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POLYFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POLYFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POLYFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POLYGONFROMTEXT( 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 POLYGONFROMTEXT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POLYGONFROMTEXT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POLYGONFROMTEXT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POLYGONFROMTEXT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POLYGONFROMWKB( 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 POLYGONFROMWKB(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POLYGONFROMWKB (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POLYGONFROMWKB; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POLYGONFROMWKB; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POW( 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 POW(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POW (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POW; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POW; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE POWER( 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 POWER(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES POWER (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE POWER; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE POWER; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE QUOTE( 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 QUOTE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES QUOTE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE QUOTE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE QUOTE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE RADIANS( 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 RADIANS(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES RADIANS (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE RADIANS; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE RADIANS; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE RAND( 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 RAND(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES RAND (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE RAND; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE RAND; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE RELEASE_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 RELEASE_LOCK(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES RELEASE_LOCK (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE RELEASE_LOCK; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE RELEASE_LOCK; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE REVERSE( 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 REVERSE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES REVERSE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE REVERSE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE REVERSE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ROUND( 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 ROUND(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ROUND (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ROUND; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ROUND; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE ROW_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 ROW_COUNT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES ROW_COUNT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE ROW_COUNT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE ROW_COUNT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE RPAD( 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 RPAD(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES RPAD (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE RPAD; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE RPAD; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE RTRIM( 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 RTRIM(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES RTRIM (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE RTRIM; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE RTRIM; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SEC_TO_TIME( 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 SEC_TO_TIME(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SEC_TO_TIME (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SEC_TO_TIME; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SEC_TO_TIME; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SESSION_USER( 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 SESSION_USER(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SESSION_USER (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SESSION_USER; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SESSION_USER; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SHA( 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 SHA(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SHA (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SHA; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SHA; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SHA1( 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 SHA1(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SHA1 (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SHA1; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SHA1; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SIGN( 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 SIGN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SIGN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SIGN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SIGN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SIN( 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 SIN(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SIN (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SIN; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SIN; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SLEEP( 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 SLEEP(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SLEEP (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SLEEP; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SLEEP; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SOUNDEX( 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 SOUNDEX(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SOUNDEX (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SOUNDEX; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SOUNDEX; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SPACE( 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 SPACE(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SPACE (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SPACE; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SPACE; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SQRT( 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 SQRT(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SQRT (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SQRT; SHOW CREATE TABLE bug21114_child; DROP TABLE bug21114_child; DROP TABLE SQRT; drop table if exists $FCT; drop table if exists bug21114_child; CREATE TABLE SRID( 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 SRID(col1, col2), CONSTRAINT fk_fct_space FOREIGN KEY (fk_col3, fk_col4) REFERENCES SRID (col1, col2) ) ENGINE InnoDb; SHOW CREATE TABLE SRID; SHOW CREATE TABLE bug21114_child;
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (malff:1.2307) BUG#21114 | marc.alff | 17 Oct |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 2.142 sec. using MySQL 5.1.14-beta-log