| List: | Commits | « Previous MessageNext Message » | |
| From: | Davi Arnaut | Date: | August 12 2008 8:51pm |
| Subject: | bzr commit into mysql-5.0 branch (davi:2647) Bug#29738 Bug#31605 Bug#33362 Bug#37201 Bug#37781 Bug#37830 Bug#38296 Bug#38486 | ||
| View as plain text | |||
# At a local mysql-5.0 repository of davi
2647 Davi Arnaut 2008-08-12 [merge]
Merge mysql-5.0-bugteam into mysql-5.0
modified:
client/mysql_upgrade.c
mysql-test/r/func_if.result
mysql-test/r/innodb_mysql.result
mysql-test/r/query_cache_merge.result
mysql-test/r/subselect.result
mysql-test/t/func_if.test
mysql-test/t/innodb_mysql.test
mysql-test/t/query_cache_merge.test
mysql-test/t/subselect.test
mysys/mf_keycache.c
mysys/my_alloc.c
scripts/mysql_system_tables.sql
sql/field.h
sql/item.cc
sql/item.h
sql/item_cmpfunc.cc
sql/item_func.cc
sql/opt_range.cc
sql/opt_range.h
sql/share/errmsg.txt
sql/sp_head.cc
sql/sql_acl.cc
sql/sql_cache.cc
sql/sql_cursor.cc
sql/sql_lex.h
sql/sql_list.h
sql/sql_parse.cc
sql/sql_select.cc
sql/sql_string.h
sql/sql_yacc.yy
sql/thr_malloc.cc
support-files/build-tags
tests/mysql_client_test.c
=== modified file 'client/mysql_upgrade.c'
--- a/client/mysql_upgrade.c 2008-05-02 12:41:19 +0000
+++ b/client/mysql_upgrade.c 2008-08-11 17:56:54 +0000
@@ -259,6 +259,10 @@ get_one_option(int optid, const struct m
}
+/**
+ Run a command using the shell, storing its output in the supplied dynamic
+ string.
+*/
static int run_command(char* cmd,
DYNAMIC_STRING *ds_res)
{
@@ -331,36 +335,16 @@ static int run_tool(char *tool_path, DYN
}
-/*
- Try to get the full path to this exceutable
-
- Return 0 if path found
-
+/**
+ Look for the filename of given tool, with the presumption that it is in the
+ same directory as mysql_upgrade and that the same executable-searching
+ mechanism will be used when we run our sub-shells with popen() later.
*/
-
-static my_bool get_full_path_to_executable(char* path)
+static void find_tool(char *tool_executable_name, const char *tool_name,
+ const char *self_name)
{
- my_bool ret;
- DBUG_ENTER("get_full_path_to_executable");
-#ifdef __WIN__
- ret= (GetModuleFileName(NULL, path, FN_REFLEN) == 0);
-#else
- /* my_readlink returns 0 if a symlink was read */
- ret= (my_readlink(path, "/proc/self/exe", MYF(0)) != 0);
- /* Might also want to try with /proc/$$/exe if the above fails */
-#endif
- DBUG_PRINT("exit", ("path: %s", path));
- DBUG_RETURN(ret);
-}
+ char *last_fn_libchar;
-
-/*
- Look for the tool in the same directory as mysql_upgrade.
-*/
-
-static void find_tool(char *tool_path, const char *tool_name)
-{
- char path[FN_REFLEN];
DYNAMIC_STRING ds_tmp;
DBUG_ENTER("find_tool");
DBUG_PRINT("enter", ("progname: %s", my_progname));
@@ -368,77 +352,59 @@ static void find_tool(char *tool_path, c
if (init_dynamic_string(&ds_tmp, "", 32, 32))
die("Out of memory");
- /* Initialize path with the full path to this program */
- if (get_full_path_to_executable(path))
+ last_fn_libchar= strrchr(self_name, FN_LIBCHAR);
+
+ if (last_fn_libchar == NULL)
{
/*
- Easy way to get full executable path failed, try
- other methods
+ mysql_upgrade was found by the shell searching the path. A sibling
+ next to us should be found the same way.
*/
- if (my_progname[0] == FN_LIBCHAR)
- {
- /* 1. my_progname contains full path */
- strmake(path, my_progname, FN_REFLEN);
- }
- else if (my_progname[0] == '.')
- {
- /* 2. my_progname contains relative path, prepend wd */
- char buf[FN_REFLEN];
- my_getwd(buf, FN_REFLEN, MYF(0));
- my_snprintf(path, FN_REFLEN, "%s%s", buf, my_progname);
- }
- else
- {
- /* 3. Just go for it and hope tool is in path */
- path[0]= 0;
- }
+ strncpy(tool_executable_name, tool_name, FN_REFLEN);
}
-
- DBUG_PRINT("info", ("path: '%s'", path));
-
- /* Chop off binary name (i.e mysql-upgrade) from path */
- dirname_part(path, path);
-
- /*
- When running in a not yet installed build and using libtool,
- the program(mysql_upgrade) will be in .libs/ and executed
- through a libtool wrapper in order to use the dynamic libraries
- from this build. The same must be done for the tools(mysql and
- mysqlcheck). Thus if path ends in .libs/, step up one directory
- and execute the tools from there
- */
- path[max((strlen(path)-1), 0)]= 0; /* Chop off last / */
- if (strncmp(path + dirname_length(path), ".libs", 5) == 0)
+ else
{
- DBUG_PRINT("info", ("Chopping off .libs from '%s'", path));
-
- /* Chop off .libs */
- dirname_part(path, path);
- }
+ int len;
+ /*
+ mysql_upgrade was run absolutely or relatively. We can find a sibling
+ by replacing our name after the LIBCHAR with the new tool name.
+ */
- DBUG_PRINT("info", ("path: '%s'", path));
+ /*
+ When running in a not yet installed build and using libtool,
+ the program(mysql_upgrade) will be in .libs/ and executed
+ through a libtool wrapper in order to use the dynamic libraries
+ from this build. The same must be done for the tools(mysql and
+ mysqlcheck). Thus if path ends in .libs/, step up one directory
+ and execute the tools from there
+ */
+ if (((last_fn_libchar - 6) >= self_name) &&
+ (strncmp(last_fn_libchar - 5, ".libs", 5) == 0) &&
+ (*(last_fn_libchar - 6) == FN_LIBCHAR))
+ {
+ DBUG_PRINT("info", ("Chopping off \".libs\" from end of path"));
+ last_fn_libchar -= 6;
+ }
- /* Format name of the tool to search for */
- fn_format(tool_path, tool_name,
- path, "", MYF(MY_REPLACE_DIR));
+ len= last_fn_libchar - self_name;
- verbose("Looking for '%s' in: %s", tool_name, tool_path);
+ my_snprintf(tool_executable_name, FN_REFLEN, "%.*s%c%s",
+ len, self_name, FN_LIBCHAR, tool_name);
+ }
- /* Make sure the tool exists */
- if (my_access(tool_path, F_OK) != 0)
- die("Can't find '%s'", tool_path);
+ verbose("Looking for '%s' as: %s", tool_name, tool_executable_name);
/*
Make sure it can be executed
*/
- if (run_tool(tool_path,
+ if (run_tool(tool_executable_name,
&ds_tmp, /* Get output from command, discard*/
"--help",
"2>&1",
IF_WIN("> NUL", "> /dev/null"),
NULL))
- die("Can't execute '%s'", tool_path);
+ die("Can't execute '%s'", tool_executable_name);
dynstr_free(&ds_tmp);
@@ -748,11 +714,20 @@ static const char *load_default_groups[]
int main(int argc, char **argv)
{
+ char self_name[FN_REFLEN];
+
MY_INIT(argv[0]);
#ifdef __NETWARE__
setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
#endif
+#if __WIN__
+ if (GetModuleFileName(NULL, self_name, FN_REFLEN) == 0)
+#endif
+ {
+ strncpy(self_name, argv[0], FN_REFLEN);
+ }
+
if (init_dynamic_string(&ds_args, "", 512, 256))
die("Out of memory");
@@ -774,10 +749,10 @@ int main(int argc, char **argv)
dynstr_append(&ds_args, " ");
/* Find mysql */
- find_tool(mysql_path, IF_WIN("mysql.exe", "mysql"));
+ find_tool(mysql_path, IF_WIN("mysql.exe", "mysql"), self_name);
/* Find mysqlcheck */
- find_tool(mysqlcheck_path, IF_WIN("mysqlcheck.exe", "mysqlcheck"));
+ find_tool(mysqlcheck_path, IF_WIN("mysqlcheck.exe", "mysqlcheck"), self_name);
/*
Read the mysql_upgrade_info file to check if mysql_upgrade
=== modified file 'mysql-test/r/func_if.result'
--- a/mysql-test/r/func_if.result 2007-02-12 20:59:29 +0000
+++ b/mysql-test/r/func_if.result 2008-07-30 11:07:37 +0000
@@ -131,3 +131,49 @@ drop table t1;
select if(0, 18446744073709551610, 18446744073709551610);
if(0, 18446744073709551610, 18446744073709551610)
18446744073709551610
+CREATE TABLE t1(a DECIMAL(10,3));
+SELECT t1.a,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,0)))))))))))))))))))))))))))))) + 1
+FROM t1;
+a IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((ROUND(t1.a,2)=1), 2,
+IF((R
+DROP TABLE t1;
+End of 5.0 tests
=== modified file 'mysql-test/r/innodb_mysql.result'
--- a/mysql-test/r/innodb_mysql.result 2008-02-07 07:12:49 +0000
+++ b/mysql-test/r/innodb_mysql.result 2008-07-23 11:25:00 +0000
@@ -1246,4 +1246,19 @@ set global innodb_autoextend_increment=@
set @my_innodb_commit_concurrency=@@global.innodb_commit_concurrency;
set global innodb_commit_concurrency=0;
set global innodb_commit_concurrency=@my_innodb_commit_concurrency;
+CREATE TABLE t1 (a int, b int, c int, PRIMARY KEY (a), KEY t1_b (b))
+ENGINE=InnoDB;
+INSERT INTO t1 (a,b,c) VALUES (1,1,1), (2,1,1), (3,1,1), (4,1,1);
+INSERT INTO t1 (a,b,c) SELECT a+4,b,c FROM t1;
+EXPLAIN SELECT a, b, c FROM t1 WHERE b = 1 ORDER BY a DESC LIMIT 5;
+id select_type table type possible_keys key key_len ref rows Extra
+1 SIMPLE t1 range t1_b t1_b 5 NULL 4 Using where
+SELECT a, b, c FROM t1 WHERE b = 1 ORDER BY a DESC LIMIT 5;
+a b c
+8 1 1
+7 1 1
+6 1 1
+5 1 1
+4 1 1
+DROP TABLE t1;
End of 5.0 tests
=== modified file 'mysql-test/r/query_cache_merge.result'
--- a/mysql-test/r/query_cache_merge.result 2003-08-22 01:07:40 +0000
+++ b/mysql-test/r/query_cache_merge.result 2008-07-24 14:14:34 +0000
@@ -18,3 +18,1675 @@ Variable_name Value
Qcache_queries_in_cache 0
drop table t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31,t32,t33,t34,t35,t36,t37,t38,t39,t40,t41,t42,t43,t44,t45,t46,t47,t48,t49,t50,t51,t52,t53,t54,t55,t56,t57,t58,t59,t60,t61,t62,t63,t64,t65,t66,t67,t68,t69,t70,t71,t72,t73,t74,t75,t76,t77,t78,t79,t80,t81,t82,t83,t84,t85,t86,t87,t88,t89,t90,t91,t92,t93,t94,t95,t96,t97,t98,t99,t100,t101,t102,t103,t104,t105,t106,t107,t108,t109,t110,t111,t112,t113,t114,t115,t116,t117,t118,t119,t120,t121,t122,t123,t124,t125,t126,t127,t128,t129,t130,t131,t132,t133,t134,t135,t136,t137,t138,t139,t140,t141,t142,t143,t144,t145,t146,t147,t148,t149,t150,t151,t152,t153,t154,t155,t156,t157,t158,t159,t160,t161,t162,t163,t164,t165,t166,t167,t168,t169,t170,t171,t172,t173,t174,t175,t176,t177,t178,t179,t180,t181,t182,t183,t184,t185,t186,t187,t188,t189,t190,t191,t192,t193,t194,t195,t196,t197,t198,t199,t200,t201,t202,t203,t204,t205,t206,t207,t208,t209,t210,t211,t212,t213,t214,t215,t216,t217,t218,t219,t220,t221,t222,t223,t224,t225,t226,t227,t228,t229,t230,t231,t232,t233,t234,t235,t236,t237,t238,t239,t240,t241,t242,t243,t244,t245,t246,t247,t248,t249,t250,t251,t252,t253,t254,t255,t256,t257,t00;
SET @@global.query_cache_size=0;
+CREATE TABLE t255 (a INT);
+INSERT INTO t255 VALUES (255);
+CREATE TABLE t254 (a INT);
+INSERT INTO t254 VALUES (254);
+CREATE TABLE t253 (a INT);
+INSERT INTO t253 VALUES (253);
+CREATE TABLE t252 (a INT);
+INSERT INTO t252 VALUES (252);
+CREATE TABLE t251 (a INT);
+INSERT INTO t251 VALUES (251);
+CREATE TABLE t250 (a INT);
+INSERT INTO t250 VALUES (250);
+CREATE TABLE t249 (a INT);
+INSERT INTO t249 VALUES (249);
+CREATE TABLE t248 (a INT);
+INSERT INTO t248 VALUES (248);
+CREATE TABLE t247 (a INT);
+INSERT INTO t247 VALUES (247);
+CREATE TABLE t246 (a INT);
+INSERT INTO t246 VALUES (246);
+CREATE TABLE t245 (a INT);
+INSERT INTO t245 VALUES (245);
+CREATE TABLE t244 (a INT);
+INSERT INTO t244 VALUES (244);
+CREATE TABLE t243 (a INT);
+INSERT INTO t243 VALUES (243);
+CREATE TABLE t242 (a INT);
+INSERT INTO t242 VALUES (242);
+CREATE TABLE t241 (a INT);
+INSERT INTO t241 VALUES (241);
+CREATE TABLE t240 (a INT);
+INSERT INTO t240 VALUES (240);
+CREATE TABLE t239 (a INT);
+INSERT INTO t239 VALUES (239);
+CREATE TABLE t238 (a INT);
+INSERT INTO t238 VALUES (238);
+CREATE TABLE t237 (a INT);
+INSERT INTO t237 VALUES (237);
+CREATE TABLE t236 (a INT);
+INSERT INTO t236 VALUES (236);
+CREATE TABLE t235 (a INT);
+INSERT INTO t235 VALUES (235);
+CREATE TABLE t234 (a INT);
+INSERT INTO t234 VALUES (234);
+CREATE TABLE t233 (a INT);
+INSERT INTO t233 VALUES (233);
+CREATE TABLE t232 (a INT);
+INSERT INTO t232 VALUES (232);
+CREATE TABLE t231 (a INT);
+INSERT INTO t231 VALUES (231);
+CREATE TABLE t230 (a INT);
+INSERT INTO t230 VALUES (230);
+CREATE TABLE t229 (a INT);
+INSERT INTO t229 VALUES (229);
+CREATE TABLE t228 (a INT);
+INSERT INTO t228 VALUES (228);
+CREATE TABLE t227 (a INT);
+INSERT INTO t227 VALUES (227);
+CREATE TABLE t226 (a INT);
+INSERT INTO t226 VALUES (226);
+CREATE TABLE t225 (a INT);
+INSERT INTO t225 VALUES (225);
+CREATE TABLE t224 (a INT);
+INSERT INTO t224 VALUES (224);
+CREATE TABLE t223 (a INT);
+INSERT INTO t223 VALUES (223);
+CREATE TABLE t222 (a INT);
+INSERT INTO t222 VALUES (222);
+CREATE TABLE t221 (a INT);
+INSERT INTO t221 VALUES (221);
+CREATE TABLE t220 (a INT);
+INSERT INTO t220 VALUES (220);
+CREATE TABLE t219 (a INT);
+INSERT INTO t219 VALUES (219);
+CREATE TABLE t218 (a INT);
+INSERT INTO t218 VALUES (218);
+CREATE TABLE t217 (a INT);
+INSERT INTO t217 VALUES (217);
+CREATE TABLE t216 (a INT);
+INSERT INTO t216 VALUES (216);
+CREATE TABLE t215 (a INT);
+INSERT INTO t215 VALUES (215);
+CREATE TABLE t214 (a INT);
+INSERT INTO t214 VALUES (214);
+CREATE TABLE t213 (a INT);
+INSERT INTO t213 VALUES (213);
+CREATE TABLE t212 (a INT);
+INSERT INTO t212 VALUES (212);
+CREATE TABLE t211 (a INT);
+INSERT INTO t211 VALUES (211);
+CREATE TABLE t210 (a INT);
+INSERT INTO t210 VALUES (210);
+CREATE TABLE t209 (a INT);
+INSERT INTO t209 VALUES (209);
+CREATE TABLE t208 (a INT);
+INSERT INTO t208 VALUES (208);
+CREATE TABLE t207 (a INT);
+INSERT INTO t207 VALUES (207);
+CREATE TABLE t206 (a INT);
+INSERT INTO t206 VALUES (206);
+CREATE TABLE t205 (a INT);
+INSERT INTO t205 VALUES (205);
+CREATE TABLE t204 (a INT);
+INSERT INTO t204 VALUES (204);
+CREATE TABLE t203 (a INT);
+INSERT INTO t203 VALUES (203);
+CREATE TABLE t202 (a INT);
+INSERT INTO t202 VALUES (202);
+CREATE TABLE t201 (a INT);
+INSERT INTO t201 VALUES (201);
+CREATE TABLE t200 (a INT);
+INSERT INTO t200 VALUES (200);
+CREATE TABLE t199 (a INT);
+INSERT INTO t199 VALUES (199);
+CREATE TABLE t198 (a INT);
+INSERT INTO t198 VALUES (198);
+CREATE TABLE t197 (a INT);
+INSERT INTO t197 VALUES (197);
+CREATE TABLE t196 (a INT);
+INSERT INTO t196 VALUES (196);
+CREATE TABLE t195 (a INT);
+INSERT INTO t195 VALUES (195);
+CREATE TABLE t194 (a INT);
+INSERT INTO t194 VALUES (194);
+CREATE TABLE t193 (a INT);
+INSERT INTO t193 VALUES (193);
+CREATE TABLE t192 (a INT);
+INSERT INTO t192 VALUES (192);
+CREATE TABLE t191 (a INT);
+INSERT INTO t191 VALUES (191);
+CREATE TABLE t190 (a INT);
+INSERT INTO t190 VALUES (190);
+CREATE TABLE t189 (a INT);
+INSERT INTO t189 VALUES (189);
+CREATE TABLE t188 (a INT);
+INSERT INTO t188 VALUES (188);
+CREATE TABLE t187 (a INT);
+INSERT INTO t187 VALUES (187);
+CREATE TABLE t186 (a INT);
+INSERT INTO t186 VALUES (186);
+CREATE TABLE t185 (a INT);
+INSERT INTO t185 VALUES (185);
+CREATE TABLE t184 (a INT);
+INSERT INTO t184 VALUES (184);
+CREATE TABLE t183 (a INT);
+INSERT INTO t183 VALUES (183);
+CREATE TABLE t182 (a INT);
+INSERT INTO t182 VALUES (182);
+CREATE TABLE t181 (a INT);
+INSERT INTO t181 VALUES (181);
+CREATE TABLE t180 (a INT);
+INSERT INTO t180 VALUES (180);
+CREATE TABLE t179 (a INT);
+INSERT INTO t179 VALUES (179);
+CREATE TABLE t178 (a INT);
+INSERT INTO t178 VALUES (178);
+CREATE TABLE t177 (a INT);
+INSERT INTO t177 VALUES (177);
+CREATE TABLE t176 (a INT);
+INSERT INTO t176 VALUES (176);
+CREATE TABLE t175 (a INT);
+INSERT INTO t175 VALUES (175);
+CREATE TABLE t174 (a INT);
+INSERT INTO t174 VALUES (174);
+CREATE TABLE t173 (a INT);
+INSERT INTO t173 VALUES (173);
+CREATE TABLE t172 (a INT);
+INSERT INTO t172 VALUES (172);
+CREATE TABLE t171 (a INT);
+INSERT INTO t171 VALUES (171);
+CREATE TABLE t170 (a INT);
+INSERT INTO t170 VALUES (170);
+CREATE TABLE t169 (a INT);
+INSERT INTO t169 VALUES (169);
+CREATE TABLE t168 (a INT);
+INSERT INTO t168 VALUES (168);
+CREATE TABLE t167 (a INT);
+INSERT INTO t167 VALUES (167);
+CREATE TABLE t166 (a INT);
+INSERT INTO t166 VALUES (166);
+CREATE TABLE t165 (a INT);
+INSERT INTO t165 VALUES (165);
+CREATE TABLE t164 (a INT);
+INSERT INTO t164 VALUES (164);
+CREATE TABLE t163 (a INT);
+INSERT INTO t163 VALUES (163);
+CREATE TABLE t162 (a INT);
+INSERT INTO t162 VALUES (162);
+CREATE TABLE t161 (a INT);
+INSERT INTO t161 VALUES (161);
+CREATE TABLE t160 (a INT);
+INSERT INTO t160 VALUES (160);
+CREATE TABLE t159 (a INT);
+INSERT INTO t159 VALUES (159);
+CREATE TABLE t158 (a INT);
+INSERT INTO t158 VALUES (158);
+CREATE TABLE t157 (a INT);
+INSERT INTO t157 VALUES (157);
+CREATE TABLE t156 (a INT);
+INSERT INTO t156 VALUES (156);
+CREATE TABLE t155 (a INT);
+INSERT INTO t155 VALUES (155);
+CREATE TABLE t154 (a INT);
+INSERT INTO t154 VALUES (154);
+CREATE TABLE t153 (a INT);
+INSERT INTO t153 VALUES (153);
+CREATE TABLE t152 (a INT);
+INSERT INTO t152 VALUES (152);
+CREATE TABLE t151 (a INT);
+INSERT INTO t151 VALUES (151);
+CREATE TABLE t150 (a INT);
+INSERT INTO t150 VALUES (150);
+CREATE TABLE t149 (a INT);
+INSERT INTO t149 VALUES (149);
+CREATE TABLE t148 (a INT);
+INSERT INTO t148 VALUES (148);
+CREATE TABLE t147 (a INT);
+INSERT INTO t147 VALUES (147);
+CREATE TABLE t146 (a INT);
+INSERT INTO t146 VALUES (146);
+CREATE TABLE t145 (a INT);
+INSERT INTO t145 VALUES (145);
+CREATE TABLE t144 (a INT);
+INSERT INTO t144 VALUES (144);
+CREATE TABLE t143 (a INT);
+INSERT INTO t143 VALUES (143);
+CREATE TABLE t142 (a INT);
+INSERT INTO t142 VALUES (142);
+CREATE TABLE t141 (a INT);
+INSERT INTO t141 VALUES (141);
+CREATE TABLE t140 (a INT);
+INSERT INTO t140 VALUES (140);
+CREATE TABLE t139 (a INT);
+INSERT INTO t139 VALUES (139);
+CREATE TABLE t138 (a INT);
+INSERT INTO t138 VALUES (138);
+CREATE TABLE t137 (a INT);
+INSERT INTO t137 VALUES (137);
+CREATE TABLE t136 (a INT);
+INSERT INTO t136 VALUES (136);
+CREATE TABLE t135 (a INT);
+INSERT INTO t135 VALUES (135);
+CREATE TABLE t134 (a INT);
+INSERT INTO t134 VALUES (134);
+CREATE TABLE t133 (a INT);
+INSERT INTO t133 VALUES (133);
+CREATE TABLE t132 (a INT);
+INSERT INTO t132 VALUES (132);
+CREATE TABLE t131 (a INT);
+INSERT INTO t131 VALUES (131);
+CREATE TABLE t130 (a INT);
+INSERT INTO t130 VALUES (130);
+CREATE TABLE t129 (a INT);
+INSERT INTO t129 VALUES (129);
+CREATE TABLE t128 (a INT);
+INSERT INTO t128 VALUES (128);
+CREATE TABLE t127 (a INT);
+INSERT INTO t127 VALUES (127);
+CREATE TABLE t126 (a INT);
+INSERT INTO t126 VALUES (126);
+CREATE TABLE t125 (a INT);
+INSERT INTO t125 VALUES (125);
+CREATE TABLE t124 (a INT);
+INSERT INTO t124 VALUES (124);
+CREATE TABLE t123 (a INT);
+INSERT INTO t123 VALUES (123);
+CREATE TABLE t122 (a INT);
+INSERT INTO t122 VALUES (122);
+CREATE TABLE t121 (a INT);
+INSERT INTO t121 VALUES (121);
+CREATE TABLE t120 (a INT);
+INSERT INTO t120 VALUES (120);
+CREATE TABLE t119 (a INT);
+INSERT INTO t119 VALUES (119);
+CREATE TABLE t118 (a INT);
+INSERT INTO t118 VALUES (118);
+CREATE TABLE t117 (a INT);
+INSERT INTO t117 VALUES (117);
+CREATE TABLE t116 (a INT);
+INSERT INTO t116 VALUES (116);
+CREATE TABLE t115 (a INT);
+INSERT INTO t115 VALUES (115);
+CREATE TABLE t114 (a INT);
+INSERT INTO t114 VALUES (114);
+CREATE TABLE t113 (a INT);
+INSERT INTO t113 VALUES (113);
+CREATE TABLE t112 (a INT);
+INSERT INTO t112 VALUES (112);
+CREATE TABLE t111 (a INT);
+INSERT INTO t111 VALUES (111);
+CREATE TABLE t110 (a INT);
+INSERT INTO t110 VALUES (110);
+CREATE TABLE t109 (a INT);
+INSERT INTO t109 VALUES (109);
+CREATE TABLE t108 (a INT);
+INSERT INTO t108 VALUES (108);
+CREATE TABLE t107 (a INT);
+INSERT INTO t107 VALUES (107);
+CREATE TABLE t106 (a INT);
+INSERT INTO t106 VALUES (106);
+CREATE TABLE t105 (a INT);
+INSERT INTO t105 VALUES (105);
+CREATE TABLE t104 (a INT);
+INSERT INTO t104 VALUES (104);
+CREATE TABLE t103 (a INT);
+INSERT INTO t103 VALUES (103);
+CREATE TABLE t102 (a INT);
+INSERT INTO t102 VALUES (102);
+CREATE TABLE t101 (a INT);
+INSERT INTO t101 VALUES (101);
+CREATE TABLE t100 (a INT);
+INSERT INTO t100 VALUES (100);
+CREATE TABLE t99 (a INT);
+INSERT INTO t99 VALUES (99);
+CREATE TABLE t98 (a INT);
+INSERT INTO t98 VALUES (98);
+CREATE TABLE t97 (a INT);
+INSERT INTO t97 VALUES (97);
+CREATE TABLE t96 (a INT);
+INSERT INTO t96 VALUES (96);
+CREATE TABLE t95 (a INT);
+INSERT INTO t95 VALUES (95);
+CREATE TABLE t94 (a INT);
+INSERT INTO t94 VALUES (94);
+CREATE TABLE t93 (a INT);
+INSERT INTO t93 VALUES (93);
+CREATE TABLE t92 (a INT);
+INSERT INTO t92 VALUES (92);
+CREATE TABLE t91 (a INT);
+INSERT INTO t91 VALUES (91);
+CREATE TABLE t90 (a INT);
+INSERT INTO t90 VALUES (90);
+CREATE TABLE t89 (a INT);
+INSERT INTO t89 VALUES (89);
+CREATE TABLE t88 (a INT);
+INSERT INTO t88 VALUES (88);
+CREATE TABLE t87 (a INT);
+INSERT INTO t87 VALUES (87);
+CREATE TABLE t86 (a INT);
+INSERT INTO t86 VALUES (86);
+CREATE TABLE t85 (a INT);
+INSERT INTO t85 VALUES (85);
+CREATE TABLE t84 (a INT);
+INSERT INTO t84 VALUES (84);
+CREATE TABLE t83 (a INT);
+INSERT INTO t83 VALUES (83);
+CREATE TABLE t82 (a INT);
+INSERT INTO t82 VALUES (82);
+CREATE TABLE t81 (a INT);
+INSERT INTO t81 VALUES (81);
+CREATE TABLE t80 (a INT);
+INSERT INTO t80 VALUES (80);
+CREATE TABLE t79 (a INT);
+INSERT INTO t79 VALUES (79);
+CREATE TABLE t78 (a INT);
+INSERT INTO t78 VALUES (78);
+CREATE TABLE t77 (a INT);
+INSERT INTO t77 VALUES (77);
+CREATE TABLE t76 (a INT);
+INSERT INTO t76 VALUES (76);
+CREATE TABLE t75 (a INT);
+INSERT INTO t75 VALUES (75);
+CREATE TABLE t74 (a INT);
+INSERT INTO t74 VALUES (74);
+CREATE TABLE t73 (a INT);
+INSERT INTO t73 VALUES (73);
+CREATE TABLE t72 (a INT);
+INSERT INTO t72 VALUES (72);
+CREATE TABLE t71 (a INT);
+INSERT INTO t71 VALUES (71);
+CREATE TABLE t70 (a INT);
+INSERT INTO t70 VALUES (70);
+CREATE TABLE t69 (a INT);
+INSERT INTO t69 VALUES (69);
+CREATE TABLE t68 (a INT);
+INSERT INTO t68 VALUES (68);
+CREATE TABLE t67 (a INT);
+INSERT INTO t67 VALUES (67);
+CREATE TABLE t66 (a INT);
+INSERT INTO t66 VALUES (66);
+CREATE TABLE t65 (a INT);
+INSERT INTO t65 VALUES (65);
+CREATE TABLE t64 (a INT);
+INSERT INTO t64 VALUES (64);
+CREATE TABLE t63 (a INT);
+INSERT INTO t63 VALUES (63);
+CREATE TABLE t62 (a INT);
+INSERT INTO t62 VALUES (62);
+CREATE TABLE t61 (a INT);
+INSERT INTO t61 VALUES (61);
+CREATE TABLE t60 (a INT);
+INSERT INTO t60 VALUES (60);
+CREATE TABLE t59 (a INT);
+INSERT INTO t59 VALUES (59);
+CREATE TABLE t58 (a INT);
+INSERT INTO t58 VALUES (58);
+CREATE TABLE t57 (a INT);
+INSERT INTO t57 VALUES (57);
+CREATE TABLE t56 (a INT);
+INSERT INTO t56 VALUES (56);
+CREATE TABLE t55 (a INT);
+INSERT INTO t55 VALUES (55);
+CREATE TABLE t54 (a INT);
+INSERT INTO t54 VALUES (54);
+CREATE TABLE t53 (a INT);
+INSERT INTO t53 VALUES (53);
+CREATE TABLE t52 (a INT);
+INSERT INTO t52 VALUES (52);
+CREATE TABLE t51 (a INT);
+INSERT INTO t51 VALUES (51);
+CREATE TABLE t50 (a INT);
+INSERT INTO t50 VALUES (50);
+CREATE TABLE t49 (a INT);
+INSERT INTO t49 VALUES (49);
+CREATE TABLE t48 (a INT);
+INSERT INTO t48 VALUES (48);
+CREATE TABLE t47 (a INT);
+INSERT INTO t47 VALUES (47);
+CREATE TABLE t46 (a INT);
+INSERT INTO t46 VALUES (46);
+CREATE TABLE t45 (a INT);
+INSERT INTO t45 VALUES (45);
+CREATE TABLE t44 (a INT);
+INSERT INTO t44 VALUES (44);
+CREATE TABLE t43 (a INT);
+INSERT INTO t43 VALUES (43);
+CREATE TABLE t42 (a INT);
+INSERT INTO t42 VALUES (42);
+CREATE TABLE t41 (a INT);
+INSERT INTO t41 VALUES (41);
+CREATE TABLE t40 (a INT);
+INSERT INTO t40 VALUES (40);
+CREATE TABLE t39 (a INT);
+INSERT INTO t39 VALUES (39);
+CREATE TABLE t38 (a INT);
+INSERT INTO t38 VALUES (38);
+CREATE TABLE t37 (a INT);
+INSERT INTO t37 VALUES (37);
+CREATE TABLE t36 (a INT);
+INSERT INTO t36 VALUES (36);
+CREATE TABLE t35 (a INT);
+INSERT INTO t35 VALUES (35);
+CREATE TABLE t34 (a INT);
+INSERT INTO t34 VALUES (34);
+CREATE TABLE t33 (a INT);
+INSERT INTO t33 VALUES (33);
+CREATE TABLE t32 (a INT);
+INSERT INTO t32 VALUES (32);
+CREATE TABLE t31 (a INT);
+INSERT INTO t31 VALUES (31);
+CREATE TABLE t30 (a INT);
+INSERT INTO t30 VALUES (30);
+CREATE TABLE t29 (a INT);
+INSERT INTO t29 VALUES (29);
+CREATE TABLE t28 (a INT);
+INSERT INTO t28 VALUES (28);
+CREATE TABLE t27 (a INT);
+INSERT INTO t27 VALUES (27);
+CREATE TABLE t26 (a INT);
+INSERT INTO t26 VALUES (26);
+CREATE TABLE t25 (a INT);
+INSERT INTO t25 VALUES (25);
+CREATE TABLE t24 (a INT);
+INSERT INTO t24 VALUES (24);
+CREATE TABLE t23 (a INT);
+INSERT INTO t23 VALUES (23);
+CREATE TABLE t22 (a INT);
+INSERT INTO t22 VALUES (22);
+CREATE TABLE t21 (a INT);
+INSERT INTO t21 VALUES (21);
+CREATE TABLE t20 (a INT);
+INSERT INTO t20 VALUES (20);
+CREATE TABLE t19 (a INT);
+INSERT INTO t19 VALUES (19);
+CREATE TABLE t18 (a INT);
+INSERT INTO t18 VALUES (18);
+CREATE TABLE t17 (a INT);
+INSERT INTO t17 VALUES (17);
+CREATE TABLE t16 (a INT);
+INSERT INTO t16 VALUES (16);
+CREATE TABLE t15 (a INT);
+INSERT INTO t15 VALUES (15);
+CREATE TABLE t14 (a INT);
+INSERT INTO t14 VALUES (14);
+CREATE TABLE t13 (a INT);
+INSERT INTO t13 VALUES (13);
+CREATE TABLE t12 (a INT);
+INSERT INTO t12 VALUES (12);
+CREATE TABLE t11 (a INT);
+INSERT INTO t11 VALUES (11);
+CREATE TABLE t10 (a INT);
+INSERT INTO t10 VALUES (10);
+CREATE TABLE t9 (a INT);
+INSERT INTO t9 VALUES (9);
+CREATE TABLE t8 (a INT);
+INSERT INTO t8 VALUES (8);
+CREATE TABLE t7 (a INT);
+INSERT INTO t7 VALUES (7);
+CREATE TABLE t6 (a INT);
+INSERT INTO t6 VALUES (6);
+CREATE TABLE t5 (a INT);
+INSERT INTO t5 VALUES (5);
+CREATE TABLE t4 (a INT);
+INSERT INTO t4 VALUES (4);
+CREATE TABLE t3 (a INT);
+INSERT INTO t3 VALUES (3);
+CREATE TABLE t2 (a INT);
+INSERT INTO t2 VALUES (2);
+CREATE TABLE t1 (a INT);
+INSERT INTO t1 VALUES (1);
+CREATE TABLE t0 (a INT) ENGINE=MERGE UNION(t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31,t32,t33,t34,t35,t36,t37,t38,t39,t40,t41,t42,t43,t44,t45,t46,t47,t48,t49,t50,t51,t52,t53,t54,t55,t56,t57,t58,t59,t60,t61,t62,t63,t64,t65,t66,t67,t68,t69,t70,t71,t72,t73,t74,t75,t76,t77,t78,t79,t80,t81,t82,t83,t84,t85,t86,t87,t88,t89,t90,t91,t92,t93,t94,t95,t96,t97,t98,t99,t100,t101,t102,t103,t104,t105,t106,t107,t108,t109,t110,t111,t112,t113,t114,t115,t116,t117,t118,t119,t120,t121,t122,t123,t124,t125,t126,t127,t128,t129,t130,t131,t132,t133,t134,t135,t136,t137,t138,t139,t140,t141,t142,t143,t144,t145,t146,t147,t148,t149,t150,t151,t152,t153,t154,t155,t156,t157,t158,t159,t160,t161,t162,t163,t164,t165,t166,t167,t168,t169,t170,t171,t172,t173,t174,t175,t176,t177,t178,t179,t180,t181,t182,t183,t184,t185,t186,t187,t188,t189,t190,t191,t192,t193,t194,t195,t196,t197,t198,t199,t200,t201,t202,t203,t204,t205,t206,t207,t208,t209,t210,t211,t212,t213,t214,t215,t216,t217,t218,t219,t220,t221,t222,t223,t224,t225,t226,t227,t228,t229,t230,t231,t232,t233,t234,t235,t236,t237,t238,t239,t240,t241,t242,t243,t244,t245,t246,t247,t248,t249,t250,t251,t252,t253,t254,t255);
+SET GLOBAL query_cache_size = 1048576;
+FLUSH STATUS;
+SELECT a FROM t0 WHERE a = 1;
+a
+1
+SHOW STATUS LIKE "Qcache_queries_in_cache";
+Variable_name Value
+Qcache_queries_in_cache 1
+FLUSH TABLES;
+TRUNCATE TABLE t255;
+SELECT a FROM t1;
+a
+1
+TRUNCATE TABLE t254;
+SELECT a FROM t2;
+a
+2
+TRUNCATE TABLE t253;
+SELECT a FROM t3;
+a
+3
+TRUNCATE TABLE t252;
+SELECT a FROM t4;
+a
+4
+TRUNCATE TABLE t251;
+SELECT a FROM t5;
+a
+5
+TRUNCATE TABLE t250;
+SELECT a FROM t6;
+a
+6
+TRUNCATE TABLE t249;
+SELECT a FROM t7;
+a
+7
+TRUNCATE TABLE t248;
+SELECT a FROM t8;
+a
+8
+TRUNCATE TABLE t247;
+SELECT a FROM t9;
+a
+9
+TRUNCATE TABLE t246;
+SELECT a FROM t10;
+a
+10
+TRUNCATE TABLE t245;
+SELECT a FROM t11;
+a
+11
+TRUNCATE TABLE t244;
+SELECT a FROM t12;
+a
+12
+TRUNCATE TABLE t243;
+SELECT a FROM t13;
+a
+13
+TRUNCATE TABLE t242;
+SELECT a FROM t14;
+a
+14
+TRUNCATE TABLE t241;
+SELECT a FROM t15;
+a
+15
+TRUNCATE TABLE t240;
+SELECT a FROM t16;
+a
+16
+TRUNCATE TABLE t239;
+SELECT a FROM t17;
+a
+17
+TRUNCATE TABLE t238;
+SELECT a FROM t18;
+a
+18
+TRUNCATE TABLE t237;
+SELECT a FROM t19;
+a
+19
+TRUNCATE TABLE t236;
+SELECT a FROM t20;
+a
+20
+TRUNCATE TABLE t235;
+SELECT a FROM t21;
+a
+21
+TRUNCATE TABLE t234;
+SELECT a FROM t22;
+a
+22
+TRUNCATE TABLE t233;
+SELECT a FROM t23;
+a
+23
+TRUNCATE TABLE t232;
+SELECT a FROM t24;
+a
+24
+TRUNCATE TABLE t231;
+SELECT a FROM t25;
+a
+25
+TRUNCATE TABLE t230;
+SELECT a FROM t26;
+a
+26
+TRUNCATE TABLE t229;
+SELECT a FROM t27;
+a
+27
+TRUNCATE TABLE t228;
+SELECT a FROM t28;
+a
+28
+TRUNCATE TABLE t227;
+SELECT a FROM t29;
+a
+29
+TRUNCATE TABLE t226;
+SELECT a FROM t30;
+a
+30
+TRUNCATE TABLE t225;
+SELECT a FROM t31;
+a
+31
+TRUNCATE TABLE t224;
+SELECT a FROM t32;
+a
+32
+TRUNCATE TABLE t223;
+SELECT a FROM t33;
+a
+33
+TRUNCATE TABLE t222;
+SELECT a FROM t34;
+a
+34
+TRUNCATE TABLE t221;
+SELECT a FROM t35;
+a
+35
+TRUNCATE TABLE t220;
+SELECT a FROM t36;
+a
+36
+TRUNCATE TABLE t219;
+SELECT a FROM t37;
+a
+37
+TRUNCATE TABLE t218;
+SELECT a FROM t38;
+a
+38
+TRUNCATE TABLE t217;
+SELECT a FROM t39;
+a
+39
+TRUNCATE TABLE t216;
+SELECT a FROM t40;
+a
+40
+TRUNCATE TABLE t215;
+SELECT a FROM t41;
+a
+41
+TRUNCATE TABLE t214;
+SELECT a FROM t42;
+a
+42
+TRUNCATE TABLE t213;
+SELECT a FROM t43;
+a
+43
+TRUNCATE TABLE t212;
+SELECT a FROM t44;
+a
+44
+TRUNCATE TABLE t211;
+SELECT a FROM t45;
+a
+45
+TRUNCATE TABLE t210;
+SELECT a FROM t46;
+a
+46
+TRUNCATE TABLE t209;
+SELECT a FROM t47;
+a
+47
+TRUNCATE TABLE t208;
+SELECT a FROM t48;
+a
+48
+TRUNCATE TABLE t207;
+SELECT a FROM t49;
+a
+49
+TRUNCATE TABLE t206;
+SELECT a FROM t50;
+a
+50
+TRUNCATE TABLE t205;
+SELECT a FROM t51;
+a
+51
+TRUNCATE TABLE t204;
+SELECT a FROM t52;
+a
+52
+TRUNCATE TABLE t203;
+SELECT a FROM t53;
+a
+53
+TRUNCATE TABLE t202;
+SELECT a FROM t54;
+a
+54
+TRUNCATE TABLE t201;
+SELECT a FROM t55;
+a
+55
+TRUNCATE TABLE t200;
+SELECT a FROM t56;
+a
+56
+TRUNCATE TABLE t199;
+SELECT a FROM t57;
+a
+57
+TRUNCATE TABLE t198;
+SELECT a FROM t58;
+a
+58
+TRUNCATE TABLE t197;
+SELECT a FROM t59;
+a
+59
+TRUNCATE TABLE t196;
+SELECT a FROM t60;
+a
+60
+TRUNCATE TABLE t195;
+SELECT a FROM t61;
+a
+61
+TRUNCATE TABLE t194;
+SELECT a FROM t62;
+a
+62
+TRUNCATE TABLE t193;
+SELECT a FROM t63;
+a
+63
+TRUNCATE TABLE t192;
+SELECT a FROM t64;
+a
+64
+TRUNCATE TABLE t191;
+SELECT a FROM t65;
+a
+65
+TRUNCATE TABLE t190;
+SELECT a FROM t66;
+a
+66
+TRUNCATE TABLE t189;
+SELECT a FROM t67;
+a
+67
+TRUNCATE TABLE t188;
+SELECT a FROM t68;
+a
+68
+TRUNCATE TABLE t187;
+SELECT a FROM t69;
+a
+69
+TRUNCATE TABLE t186;
+SELECT a FROM t70;
+a
+70
+TRUNCATE TABLE t185;
+SELECT a FROM t71;
+a
+71
+TRUNCATE TABLE t184;
+SELECT a FROM t72;
+a
+72
+TRUNCATE TABLE t183;
+SELECT a FROM t73;
+a
+73
+TRUNCATE TABLE t182;
+SELECT a FROM t74;
+a
+74
+TRUNCATE TABLE t181;
+SELECT a FROM t75;
+a
+75
+TRUNCATE TABLE t180;
+SELECT a FROM t76;
+a
+76
+TRUNCATE TABLE t179;
+SELECT a FROM t77;
+a
+77
+TRUNCATE TABLE t178;
+SELECT a FROM t78;
+a
+78
+TRUNCATE TABLE t177;
+SELECT a FROM t79;
+a
+79
+TRUNCATE TABLE t176;
+SELECT a FROM t80;
+a
+80
+TRUNCATE TABLE t175;
+SELECT a FROM t81;
+a
+81
+TRUNCATE TABLE t174;
+SELECT a FROM t82;
+a
+82
+TRUNCATE TABLE t173;
+SELECT a FROM t83;
+a
+83
+TRUNCATE TABLE t172;
+SELECT a FROM t84;
+a
+84
+TRUNCATE TABLE t171;
+SELECT a FROM t85;
+a
+85
+TRUNCATE TABLE t170;
+SELECT a FROM t86;
+a
+86
+TRUNCATE TABLE t169;
+SELECT a FROM t87;
+a
+87
+TRUNCATE TABLE t168;
+SELECT a FROM t88;
+a
+88
+TRUNCATE TABLE t167;
+SELECT a FROM t89;
+a
+89
+TRUNCATE TABLE t166;
+SELECT a FROM t90;
+a
+90
+TRUNCATE TABLE t165;
+SELECT a FROM t91;
+a
+91
+TRUNCATE TABLE t164;
+SELECT a FROM t92;
+a
+92
+TRUNCATE TABLE t163;
+SELECT a FROM t93;
+a
+93
+TRUNCATE TABLE t162;
+SELECT a FROM t94;
+a
+94
+TRUNCATE TABLE t161;
+SELECT a FROM t95;
+a
+95
+TRUNCATE TABLE t160;
+SELECT a FROM t96;
+a
+96
+TRUNCATE TABLE t159;
+SELECT a FROM t97;
+a
+97
+TRUNCATE TABLE t158;
+SELECT a FROM t98;
+a
+98
+TRUNCATE TABLE t157;
+SELECT a FROM t99;
+a
+99
+TRUNCATE TABLE t156;
+SELECT a FROM t100;
+a
+100
+TRUNCATE TABLE t155;
+SELECT a FROM t101;
+a
+101
+TRUNCATE TABLE t154;
+SELECT a FROM t102;
+a
+102
+TRUNCATE TABLE t153;
+SELECT a FROM t103;
+a
+103
+TRUNCATE TABLE t152;
+SELECT a FROM t104;
+a
+104
+TRUNCATE TABLE t151;
+SELECT a FROM t105;
+a
+105
+TRUNCATE TABLE t150;
+SELECT a FROM t106;
+a
+106
+TRUNCATE TABLE t149;
+SELECT a FROM t107;
+a
+107
+TRUNCATE TABLE t148;
+SELECT a FROM t108;
+a
+108
+TRUNCATE TABLE t147;
+SELECT a FROM t109;
+a
+109
+TRUNCATE TABLE t146;
+SELECT a FROM t110;
+a
+110
+TRUNCATE TABLE t145;
+SELECT a FROM t111;
+a
+111
+TRUNCATE TABLE t144;
+SELECT a FROM t112;
+a
+112
+TRUNCATE TABLE t143;
+SELECT a FROM t113;
+a
+113
+TRUNCATE TABLE t142;
+SELECT a FROM t114;
+a
+114
+TRUNCATE TABLE t141;
+SELECT a FROM t115;
+a
+115
+TRUNCATE TABLE t140;
+SELECT a FROM t116;
+a
+116
+TRUNCATE TABLE t139;
+SELECT a FROM t117;
+a
+117
+TRUNCATE TABLE t138;
+SELECT a FROM t118;
+a
+118
+TRUNCATE TABLE t137;
+SELECT a FROM t119;
+a
+119
+TRUNCATE TABLE t136;
+SELECT a FROM t120;
+a
+120
+TRUNCATE TABLE t135;
+SELECT a FROM t121;
+a
+121
+TRUNCATE TABLE t134;
+SELECT a FROM t122;
+a
+122
+TRUNCATE TABLE t133;
+SELECT a FROM t123;
+a
+123
+TRUNCATE TABLE t132;
+SELECT a FROM t124;
+a
+124
+TRUNCATE TABLE t131;
+SELECT a FROM t125;
+a
+125
+TRUNCATE TABLE t130;
+SELECT a FROM t126;
+a
+126
+TRUNCATE TABLE t129;
+SELECT a FROM t127;
+a
+127
+TRUNCATE TABLE t128;
+SELECT a FROM t128;
+a
+TRUNCATE TABLE t127;
+SELECT a FROM t129;
+a
+TRUNCATE TABLE t126;
+SELECT a FROM t130;
+a
+TRUNCATE TABLE t125;
+SELECT a FROM t131;
+a
+TRUNCATE TABLE t124;
+SELECT a FROM t132;
+a
+TRUNCATE TABLE t123;
+SELECT a FROM t133;
+a
+TRUNCATE TABLE t122;
+SELECT a FROM t134;
+a
+TRUNCATE TABLE t121;
+SELECT a FROM t135;
+a
+TRUNCATE TABLE t120;
+SELECT a FROM t136;
+a
+TRUNCATE TABLE t119;
+SELECT a FROM t137;
+a
+TRUNCATE TABLE t118;
+SELECT a FROM t138;
+a
+TRUNCATE TABLE t117;
+SELECT a FROM t139;
+a
+TRUNCATE TABLE t116;
+SELECT a FROM t140;
+a
+TRUNCATE TABLE t115;
+SELECT a FROM t141;
+a
+TRUNCATE TABLE t114;
+SELECT a FROM t142;
+a
+TRUNCATE TABLE t113;
+SELECT a FROM t143;
+a
+TRUNCATE TABLE t112;
+SELECT a FROM t144;
+a
+TRUNCATE TABLE t111;
+SELECT a FROM t145;
+a
+TRUNCATE TABLE t110;
+SELECT a FROM t146;
+a
+TRUNCATE TABLE t109;
+SELECT a FROM t147;
+a
+TRUNCATE TABLE t108;
+SELECT a FROM t148;
+a
+TRUNCATE TABLE t107;
+SELECT a FROM t149;
+a
+TRUNCATE TABLE t106;
+SELECT a FROM t150;
+a
+TRUNCATE TABLE t105;
+SELECT a FROM t151;
+a
+TRUNCATE TABLE t104;
+SELECT a FROM t152;
+a
+TRUNCATE TABLE t103;
+SELECT a FROM t153;
+a
+TRUNCATE TABLE t102;
+SELECT a FROM t154;
+a
+TRUNCATE TABLE t101;
+SELECT a FROM t155;
+a
+TRUNCATE TABLE t100;
+SELECT a FROM t156;
+a
+TRUNCATE TABLE t99;
+SELECT a FROM t157;
+a
+TRUNCATE TABLE t98;
+SELECT a FROM t158;
+a
+TRUNCATE TABLE t97;
+SELECT a FROM t159;
+a
+TRUNCATE TABLE t96;
+SELECT a FROM t160;
+a
+TRUNCATE TABLE t95;
+SELECT a FROM t161;
+a
+TRUNCATE TABLE t94;
+SELECT a FROM t162;
+a
+TRUNCATE TABLE t93;
+SELECT a FROM t163;
+a
+TRUNCATE TABLE t92;
+SELECT a FROM t164;
+a
+TRUNCATE TABLE t91;
+SELECT a FROM t165;
+a
+TRUNCATE TABLE t90;
+SELECT a FROM t166;
+a
+TRUNCATE TABLE t89;
+SELECT a FROM t167;
+a
+TRUNCATE TABLE t88;
+SELECT a FROM t168;
+a
+TRUNCATE TABLE t87;
+SELECT a FROM t169;
+a
+TRUNCATE TABLE t86;
+SELECT a FROM t170;
+a
+TRUNCATE TABLE t85;
+SELECT a FROM t171;
+a
+TRUNCATE TABLE t84;
+SELECT a FROM t172;
+a
+TRUNCATE TABLE t83;
+SELECT a FROM t173;
+a
+TRUNCATE TABLE t82;
+SELECT a FROM t174;
+a
+TRUNCATE TABLE t81;
+SELECT a FROM t175;
+a
+TRUNCATE TABLE t80;
+SELECT a FROM t176;
+a
+TRUNCATE TABLE t79;
+SELECT a FROM t177;
+a
+TRUNCATE TABLE t78;
+SELECT a FROM t178;
+a
+TRUNCATE TABLE t77;
+SELECT a FROM t179;
+a
+TRUNCATE TABLE t76;
+SELECT a FROM t180;
+a
+TRUNCATE TABLE t75;
+SELECT a FROM t181;
+a
+TRUNCATE TABLE t74;
+SELECT a FROM t182;
+a
+TRUNCATE TABLE t73;
+SELECT a FROM t183;
+a
+TRUNCATE TABLE t72;
+SELECT a FROM t184;
+a
+TRUNCATE TABLE t71;
+SELECT a FROM t185;
+a
+TRUNCATE TABLE t70;
+SELECT a FROM t186;
+a
+TRUNCATE TABLE t69;
+SELECT a FROM t187;
+a
+TRUNCATE TABLE t68;
+SELECT a FROM t188;
+a
+TRUNCATE TABLE t67;
+SELECT a FROM t189;
+a
+TRUNCATE TABLE t66;
+SELECT a FROM t190;
+a
+TRUNCATE TABLE t65;
+SELECT a FROM t191;
+a
+TRUNCATE TABLE t64;
+SELECT a FROM t192;
+a
+TRUNCATE TABLE t63;
+SELECT a FROM t193;
+a
+TRUNCATE TABLE t62;
+SELECT a FROM t194;
+a
+TRUNCATE TABLE t61;
+SELECT a FROM t195;
+a
+TRUNCATE TABLE t60;
+SELECT a FROM t196;
+a
+TRUNCATE TABLE t59;
+SELECT a FROM t197;
+a
+TRUNCATE TABLE t58;
+SELECT a FROM t198;
+a
+TRUNCATE TABLE t57;
+SELECT a FROM t199;
+a
+TRUNCATE TABLE t56;
+SELECT a FROM t200;
+a
+TRUNCATE TABLE t55;
+SELECT a FROM t201;
+a
+TRUNCATE TABLE t54;
+SELECT a FROM t202;
+a
+TRUNCATE TABLE t53;
+SELECT a FROM t203;
+a
+TRUNCATE TABLE t52;
+SELECT a FROM t204;
+a
+TRUNCATE TABLE t51;
+SELECT a FROM t205;
+a
+TRUNCATE TABLE t50;
+SELECT a FROM t206;
+a
+TRUNCATE TABLE t49;
+SELECT a FROM t207;
+a
+TRUNCATE TABLE t48;
+SELECT a FROM t208;
+a
+TRUNCATE TABLE t47;
+SELECT a FROM t209;
+a
+TRUNCATE TABLE t46;
+SELECT a FROM t210;
+a
+TRUNCATE TABLE t45;
+SELECT a FROM t211;
+a
+TRUNCATE TABLE t44;
+SELECT a FROM t212;
+a
+TRUNCATE TABLE t43;
+SELECT a FROM t213;
+a
+TRUNCATE TABLE t42;
+SELECT a FROM t214;
+a
+TRUNCATE TABLE t41;
+SELECT a FROM t215;
+a
+TRUNCATE TABLE t40;
+SELECT a FROM t216;
+a
+TRUNCATE TABLE t39;
+SELECT a FROM t217;
+a
+TRUNCATE TABLE t38;
+SELECT a FROM t218;
+a
+TRUNCATE TABLE t37;
+SELECT a FROM t219;
+a
+TRUNCATE TABLE t36;
+SELECT a FROM t220;
+a
+TRUNCATE TABLE t35;
+SELECT a FROM t221;
+a
+TRUNCATE TABLE t34;
+SELECT a FROM t222;
+a
+TRUNCATE TABLE t33;
+SELECT a FROM t223;
+a
+TRUNCATE TABLE t32;
+SELECT a FROM t224;
+a
+TRUNCATE TABLE t31;
+SELECT a FROM t225;
+a
+TRUNCATE TABLE t30;
+SELECT a FROM t226;
+a
+TRUNCATE TABLE t29;
+SELECT a FROM t227;
+a
+TRUNCATE TABLE t28;
+SELECT a FROM t228;
+a
+TRUNCATE TABLE t27;
+SELECT a FROM t229;
+a
+TRUNCATE TABLE t26;
+SELECT a FROM t230;
+a
+TRUNCATE TABLE t25;
+SELECT a FROM t231;
+a
+TRUNCATE TABLE t24;
+SELECT a FROM t232;
+a
+TRUNCATE TABLE t23;
+SELECT a FROM t233;
+a
+TRUNCATE TABLE t22;
+SELECT a FROM t234;
+a
+TRUNCATE TABLE t21;
+SELECT a FROM t235;
+a
+TRUNCATE TABLE t20;
+SELECT a FROM t236;
+a
+TRUNCATE TABLE t19;
+SELECT a FROM t237;
+a
+TRUNCATE TABLE t18;
+SELECT a FROM t238;
+a
+TRUNCATE TABLE t17;
+SELECT a FROM t239;
+a
+TRUNCATE TABLE t16;
+SELECT a FROM t240;
+a
+TRUNCATE TABLE t15;
+SELECT a FROM t241;
+a
+TRUNCATE TABLE t14;
+SELECT a FROM t242;
+a
+TRUNCATE TABLE t13;
+SELECT a FROM t243;
+a
+TRUNCATE TABLE t12;
+SELECT a FROM t244;
+a
+TRUNCATE TABLE t11;
+SELECT a FROM t245;
+a
+TRUNCATE TABLE t10;
+SELECT a FROM t246;
+a
+TRUNCATE TABLE t9;
+SELECT a FROM t247;
+a
+TRUNCATE TABLE t8;
+SELECT a FROM t248;
+a
+TRUNCATE TABLE t7;
+SELECT a FROM t249;
+a
+TRUNCATE TABLE t6;
+SELECT a FROM t250;
+a
+TRUNCATE TABLE t5;
+SELECT a FROM t251;
+a
+TRUNCATE TABLE t4;
+SELECT a FROM t252;
+a
+TRUNCATE TABLE t3;
+SELECT a FROM t253;
+a
+TRUNCATE TABLE t2;
+SELECT a FROM t254;
+a
+TRUNCATE TABLE t1;
+SELECT a FROM t255;
+a
+SELECT a FROM t0;
+a
+DROP TABLE t0;
+DROP TABLE t255;
+DROP TABLE t254;
+DROP TABLE t253;
+DROP TABLE t252;
+DROP TABLE t251;
+DROP TABLE t250;
+DROP TABLE t249;
+DROP TABLE t248;
+DROP TABLE t247;
+DROP TABLE t246;
+DROP TABLE t245;
+DROP TABLE t244;
+DROP TABLE t243;
+DROP TABLE t242;
+DROP TABLE t241;
+DROP TABLE t240;
+DROP TABLE t239;
+DROP TABLE t238;
+DROP TABLE t237;
+DROP TABLE t236;
+DROP TABLE t235;
+DROP TABLE t234;
+DROP TABLE t233;
+DROP TABLE t232;
+DROP TABLE t231;
+DROP TABLE t230;
+DROP TABLE t229;
+DROP TABLE t228;
+DROP TABLE t227;
+DROP TABLE t226;
+DROP TABLE t225;
+DROP TABLE t224;
+DROP TABLE t223;
+DROP TABLE t222;
+DROP TABLE t221;
+DROP TABLE t220;
+DROP TABLE t219;
+DROP TABLE t218;
+DROP TABLE t217;
+DROP TABLE t216;
+DROP TABLE t215;
+DROP TABLE t214;
+DROP TABLE t213;
+DROP TABLE t212;
+DROP TABLE t211;
+DROP TABLE t210;
+DROP TABLE t209;
+DROP TABLE t208;
+DROP TABLE t207;
+DROP TABLE t206;
+DROP TABLE t205;
+DROP TABLE t204;
+DROP TABLE t203;
+DROP TABLE t202;
+DROP TABLE t201;
+DROP TABLE t200;
+DROP TABLE t199;
+DROP TABLE t198;
+DROP TABLE t197;
+DROP TABLE t196;
+DROP TABLE t195;
+DROP TABLE t194;
+DROP TABLE t193;
+DROP TABLE t192;
+DROP TABLE t191;
+DROP TABLE t190;
+DROP TABLE t189;
+DROP TABLE t188;
+DROP TABLE t187;
+DROP TABLE t186;
+DROP TABLE t185;
+DROP TABLE t184;
+DROP TABLE t183;
+DROP TABLE t182;
+DROP TABLE t181;
+DROP TABLE t180;
+DROP TABLE t179;
+DROP TABLE t178;
+DROP TABLE t177;
+DROP TABLE t176;
+DROP TABLE t175;
+DROP TABLE t174;
+DROP TABLE t173;
+DROP TABLE t172;
+DROP TABLE t171;
+DROP TABLE t170;
+DROP TABLE t169;
+DROP TABLE t168;
+DROP TABLE t167;
+DROP TABLE t166;
+DROP TABLE t165;
+DROP TABLE t164;
+DROP TABLE t163;
+DROP TABLE t162;
+DROP TABLE t161;
+DROP TABLE t160;
+DROP TABLE t159;
+DROP TABLE t158;
+DROP TABLE t157;
+DROP TABLE t156;
+DROP TABLE t155;
+DROP TABLE t154;
+DROP TABLE t153;
+DROP TABLE t152;
+DROP TABLE t151;
+DROP TABLE t150;
+DROP TABLE t149;
+DROP TABLE t148;
+DROP TABLE t147;
+DROP TABLE t146;
+DROP TABLE t145;
+DROP TABLE t144;
+DROP TABLE t143;
+DROP TABLE t142;
+DROP TABLE t141;
+DROP TABLE t140;
+DROP TABLE t139;
+DROP TABLE t138;
+DROP TABLE t137;
+DROP TABLE t136;
+DROP TABLE t135;
+DROP TABLE t134;
+DROP TABLE t133;
+DROP TABLE t132;
+DROP TABLE t131;
+DROP TABLE t130;
+DROP TABLE t129;
+DROP TABLE t128;
+DROP TABLE t127;
+DROP TABLE t126;
+DROP TABLE t125;
+DROP TABLE t124;
+DROP TABLE t123;
+DROP TABLE t122;
+DROP TABLE t121;
+DROP TABLE t120;
+DROP TABLE t119;
+DROP TABLE t118;
+DROP TABLE t117;
+DROP TABLE t116;
+DROP TABLE t115;
+DROP TABLE t114;
+DROP TABLE t113;
+DROP TABLE t112;
+DROP TABLE t111;
+DROP TABLE t110;
+DROP TABLE t109;
+DROP TABLE t108;
+DROP TABLE t107;
+DROP TABLE t106;
+DROP TABLE t105;
+DROP TABLE t104;
+DROP TABLE t103;
+DROP TABLE t102;
+DROP TABLE t101;
+DROP TABLE t100;
+DROP TABLE t99;
+DROP TABLE t98;
+DROP TABLE t97;
+DROP TABLE t96;
+DROP TABLE t95;
+DROP TABLE t94;
+DROP TABLE t93;
+DROP TABLE t92;
+DROP TABLE t91;
+DROP TABLE t90;
+DROP TABLE t89;
+DROP TABLE t88;
+DROP TABLE t87;
+DROP TABLE t86;
+DROP TABLE t85;
+DROP TABLE t84;
+DROP TABLE t83;
+DROP TABLE t82;
+DROP TABLE t81;
+DROP TABLE t80;
+DROP TABLE t79;
+DROP TABLE t78;
+DROP TABLE t77;
+DROP TABLE t76;
+DROP TABLE t75;
+DROP TABLE t74;
+DROP TABLE t73;
+DROP TABLE t72;
+DROP TABLE t71;
+DROP TABLE t70;
+DROP TABLE t69;
+DROP TABLE t68;
+DROP TABLE t67;
+DROP TABLE t66;
+DROP TABLE t65;
+DROP TABLE t64;
+DROP TABLE t63;
+DROP TABLE t62;
+DROP TABLE t61;
+DROP TABLE t60;
+DROP TABLE t59;
+DROP TABLE t58;
+DROP TABLE t57;
+DROP TABLE t56;
+DROP TABLE t55;
+DROP TABLE t54;
+DROP TABLE t53;
+DROP TABLE t52;
+DROP TABLE t51;
+DROP TABLE t50;
+DROP TABLE t49;
+DROP TABLE t48;
+DROP TABLE t47;
+DROP TABLE t46;
+DROP TABLE t45;
+DROP TABLE t44;
+DROP TABLE t43;
+DROP TABLE t42;
+DROP TABLE t41;
+DROP TABLE t40;
+DROP TABLE t39;
+DROP TABLE t38;
+DROP TABLE t37;
+DROP TABLE t36;
+DROP TABLE t35;
+DROP TABLE t34;
+DROP TABLE t33;
+DROP TABLE t32;
+DROP TABLE t31;
+DROP TABLE t30;
+DROP TABLE t29;
+DROP TABLE t28;
+DROP TABLE t27;
+DROP TABLE t26;
+DROP TABLE t25;
+DROP TABLE t24;
+DROP TABLE t23;
+DROP TABLE t22;
+DROP TABLE t21;
+DROP TABLE t20;
+DROP TABLE t19;
+DROP TABLE t18;
+DROP TABLE t17;
+DROP TABLE t16;
+DROP TABLE t15;
+DROP TABLE t14;
+DROP TABLE t13;
+DROP TABLE t12;
+DROP TABLE t11;
+DROP TABLE t10;
+DROP TABLE t9;
+DROP TABLE t8;
+DROP TABLE t7;
+DROP TABLE t6;
+DROP TABLE t5;
+DROP TABLE t4;
+DROP TABLE t3;
+DROP TABLE t2;
+DROP TABLE t1;
+SET @@global.query_cache_size = 0;
+End of 5.1 tests
=== modified file 'mysql-test/r/subselect.result'
--- a/mysql-test/r/subselect.result 2008-05-16 14:05:55 +0000
+++ b/mysql-test/r/subselect.result 2008-07-26 20:44:07 +0000
@@ -4396,4 +4396,15 @@ id select_type table type possible_keys
Warnings:
Note 1003 select 1 AS `1` from `test`.`t1` where <in_optimizer>(1,<exists>(select 1 AS `1` from `test`.`t1` where (`test`.`t1`.`a` > 3) group by `test`.`t1`.`a` having (<cache>(1) = <ref_null_helper>(1))))
DROP TABLE t1;
+CREATE TABLE t1(pk int PRIMARY KEY, a int, INDEX idx(a));
+INSERT INTO t1 VALUES (1, 10), (3, 30), (2, 20);
+CREATE TABLE t2(pk int PRIMARY KEY, a int, b int, INDEX idxa(a));
+INSERT INTO t2 VALUES (2, 20, 700), (1, 10, 200), (4, 10, 100);
+SELECT * FROM t1
+WHERE EXISTS (SELECT DISTINCT a FROM t2 WHERE t1.a < t2.a ORDER BY b);
+pk a
+1 10
+3 30
+2 20
+DROP TABLE t1,t2;
End of 5.0 tests.
=== modified file 'mysql-test/t/func_if.test'
--- a/mysql-test/t/func_if.test 2007-02-12 20:59:29 +0000
+++ b/mysql-test/t/func_if.test 2008-07-30 11:07:37 +0000
@@ -108,3 +108,46 @@ drop table t1;
select if(0, 18446744073709551610, 18446744073709551610);
+#
+# Bug #37662: nested if() inside sum() is parsed in exponential time
+#
+
+CREATE TABLE t1(a DECIMAL(10,3));
+
+# check : should be fast. more than few secs means failure.
+SELECT t1.a,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,
+ IF((ROUND(t1.a,2)=1), 2,0)))))))))))))))))))))))))))))) + 1
+FROM t1;
+
+DROP TABLE t1;
+
+--echo End of 5.0 tests
=== modified file 'mysql-test/t/innodb_mysql.test'
--- a/mysql-test/t/innodb_mysql.test 2008-02-07 07:12:49 +0000
+++ b/mysql-test/t/innodb_mysql.test 2008-07-23 11:25:00 +0000
@@ -996,4 +996,22 @@ set @my_innodb_commit_concurrency=@@glob
set global innodb_commit_concurrency=0;
set global innodb_commit_concurrency=@my_innodb_commit_concurrency;
+#
+# Bug #37830: ORDER BY ASC/DESC - no difference
+#
+
+CREATE TABLE t1 (a int, b int, c int, PRIMARY KEY (a), KEY t1_b (b))
+ ENGINE=InnoDB;
+
+INSERT INTO t1 (a,b,c) VALUES (1,1,1), (2,1,1), (3,1,1), (4,1,1);
+INSERT INTO t1 (a,b,c) SELECT a+4,b,c FROM t1;
+
+# should be range access
+EXPLAIN SELECT a, b, c FROM t1 WHERE b = 1 ORDER BY a DESC LIMIT 5;
+
+# should produce '8 7 6 5 4' for a
+SELECT a, b, c FROM t1 WHERE b = 1 ORDER BY a DESC LIMIT 5;
+
+DROP TABLE t1;
+
--echo End of 5.0 tests
=== modified file 'mysql-test/t/query_cache_merge.test'
--- a/mysql-test/t/query_cache_merge.test 2005-07-28 00:22:47 +0000
+++ b/mysql-test/t/query_cache_merge.test 2008-07-24 14:14:34 +0000
@@ -38,3 +38,59 @@ drop table t1,t2,t3,t4,t5,t6,t7,t8,t9,t1
SET @@global.query_cache_size=0;
# End of 4.1 tests
+
+#
+# Bug#33362: Query cache invalidation (truncate) may hang if cached query uses many tables
+#
+
+let $c= 255;
+
+while ($c)
+{
+ eval CREATE TABLE t$c (a INT);
+ eval INSERT INTO t$c VALUES ($c);
+ dec $c;
+}
+
+let $c= 254;
+let $str= t255;
+
+while ($c)
+{
+ let $str= t$c,$str;
+ dec $c;
+}
+
+eval CREATE TABLE t0 (a INT) ENGINE=MERGE UNION($str);
+SET GLOBAL query_cache_size = 1048576;
+FLUSH STATUS;
+SELECT a FROM t0 WHERE a = 1;
+SHOW STATUS LIKE "Qcache_queries_in_cache";
+
+let $c= 255;
+let $i= 1;
+
+FLUSH TABLES;
+
+while ($c)
+{
+ eval TRUNCATE TABLE t$c;
+ eval SELECT a FROM t$i;
+ dec $c;
+ inc $i;
+}
+
+SELECT a FROM t0;
+DROP TABLE t0;
+
+let $c= 255;
+
+while ($c)
+{
+ eval DROP TABLE t$c;
+ dec $c;
+}
+
+SET @@global.query_cache_size = 0;
+
+--echo End of 5.1 tests
=== modified file 'mysql-test/t/subselect.test'
--- a/mysql-test/t/subselect.test 2008-06-25 14:59:38 +0000
+++ b/mysql-test/t/subselect.test 2008-07-26 20:44:07 +0000
@@ -3295,5 +3295,17 @@ EXPLAIN EXTENDED SELECT 1 FROM t1 WHERE
EXPLAIN EXTENDED SELECT 1 FROM t1 WHERE 1 IN (SELECT 1 FROM t1 WHERE a > 3 GROUP BY a);
DROP TABLE t1;
+#
+# Bug #38191: Server crash with subquery containing DISTINCT and ORDER BY
+#
+
+CREATE TABLE t1(pk int PRIMARY KEY, a int, INDEX idx(a));
+INSERT INTO t1 VALUES (1, 10), (3, 30), (2, 20);
+CREATE TABLE t2(pk int PRIMARY KEY, a int, b int, INDEX idxa(a));
+INSERT INTO t2 VALUES (2, 20, 700), (1, 10, 200), (4, 10, 100);
+SELECT * FROM t1
+ WHERE EXISTS (SELECT DISTINCT a FROM t2 WHERE t1.a < t2.a ORDER BY b);
+DROP TABLE t1,t2;
+
--echo End of 5.0 tests.
=== modified file 'mysys/mf_keycache.c'
--- a/mysys/mf_keycache.c 2008-03-29 15:50:46 +0000
+++ b/mysys/mf_keycache.c 2008-08-11 21:08:12 +0000
@@ -1382,7 +1382,7 @@ restart:
/* We don't need the page in the cache: we are going to write on disk */
hash_link->requests--;
unlink_hash(keycache, hash_link);
- return 0;
+ DBUG_RETURN(0);
}
if (!(block->status & BLOCK_IN_FLUSH))
{
@@ -1399,7 +1399,7 @@ restart:
flag (see the code below that handles reading requests).
*/
free_block(keycache, block);
- return 0;
+ DBUG_RETURN(0);
}
/* Wait intil the page is flushed on disk */
hash_link->requests--;
@@ -1429,7 +1429,7 @@ restart:
/* Invalidate page in the block if it has not been done yet */
if (block->status)
free_block(keycache, block);
- return 0;
+ DBUG_RETURN(0);
}
if (page_status == PAGE_READ &&
=== modified file 'mysys/my_alloc.c'
--- a/mysys/my_alloc.c 2007-04-18 20:50:32 +0000
+++ b/mysys/my_alloc.c 2008-08-11 16:10:00 +0000
@@ -202,7 +202,7 @@ gptr alloc_root(MEM_ROOT *mem_root,unsig
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
- return((gptr) 0); /* purecov: inspected */
+ DBUG_RETURN((gptr) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
=== modified file 'scripts/mysql_system_tables.sql'
--- a/scripts/mysql_system_tables.sql 2007-04-26 14:48:53 +0000
+++ b/scripts/mysql_system_tables.sql 2008-07-31 09:28:04 +0000
@@ -2,6 +2,7 @@
-- The system tables of MySQL Server
--
+set sql_mode='';
set storage_engine=myisam;
CREATE TABLE IF NOT EXISTS db ( Host char(60) binary DEFAULT '' NOT NULL, Db char(64) binary DEFAULT '' NOT NULL, User char(16) binary DEFAULT '' NOT NULL, Select_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Insert_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Update_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Delete_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Create_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Drop_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Grant_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, References_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Index_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Alter_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Create_tmp_table_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Lock_tables_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Create_view_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Show_view_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Create_routine_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Alter_routine_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, Execute_priv enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL, PRIMARY KEY Host (Host,Db,User), KEY User (User) ) engine=MyISAM CHARACTER SET utf8 COLLATE utf8_bin comment='Database privileges';
=== modified file 'sql/field.h'
--- a/sql/field.h 2008-05-06 16:43:46 +0000
+++ b/sql/field.h 2008-08-11 16:10:00 +0000
@@ -48,7 +48,8 @@ class Field
Field(const Item &); /* Prevent use of these */
void operator=(Field &);
public:
- static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
+ static void *operator new(size_t size) throw ()
+ { return (void*) sql_alloc((uint) size); }
static void operator delete(void *ptr_arg, size_t size) { TRASH(ptr_arg, size); }
char *ptr; // Position to field in record
=== modified file 'sql/item.cc'
--- a/sql/item.cc 2008-06-27 15:56:41 +0000
+++ b/sql/item.cc 2008-07-30 11:07:37 +0000
@@ -429,8 +429,11 @@ uint Item::decimal_precision() const
Item_result restype= result_type();
if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))
- return min(my_decimal_length_to_precision(max_length, decimals, unsigned_flag),
- DECIMAL_MAX_PRECISION);
+ {
+ uint prec=
+ my_decimal_length_to_precision(max_length, decimals, unsigned_flag);
+ return min(prec, DECIMAL_MAX_PRECISION);
+ }
return min(max_length, DECIMAL_MAX_PRECISION);
}
@@ -6838,8 +6841,9 @@ bool Item_type_holder::join_types(THD *t
if (Field::result_merge_type(fld_type) == DECIMAL_RESULT)
{
decimals= min(max(decimals, item->decimals), DECIMAL_MAX_SCALE);
- int precision= min(max(prev_decimal_int_part, item->decimal_int_part())
- + decimals, DECIMAL_MAX_PRECISION);
+ int item_int_part= item->decimal_int_part();
+ int item_prec = max(prev_decimal_int_part, item_int_part) + decimals;
+ int precision= min(item_prec, DECIMAL_MAX_PRECISION);
unsigned_flag&= item->unsigned_flag;
max_length= my_decimal_precision_to_length(precision, decimals,
unsigned_flag);
=== modified file 'sql/item.h'
--- a/sql/item.h 2008-03-12 07:59:15 +0000
+++ b/sql/item.h 2008-08-11 16:10:00 +0000
@@ -439,9 +439,9 @@ class Item {
Item(const Item &); /* Prevent use of these */
void operator=(Item &);
public:
- static void *operator new(size_t size)
+ static void *operator new(size_t size) throw ()
{ return (void*) sql_alloc((uint) size); }
- static void *operator new(size_t size, MEM_ROOT *mem_root)
+ static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return (void*) alloc_root(mem_root, (uint) size); }
static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
=== modified file 'sql/item_cmpfunc.cc'
--- a/sql/item_cmpfunc.cc 2008-03-28 18:02:27 +0000
+++ b/sql/item_cmpfunc.cc 2008-07-30 11:07:37 +0000
@@ -2098,8 +2098,11 @@ Item_func_ifnull::fix_length_and_dec()
uint Item_func_ifnull::decimal_precision() const
{
- int max_int_part=max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
- return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
+ int arg0_int_part= args[0]->decimal_int_part();
+ int arg1_int_part= args[1]->decimal_int_part();
+ int max_int_part= max(arg0_int_part, arg1_int_part);
+ int precision= max_int_part + decimals;
+ return min(precision, DECIMAL_MAX_PRECISION);
}
@@ -2281,8 +2284,9 @@ Item_func_if::fix_length_and_dec()
uint Item_func_if::decimal_precision() const
{
- int precision=(max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
- decimals);
+ int arg1_prec= args[1]->decimal_int_part();
+ int arg2_prec= args[2]->decimal_int_part();
+ int precision=max(arg1_prec,arg2_prec) + decimals;
return min(precision, DECIMAL_MAX_PRECISION);
}
=== modified file 'sql/item_func.cc'
--- a/sql/item_func.cc 2008-03-29 15:50:46 +0000
+++ b/sql/item_func.cc 2008-07-30 11:07:37 +0000
@@ -1156,9 +1156,10 @@ my_decimal *Item_func_plus::decimal_op(m
void Item_func_additive_op::result_precision()
{
decimals= max(args[0]->decimals, args[1]->decimals);
- int max_int_part= max(args[0]->decimal_precision() - args[0]->decimals,
- args[1]->decimal_precision() - args[1]->decimals);
- int precision= min(max_int_part + 1 + decimals, DECIMAL_MAX_PRECISION);
+ int arg1_int= args[0]->decimal_precision() - args[0]->decimals;
+ int arg2_int= args[1]->decimal_precision() - args[1]->decimals;
+ int est_prec= max(arg1_int, arg2_int) + 1 + decimals;
+ int precision= min(est_prec, DECIMAL_MAX_PRECISION);
/* Integer operations keep unsigned_flag if one of arguments is unsigned */
if (result_type() == INT_RESULT)
@@ -1267,8 +1268,8 @@ void Item_func_mul::result_precision()
else
unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
decimals= min(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE);
- int precision= min(args[0]->decimal_precision() + args[1]->decimal_precision(),
- DECIMAL_MAX_PRECISION);
+ uint est_prec = args[0]->decimal_precision() + args[1]->decimal_precision();
+ uint precision= min(est_prec, DECIMAL_MAX_PRECISION);
max_length= my_decimal_precision_to_length(precision, decimals,unsigned_flag);
}
@@ -1315,8 +1316,8 @@ my_decimal *Item_func_div::decimal_op(my
void Item_func_div::result_precision()
{
- uint precision=min(args[0]->decimal_precision() + prec_increment,
- DECIMAL_MAX_PRECISION);
+ uint arg_prec= args[0]->decimal_precision() + prec_increment;
+ uint precision=min(arg_prec, DECIMAL_MAX_PRECISION);
/* Integer operations keep unsigned_flag if one of arguments is unsigned */
if (result_type() == INT_RESULT)
unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
=== modified file 'sql/opt_range.cc'
--- a/sql/opt_range.cc 2008-07-15 14:13:21 +0000
+++ b/sql/opt_range.cc 2008-07-23 11:25:00 +0000
@@ -7099,7 +7099,8 @@ bool QUICK_RANGE_SELECT::row_in_ranges()
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
uint used_key_parts_arg)
- : QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
+ : QUICK_RANGE_SELECT(*q), rev_it(rev_ranges),
+ used_key_parts (used_key_parts_arg)
{
QUICK_RANGE *r;
@@ -7141,10 +7142,11 @@ int QUICK_SELECT_DESC::get_next()
int result;
if (last_range)
{ // Already read through key
- result = ((last_range->flag & EQ_RANGE)
- ? file->index_next_same(record, (byte*) last_range->min_key,
- last_range->min_length) :
- file->index_prev(record));
+ result = ((last_range->flag & EQ_RANGE &&
+ used_key_parts <= head->key_info[index].key_parts) ?
+ file->index_next_same(record, (byte*) last_range->min_key,
+ last_range->min_length) :
+ file->index_prev(record));
if (!result)
{
if (cmp_prev(*rev_it.ref()) == 0)
@@ -7168,7 +7170,9 @@ int QUICK_SELECT_DESC::get_next()
continue;
}
- if (last_range->flag & EQ_RANGE)
+ if (last_range->flag & EQ_RANGE &&
+ used_key_parts <= head->key_info[index].key_parts)
+
{
result= file->index_read(record, (byte*) last_range->max_key,
last_range->max_length, HA_READ_KEY_EXACT);
@@ -7176,6 +7180,8 @@ int QUICK_SELECT_DESC::get_next()
else
{
DBUG_ASSERT(last_range->flag & NEAR_MAX ||
+ (last_range->flag & EQ_RANGE &&
+ used_key_parts > head->key_info[index].key_parts) ||
range_reads_after_key(last_range));
result=file->index_read(record, (byte*) last_range->max_key,
last_range->max_length,
@@ -7273,54 +7279,6 @@ bool QUICK_SELECT_DESC::range_reads_afte
}
-/* TRUE if we are reading over a key that may have a NULL value */
-
-#ifdef NOT_USED
-bool QUICK_SELECT_DESC::test_if_null_range(QUICK_RANGE *range_arg,
- uint used_key_parts)
-{
- uint offset, end;
- KEY_PART *key_part = key_parts,
- *key_part_end= key_part+used_key_parts;
-
- for (offset= 0, end = min(range_arg->min_length, range_arg->max_length) ;
- offset < end && key_part != key_part_end ;
- offset+= key_part++->store_length)
- {
- if (!memcmp((char*) range_arg->min_key+offset,
- (char*) range_arg->max_key+offset,
- key_part->store_length))
- continue;
-
- if (key_part->null_bit && range_arg->min_key[offset])
- return 1; // min_key is null and max_key isn't
- // Range doesn't cover NULL. This is ok if there is no more null parts
- break;
- }
- /*
- If the next min_range is > NULL, then we can use this, even if
- it's a NULL key
- Example: SELECT * FROM t1 WHERE a = 2 AND b >0 ORDER BY a DESC,b DESC;
-
- */
- if (key_part != key_part_end && key_part->null_bit)
- {
- if (offset >= range_arg->min_length || range_arg->min_key[offset])
- return 1; // Could be null
- key_part++;
- }
- /*
- If any of the key parts used in the ORDER BY could be NULL, we can't
- use the key to sort the data.
- */
- for (; key_part != key_part_end ; key_part++)
- if (key_part->null_bit)
- return 1; // Covers null part
- return 0;
-}
-#endif
-
-
void QUICK_RANGE_SELECT::add_info_string(String *str)
{
KEY *key_info= head->key_info + index;
=== modified file 'sql/opt_range.h'
--- a/sql/opt_range.h 2007-02-21 12:07:08 +0000
+++ b/sql/opt_range.h 2008-07-23 11:25:00 +0000
@@ -667,12 +667,10 @@ public:
int get_type() { return QS_TYPE_RANGE_DESC; }
private:
bool range_reads_after_key(QUICK_RANGE *range);
-#ifdef NOT_USED
- bool test_if_null_range(QUICK_RANGE *range, uint used_key_parts);
-#endif
int reset(void) { rev_it.rewind(); return QUICK_RANGE_SELECT::reset(); }
List<QUICK_RANGE> rev_ranges;
List_iterator<QUICK_RANGE> rev_it;
+ uint used_key_parts;
};
=== modified file 'sql/share/errmsg.txt'
--- a/sql/share/errmsg.txt 2008-07-16 22:29:22 +0000
+++ b/sql/share/errmsg.txt 2008-07-29 13:58:15 +0000
@@ -4737,7 +4737,7 @@ ER_SLAVE_IGNORED_TABLE
swe "Slav SQL tr�n ignorerade fr�n pga en replicate-*-table regel"
ER_INCORRECT_GLOBAL_LOCAL_VAR
eng "Variable '%-.64s' is a %s variable"
- serbian "Incorrect foreign key definition for '%-.64s': %s"
+ serbian "Promenljiva '%-.64s' je %s promenljiva"
ger "Variable '%-.64s' ist eine %s-Variable"
spa "Variable '%-.64s' es una %s variable"
swe "Variabel '%-.64s' �av typ %s"
=== modified file 'sql/sp_head.cc'
--- a/sql/sp_head.cc 2008-07-14 21:41:30 +0000
+++ b/sql/sp_head.cc 2008-08-11 16:10:00 +0000
@@ -446,7 +446,7 @@ sp_head::operator new(size_t size) throw
init_sql_alloc(&own_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
sp= (sp_head *) alloc_root(&own_root, size);
if (sp == NULL)
- return NULL;
+ DBUG_RETURN(NULL);
sp->main_mem_root= own_root;
DBUG_PRINT("info", ("mem_root 0x%lx", (ulong) &sp->mem_root));
DBUG_RETURN(sp);
=== modified file 'sql/sql_acl.cc'
--- a/sql/sql_acl.cc 2008-07-15 14:13:21 +0000
+++ b/sql/sql_acl.cc 2008-07-29 13:37:09 +0000
@@ -5430,7 +5430,6 @@ bool mysql_drop_user(THD *thd, List <LEX
while ((tmp_user_name= user_list++))
{
- user_name= get_current_user(thd, tmp_user_name);
if (!(user_name= get_current_user(thd, tmp_user_name)))
{
result= TRUE;
=== modified file 'sql/sql_cache.cc'
--- a/sql/sql_cache.cc 2008-07-16 22:29:22 +0000
+++ b/sql/sql_cache.cc 2008-07-24 14:14:34 +0000
@@ -2516,7 +2516,7 @@ my_bool Query_cache::register_all_tables
tmp++)
unlink_table(tmp);
}
- return (n);
+ return test(n);
}
/*
=== modified file 'sql/sql_cursor.cc'
--- a/sql/sql_cursor.cc 2008-02-20 19:45:24 +0000
+++ b/sql/sql_cursor.cc 2008-08-11 09:40:54 +0000
@@ -111,7 +111,8 @@ class Select_materialize: public select_
select_result *result; /* the result object of the caller (PS or SP) */
public:
Materialized_cursor *materialized_cursor;
- Select_materialize(select_result *result_arg) :result(result_arg) {}
+ Select_materialize(select_result *result_arg) :result(result_arg),
+ materialized_cursor(0) {}
virtual bool send_fields(List<Item> &list, uint flags);
};
@@ -155,6 +156,7 @@ int mysql_open_cursor(THD *thd, uint fla
if (! (sensitive_cursor= new (thd->mem_root) Sensitive_cursor(thd, result)))
{
delete result_materialize;
+ result_materialize= NULL;
return 1;
}
@@ -212,6 +214,7 @@ int mysql_open_cursor(THD *thd, uint fla
if ((rc= materialized_cursor->open(0)))
{
delete materialized_cursor;
+ materialized_cursor= NULL;
goto err_open;
}
=== modified file 'sql/sql_lex.h'
--- a/sql/sql_lex.h 2008-07-14 21:41:30 +0000
+++ b/sql/sql_lex.h 2008-08-11 16:10:00 +0000
@@ -331,11 +331,11 @@ public:
bool no_table_names_allowed; /* used for global order by */
bool no_error; /* suppress error message (convert it to warnings) */
- static void *operator new(size_t size)
+ static void *operator new(size_t size) throw ()
{
return (void*) sql_alloc((uint) size);
}
- static void *operator new(size_t size, MEM_ROOT *mem_root)
+ static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return (void*) alloc_root(mem_root, (uint) size); }
static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
=== modified file 'sql/sql_list.h'
--- a/sql/sql_list.h 2007-03-29 06:35:28 +0000
+++ b/sql/sql_list.h 2008-08-11 16:10:00 +0000
@@ -27,7 +27,7 @@ public:
{
return (void*) sql_alloc((uint) size);
}
- static void *operator new[](size_t size)
+ static void *operator new[](size_t size) throw ()
{
return (void*) sql_alloc((uint) size);
}
@@ -466,7 +466,7 @@ public:
struct ilink
{
struct ilink **prev,*next;
- static void *operator new(size_t size)
+ static void *operator new(size_t size) throw ()
{
return (void*)my_malloc((uint)size, MYF(MY_WME | MY_FAE));
}
=== modified file 'sql/sql_parse.cc'
--- a/sql/sql_parse.cc 2008-07-14 21:41:30 +0000
+++ b/sql/sql_parse.cc 2008-07-29 13:15:04 +0000
@@ -7069,11 +7069,23 @@ bool reload_acl_and_cache(THD *thd, ulon
thd->thread_stack= (char*) &tmp_thd;
thd->store_globals();
}
+
if (thd)
{
- (void)acl_reload(thd);
- (void)grant_reload(thd);
+ bool reload_acl_failed= acl_reload(thd);
+ bool reload_grants_failed= grant_reload(thd);
+
+ if (reload_acl_failed || reload_grants_failed)
+ {
+ result= 1;
+ /*
+ When an error is returned, my_message may have not been called and
+ the client will hang waiting for a response.
+ */
+ my_error(ER_UNKNOWN_ERROR, MYF(0), "FLUSH PRIVILEGES failed");
+ }
}
+
if (tmp_thd)
{
delete tmp_thd;
@@ -7159,8 +7171,10 @@ bool reload_acl_and_cache(THD *thd, ulon
tmp_write_to_binlog= 0;
if (lock_global_read_lock(thd))
return 1; // Killed
- result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
- tables);
+ if (close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
+ tables))
+ result= 1;
+
if (make_global_read_lock_block_commit(thd)) // Killed
{
/* Don't leave things in a half-locked state */
@@ -7169,7 +7183,10 @@ bool reload_acl_and_cache(THD *thd, ulon
}
}
else
- result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
+ {
+ if (close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables))
+ result= 1;
+ }
my_dbopt_cleanup();
}
if (options & REFRESH_HOSTS)
@@ -7193,8 +7210,8 @@ bool reload_acl_and_cache(THD *thd, ulon
#ifdef OPENSSL
if (options & REFRESH_DES_KEY_FILE)
{
- if (des_key_file)
- result=load_des_key_file(des_key_file);
+ if (des_key_file && load_des_key_file(des_key_file))
+ result= 1;
}
#endif
#ifdef HAVE_REPLICATION
=== modified file 'sql/sql_select.cc'
--- a/sql/sql_select.cc 2008-07-15 14:13:21 +0000
+++ b/sql/sql_select.cc 2008-07-28 08:24:56 +0000
@@ -6469,6 +6469,12 @@ void JOIN::cleanup(bool full)
if (tmp_join)
tmp_table_param.copy_field= 0;
group_fields.delete_elements();
+ /*
+ Ensure that the above delete_elements() would not be called
+ twice for the same list.
+ */
+ if (tmp_join && tmp_join != this)
+ tmp_join->group_fields= group_fields;
/*
We can't call delete_elements() on copy_funcs as this will cause
problems in free_elements() as some of the elements are then deleted.
@@ -12088,26 +12094,25 @@ part_of_refkey(TABLE *table,Field *field
}
-/*****************************************************************************
- Test if one can use the key to resolve ORDER BY
-
- SYNOPSIS
- test_if_order_by_key()
- order Sort order
- table Table to sort
- idx Index to check
- used_key_parts Return value for used key parts.
-
-
- NOTES
- used_key_parts is set to correct key parts used if return value != 0
- (On other cases, used_key_part may be changed)
+/**
+ Test if a key can be used to resolve ORDER BY
- RETURN
- 1 key is ok.
- 0 Key can't be used
- -1 Reverse key can be used
-*****************************************************************************/
+ used_key_parts is set to correct key parts used if return value != 0
+ (On other cases, used_key_part may be changed).
+ Note that the value may actually be greater than the number of index
+ key parts. This can happen for storage engines that have the primary
+ key parts as a suffix for every secondary key.
+
+ @param order Sort order
+ @param table Table to sort
+ @param idx Index to check
+ @param[out] used_key_parts Return value for used key parts.
+
+ @return indication if the key can be used for sorting
+ @retval 1 key can be used for reading data in order.
+ @retval 0 Key can't be used
+ @retval -1 Reverse read on the key can be used
+*/
static int test_if_order_by_key(ORDER *order, TABLE *table, uint idx,
uint *used_key_parts)
@@ -12172,11 +12177,27 @@ static int test_if_order_by_key(ORDER *o
reverse=flag; // Remember if reverse
key_part++;
}
- *used_key_parts= on_primary_key ? table->key_info[idx].key_parts :
- (uint) (key_part - table->key_info[idx].key_part);
- if (reverse == -1 && !(table->file->index_flags(idx, *used_key_parts-1, 1) &
- HA_READ_PREV))
- reverse= 0; // Index can't be used
+ if (on_primary_key)
+ {
+ uint used_key_parts_secondary= table->key_info[idx].key_parts;
+ uint used_key_parts_pk=
+ (uint) (key_part - table->key_info[table->s->primary_key].key_part);
+ *used_key_parts= used_key_parts_pk + used_key_parts_secondary;
+
+ if (reverse == -1 &&
+ (!(table->file->index_flags(idx, used_key_parts_secondary - 1, 1) &
+ HA_READ_PREV) ||
+ !(table->file->index_flags(table->s->primary_key,
+ used_key_parts_pk - 1, 1) & HA_READ_PREV)))
+ reverse= 0; // Index can't be used
+ }
+ else
+ {
+ *used_key_parts= (uint) (key_part - table->key_info[idx].key_part);
+ if (reverse == -1 &&
+ !(table->file->index_flags(idx, *used_key_parts-1, 1) & HA_READ_PREV))
+ reverse= 0; // Index can't be used
+ }
DBUG_RETURN(reverse);
}
=== modified file 'sql/sql_string.h'
--- a/sql/sql_string.h 2007-01-22 12:10:46 +0000
+++ b/sql/sql_string.h 2008-08-11 16:10:00 +0000
@@ -78,7 +78,7 @@ public:
Alloced_length=str.Alloced_length; alloced=0;
str_charset=str.str_charset;
}
- static void *operator new(size_t size, MEM_ROOT *mem_root)
+ static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return (void*) alloc_root(mem_root, (uint) size); }
static void operator delete(void *ptr_arg,size_t size)
{ TRASH(ptr_arg, size); }
=== modified file 'sql/sql_yacc.yy'
--- a/sql/sql_yacc.yy 2008-07-14 21:41:30 +0000
+++ b/sql/sql_yacc.yy 2008-08-11 16:10:00 +0000
@@ -1540,6 +1540,8 @@ create:
{
LEX *lex=Lex;
Key *key= new Key($2, $4.str, $5, 0, lex->col_list);
+ if (key == NULL)
+ MYSQL_YYABORT;
lex->alter_info.key_list.push_back(key);
lex->col_list.empty();
@@ -1599,6 +1601,8 @@ sp_name:
MYSQL_YYABORT;
}
$$= new sp_name($1, $3, true);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
$$->init_qname(YYTHD);
}
| ident
@@ -1614,8 +1618,9 @@ sp_name:
if (lex->copy_db_to(&db.str, &db.length))
MYSQL_YYABORT;
$$= new sp_name(db, $1, false);
- if ($$)
- $$->init_qname(YYTHD);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ $$->init_qname(YYTHD);
}
;
@@ -1866,6 +1871,8 @@ sp_decl:
if (!dflt_value_item)
{
dflt_value_item= new Item_null();
+ if (dflt_value_item == NULL)
+ MYSQL_YYABORT;
/* QQ Set to the var_type with null_value? */
}
@@ -1891,10 +1898,17 @@ sp_decl:
/* The last instruction is responsible for freeing LEX. */
- lex->sphead->add_instr(
- new sp_instr_set(lex->sphead->instructions(), pctx, var_idx,
- dflt_value_item, var_type, lex,
- (i == num_vars - 1)));
+ sp_instr_set *is= new sp_instr_set(lex->sphead->instructions(),
+ pctx,
+ var_idx,
+ dflt_value_item,
+ var_type,
+ lex,
+ (i == num_vars - 1));
+ if (is == NULL)
+ MYSQL_YYABORT;
+
+ lex->sphead->add_instr(is);
}
pctx->declare_var_boundary(0);
@@ -1928,6 +1942,8 @@ sp_decl:
sp_instr_hpush_jump *i=
new sp_instr_hpush_jump(sp->instructions(), ctx, $2,
ctx->current_var_count());
+ if (i == NULL)
+ MYSQL_YYABORT;
sp->add_instr(i);
sp->push_backpatch(i, ctx->push_label((char *)"", 0));
@@ -1980,7 +1996,7 @@ sp_decl:
}
i= new sp_instr_cpush(sp->instructions(), ctx, $5,
ctx->current_cursor_count());
- if ( i==NULL )
+ if (i == NULL)
MYSQL_YYABORT;
sp->add_instr(i);
ctx->push_cursor(&$2);
@@ -2061,6 +2077,8 @@ sp_cond:
ulong_num
{ /* mysql errno */
$$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
+ if ($$ == NULL)
+ YYABORT;
$$->type= sp_cond_type_t::number;
$$->mysqlerr= $1;
}
@@ -2072,6 +2090,8 @@ sp_cond:
MYSQL_YYABORT;
}
$$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
+ if ($$ == NULL)
+ YYABORT;
$$->type= sp_cond_type_t::state;
memcpy($$->sqlstate, $3.str, 5);
$$->sqlstate[5]= '\0';
@@ -2100,16 +2120,22 @@ sp_hcond:
| SQLWARNING_SYM /* SQLSTATEs 01??? */
{
$$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
+ if ($$ == NULL)
+ YYABORT;
$$->type= sp_cond_type_t::warning;
}
| not FOUND_SYM /* SQLSTATEs 02??? */
{
$$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
+ if ($$ == NULL)
+ YYABORT;
$$->type= sp_cond_type_t::notfound;
}
| SQLEXCEPTION_SYM /* All other SQLSTATEs */
{
$$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
+ if ($$ == NULL)
+ YYABORT;
$$->type= sp_cond_type_t::exception;
}
;
@@ -3085,6 +3111,8 @@ key_def:
{
LEX *lex=Lex;
Key *key= new Key($1, $2, $7 ? $7 : $3, 0, lex->col_list);
+ if (key == NULL)
+ MYSQL_YYABORT;
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */
@@ -3094,6 +3122,8 @@ key_def:
LEX *lex=Lex;
const char *key_name= $3 ? $3:$1;
Key *key= new Key($2, key_name, $4, 0, lex->col_list);
+ if (key == NULL)
+ MYSQL_YYABORT;
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */
}
@@ -3107,10 +3137,14 @@ key_def:
lex->fk_delete_opt,
lex->fk_update_opt,
lex->fk_match_option);
+ if (key == NULL)
+ MYSQL_YYABORT;
lex->alter_info.key_list.push_back(key);
key= new Key(Key::MULTIPLE, key_name,
HA_KEY_ALG_UNDEF, 1,
lex->col_list);
+ if (key == NULL)
+ MYSQL_YYABORT;
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */
}
@@ -3400,7 +3434,12 @@ attribute:
;
now_or_signed_literal:
- NOW_SYM optional_braces { $$= new Item_func_now_local(); }
+ NOW_SYM optional_braces
+ {
+ $$= new Item_func_now_local();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| signed_literal { $$=$1; }
;
@@ -3526,8 +3565,21 @@ opt_ref_list:
| '(' ref_list ')' opt_on_delete {};
ref_list:
- ref_list ',' ident { Lex->ref_list.push_back(new key_part_spec($3.str)); }
- | ident { Lex->ref_list.push_back(new key_part_spec($1.str)); };
+ ref_list ',' ident
+ {
+ key_part_spec *key= new key_part_spec($3.str);
+ if (key == NULL)
+ MYSQL_YYABORT;
+ Lex->ref_list.push_back(key);
+ }
+ | ident
+ {
+ key_part_spec *key= new key_part_spec($1.str);
+ if (key == NULL)
+ MYSQL_YYABORT;
+ Lex->ref_list.push_back(key);
+ }
+ ;
opt_on_delete:
@@ -3618,16 +3670,24 @@ key_list:
| key_part order_dir { Lex->col_list.push_back($1); };
key_part:
- ident { $$=new key_part_spec($1.str); }
- | ident '(' NUM ')'
- {
- int key_part_len= atoi($3.str);
- if (!key_part_len)
+ ident
{
- my_error(ER_KEY_PART_0, MYF(0), $1.str);
+ $$= new key_part_spec($1.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
- $$=new key_part_spec($1.str,(uint) key_part_len);
- };
+ | ident '(' NUM ')'
+ {
+ int key_part_len= atoi($3.str);
+ if (!key_part_len)
+ {
+ my_error(ER_KEY_PART_0, MYF(0), $1.str);
+ }
+ $$=new key_part_spec($1.str,(uint) key_part_len);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ ;
opt_ident:
/* empty */ { $$=(char*) 0; } /* Defaultlength */
@@ -3797,8 +3857,10 @@ alter_list_item:
| DROP opt_column field_ident opt_restrict
{
LEX *lex=Lex;
- lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::COLUMN,
- $3.str));
+ Alter_drop *ad= new Alter_drop(Alter_drop::COLUMN, $3.str);
+ if (ad == NULL)
+ MYSQL_YYABORT;
+ lex->alter_info.drop_list.push_back(ad);
lex->alter_info.flags|= ALTER_DROP_COLUMN;
}
| DROP FOREIGN KEY_SYM opt_ident
@@ -3808,15 +3870,19 @@ alter_list_item:
| DROP PRIMARY_SYM KEY_SYM
{
LEX *lex=Lex;
- lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::KEY,
- primary_key_name));
+ Alter_drop *ad= new Alter_drop(Alter_drop::KEY, primary_key_name);
+ if (ad == NULL)
+ MYSQL_YYABORT;
+ lex->alter_info.drop_list.push_back(ad);
lex->alter_info.flags|= ALTER_DROP_INDEX;
}
| DROP key_or_index field_ident
{
LEX *lex=Lex;
- lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::KEY,
- $3.str));
+ Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $3.str);
+ if (ad == NULL)
+ MYSQL_YYABORT;
+ lex->alter_info.drop_list.push_back(ad);
lex->alter_info.flags|= ALTER_DROP_INDEX;
}
| DISABLE_SYM KEYS
@@ -3834,14 +3900,19 @@ alter_list_item:
| ALTER opt_column field_ident SET DEFAULT signed_literal
{
LEX *lex=Lex;
- lex->alter_info.alter_list.push_back(new Alter_column($3.str,$6));
+ Alter_column *ac= new Alter_column($3.str, $6);
+ if (ac == NULL)
+ MYSQL_YYABORT;
+ lex->alter_info.alter_list.push_back(ac);
lex->alter_info.flags|= ALTER_CHANGE_COLUMN_DEFAULT;
}
| ALTER opt_column field_ident DROP DEFAULT
{
LEX *lex=Lex;
- lex->alter_info.alter_list.push_back(new Alter_column($3.str,
- (Item*) 0));
+ Alter_column *ac= new Alter_column($3.str, (Item*) 0);
+ if (ac == NULL)
+ MYSQL_YYABORT;
+ lex->alter_info.alter_list.push_back(ac);
lex->alter_info.flags|= ALTER_CHANGE_COLUMN_DEFAULT;
}
| RENAME opt_to table_ident
@@ -4467,10 +4538,11 @@ select_item_list:
| '*'
{
THD *thd= YYTHD;
- if (add_item_to_list(thd,
- new Item_field(&thd->lex->current_select->
- context,
- NULL, NULL, "*")))
+ Item *item= new Item_field(&thd->lex->current_select->context,
+ NULL, NULL, "*");
+ if (item == NULL)
+ MYSQL_YYABORT;
+ if (add_item_to_list(thd, item))
MYSQL_YYABORT;
(thd->lex->current_select->with_wild)++;
};
@@ -4577,12 +4649,16 @@ expr:
{
/* X OR Y */
$$ = new (YYTHD->mem_root) Item_cond_or($1, $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
}
| expr XOR expr %prec XOR
{
/* XOR is a proprietary extension */
$$ = new (YYTHD->mem_root) Item_cond_xor($1, $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| expr and expr %prec AND_SYM
{
@@ -4623,62 +4699,124 @@ expr:
{
/* X AND Y */
$$ = new (YYTHD->mem_root) Item_cond_and($1, $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
}
| NOT_SYM expr %prec NOT_SYM
- { $$= negate_expression(YYTHD, $2); }
+ {
+ $$= negate_expression(YYTHD, $2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS TRUE_SYM %prec IS
- { $$= new (YYTHD->mem_root) Item_func_istrue($1); }
+ {
+ $$= new (YYTHD->mem_root) Item_func_istrue($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS not TRUE_SYM %prec IS
- { $$= new (YYTHD->mem_root) Item_func_isnottrue($1); }
+ {
+ $$= new (YYTHD->mem_root) Item_func_isnottrue($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS FALSE_SYM %prec IS
- { $$= new (YYTHD->mem_root) Item_func_isfalse($1); }
+ {
+ $$= new (YYTHD->mem_root) Item_func_isfalse($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS not FALSE_SYM %prec IS
- { $$= new (YYTHD->mem_root) Item_func_isnotfalse($1); }
+ {
+ $$= new (YYTHD->mem_root) Item_func_isnotfalse($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS UNKNOWN_SYM %prec IS
- { $$= new Item_func_isnull($1); }
+ {
+ $$= new Item_func_isnull($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS not UNKNOWN_SYM %prec IS
- { $$= new Item_func_isnotnull($1); }
+ {
+ $$= new Item_func_isnotnull($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri
;
bool_pri:
bool_pri IS NULL_SYM %prec IS
- { $$= new Item_func_isnull($1); }
+ {
+ $$= new Item_func_isnull($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri IS not NULL_SYM %prec IS
- { $$= new Item_func_isnotnull($1); }
+ {
+ $$= new Item_func_isnotnull($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri EQUAL_SYM predicate %prec EQUAL_SYM
- { $$= new Item_func_equal($1,$3); }
+ {
+ $$= new Item_func_equal($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri comp_op predicate %prec EQ
- { $$= (*$2)(0)->create($1,$3); }
+ {
+ $$= (*$2)(0)->create($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bool_pri comp_op all_or_any '(' subselect ')' %prec EQ
- { $$= all_any_subquery_creator($1, $2, $3, $5); }
+ {
+ $$= all_any_subquery_creator($1, $2, $3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| predicate ;
predicate:
bit_expr IN_SYM '(' subselect ')'
{
$$= new (YYTHD->mem_root) Item_in_subselect($1, $4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| bit_expr not IN_SYM '(' subselect ')'
{
THD *thd= YYTHD;
Item *item= new (thd->mem_root) Item_in_subselect($1, $5);
+ if (item == NULL)
+ MYSQL_YYABORT;
$$= negate_expression(thd, item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| bit_expr IN_SYM '(' expr ')'
{
$$= handle_sql2003_note184_exception(YYTHD, $1, true, $4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| bit_expr IN_SYM '(' expr ',' expr_list ')'
{
$6->push_front($4);
$6->push_front($1);
$$= new (YYTHD->mem_root) Item_func_in(*$6);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| bit_expr not IN_SYM '(' expr ')'
{
$$= handle_sql2003_note184_exception(YYTHD, $1, false, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| bit_expr not IN_SYM '(' expr ',' expr_list ')'
{
@@ -4691,54 +4829,146 @@ predicate:
$$= item;
}
| bit_expr BETWEEN_SYM bit_expr AND_SYM predicate
- { $$= new Item_func_between($1,$3,$5); }
+ {
+ $$= new Item_func_between($1,$3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr not BETWEEN_SYM bit_expr AND_SYM predicate
{
Item_func_between *item= new Item_func_between($1,$4,$6);
+ if (item == NULL)
+ MYSQL_YYABORT;
item->negate();
$$= item;
}
| bit_expr SOUNDS_SYM LIKE bit_expr
- { $$= new Item_func_eq(new Item_func_soundex($1),
- new Item_func_soundex($4)); }
+ {
+ Item *item1= new Item_func_soundex($1);
+ Item *item4= new Item_func_soundex($4);
+ if ((item1 == NULL) || (item4 == NULL))
+ MYSQL_YYABORT;
+ $$= new Item_func_eq(item1, item4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr LIKE simple_expr opt_escape
- { $$= new Item_func_like($1,$3,$4,Lex->escape_used); }
+ {
+ $$= new Item_func_like($1,$3,$4,Lex->escape_used);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr not LIKE simple_expr opt_escape
- { $$= new Item_func_not(new Item_func_like($1,$4,$5, Lex->escape_used)); }
- | bit_expr REGEXP bit_expr { $$= new Item_func_regex($1,$3); }
+ {
+ Item *item= new Item_func_like($1,$4,$5, Lex->escape_used);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_not(item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | bit_expr REGEXP bit_expr
+ {
+ $$= new Item_func_regex($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr not REGEXP bit_expr
- { $$= negate_expression(YYTHD, new Item_func_regex($1,$4)); }
+ {
+ Item *item= new Item_func_regex($1,$4);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= negate_expression(YYTHD, item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr ;
bit_expr:
bit_expr '|' bit_expr %prec '|'
- { $$= new Item_func_bit_or($1,$3); }
+ {
+ $$= new Item_func_bit_or($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '&' bit_expr %prec '&'
- { $$= new Item_func_bit_and($1,$3); }
+ {
+ $$= new Item_func_bit_and($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr SHIFT_LEFT bit_expr %prec SHIFT_LEFT
- { $$= new Item_func_shift_left($1,$3); }
+ {
+ $$= new Item_func_shift_left($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr SHIFT_RIGHT bit_expr %prec SHIFT_RIGHT
- { $$= new Item_func_shift_right($1,$3); }
+ {
+ $$= new Item_func_shift_right($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '+' bit_expr %prec '+'
- { $$= new Item_func_plus($1,$3); }
+ {
+ $$= new Item_func_plus($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '-' bit_expr %prec '-'
- { $$= new Item_func_minus($1,$3); }
+ {
+ $$= new Item_func_minus($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '+' interval_expr interval %prec '+'
- { $$= new Item_date_add_interval($1,$3,$4,0); }
+ {
+ $$= new Item_date_add_interval($1,$3,$4,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '-' interval_expr interval %prec '-'
- { $$= new Item_date_add_interval($1,$3,$4,1); }
+ {
+ $$= new Item_date_add_interval($1,$3,$4,1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '*' bit_expr %prec '*'
- { $$= new Item_func_mul($1,$3); }
+ {
+ $$= new Item_func_mul($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '/' bit_expr %prec '/'
- { $$= new Item_func_div($1,$3); }
+ {
+ $$= new Item_func_div($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '%' bit_expr %prec '%'
- { $$= new Item_func_mod($1,$3); }
+ {
+ $$= new Item_func_mod($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr DIV_SYM bit_expr %prec DIV_SYM
- { $$= new Item_func_int_div($1,$3); }
+ {
+ $$= new Item_func_int_div($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr MOD_SYM bit_expr %prec MOD_SYM
- { $$= new Item_func_mod($1,$3); }
+ {
+ $$= new Item_func_mod($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| bit_expr '^' bit_expr
- { $$= new Item_func_bit_xor($1,$3); }
+ {
+ $$= new Item_func_bit_xor($1,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| simple_expr
;
@@ -4768,67 +4998,118 @@ simple_expr:
simple_ident
| simple_expr COLLATE_SYM ident_or_text %prec NEG
{
- $$= new Item_func_set_collation($1,
- new Item_string($3.str,
- $3.length,
- YYTHD->charset()));
+ Item *item= new Item_string($3.str, $3.length, YYTHD->charset());
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_set_collation($1, item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| literal
| param_marker
| variable
| sum_expr
| simple_expr OR_OR_SYM simple_expr
- { $$= new Item_func_concat($1, $3); }
- | '+' simple_expr %prec NEG { $$= $2; }
- | '-' simple_expr %prec NEG { $$= new Item_func_neg($2); }
- | '~' simple_expr %prec NEG { $$= new Item_func_bit_neg($2); }
- | not2 simple_expr %prec NEG { $$= negate_expression(YYTHD, $2); }
+ {
+ $$= new Item_func_concat($1, $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | '+' simple_expr %prec NEG
+ { $$= $2; }
+ | '-' simple_expr %prec NEG
+ {
+ $$= new Item_func_neg($2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | '~' simple_expr %prec NEG
+ {
+ $$= new Item_func_bit_neg($2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | not2 simple_expr %prec NEG
+ {
+ $$= negate_expression(YYTHD, $2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| '(' subselect ')'
{
$$= new Item_singlerow_subselect($2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| '(' expr ')' { $$= $2; }
| '(' expr ',' expr_list ')'
{
$4->push_front($2);
$$= new Item_row(*$4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| ROW_SYM '(' expr ',' expr_list ')'
{
$5->push_front($3);
$$= new Item_row(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| EXISTS '(' subselect ')'
{
$$= new Item_exists_subselect($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
- | '{' ident expr '}' { $$= $3; }
+ | '{' ident expr '}'
+ { $$= $3; }
| MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')'
- { $2->push_front($5);
- Select->add_ftfunc_to_list((Item_func_match*)
- ($$=new Item_func_match(*$2,$6))); }
- | ASCII_SYM '(' expr ')' { $$= new Item_func_ascii($3); }
+ {
+ $2->push_front($5);
+ Item_func_match *item= new Item_func_match(*$2,$6);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ Select->add_ftfunc_to_list(item);
+ $$= item;
+ }
+ | ASCII_SYM '(' expr ')'
+ {
+ $$= new Item_func_ascii($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| BINARY simple_expr %prec NEG
{
$$= create_func_cast($2, ITEM_CAST_CHAR, NULL, NULL, &my_charset_bin);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| CAST_SYM '(' expr AS cast_type ')'
{
LEX *lex= Lex;
$$= create_func_cast($3, $5, lex->length, lex->dec, lex->charset);
- if (!$$)
+ if ($$ == NULL)
MYSQL_YYABORT;
}
| CASE_SYM opt_expr when_list opt_else END
- { $$= new Item_func_case(* $3, $2, $4 ); }
+ {
+ $$= new Item_func_case(* $3, $2, $4 );
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CONVERT_SYM '(' expr ',' cast_type ')'
{
$$= create_func_cast($3, $5, Lex->length, Lex->dec, Lex->charset);
- if (!$$)
+ if ($$ == NULL)
MYSQL_YYABORT;
}
| CONVERT_SYM '(' expr USING charset_name ')'
- { $$= new Item_func_conv_charset($3,$5); }
+ {
+ $$= new Item_func_conv_charset($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DEFAULT '(' simple_ident ')'
{
if ($3->is_splocal())
@@ -4839,9 +5120,15 @@ simple_expr:
MYSQL_YYABORT;
}
$$= new Item_default_value(Lex->current_context(), $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| VALUES '(' simple_ident_nospvar ')'
- { $$= new Item_insert_value(Lex->current_context(), $3); }
+ {
+ $$= new Item_insert_value(Lex->current_context(), $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| FUNC_ARG0 '(' ')'
{
if (!$1.symbol->create_func)
@@ -4852,6 +5139,8 @@ simple_expr:
MYSQL_YYABORT;
}
$$= ((Item*(*)(void))($1.symbol->create_func))();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| FUNC_ARG1 '(' expr ')'
{
@@ -4863,6 +5152,8 @@ simple_expr:
MYSQL_YYABORT;
}
$$= ((Item*(*)(Item*))($1.symbol->create_func))($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| FUNC_ARG2 '(' expr ',' expr ')'
{
@@ -4874,6 +5165,8 @@ simple_expr:
MYSQL_YYABORT;
}
$$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| FUNC_ARG3 '(' expr ',' expr ',' expr ')'
{
@@ -4885,106 +5178,264 @@ simple_expr:
MYSQL_YYABORT;
}
$$= ((Item*(*)(Item*,Item*,Item*))($1.symbol->create_func))($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| ADDDATE_SYM '(' expr ',' expr ')'
- { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 0);}
+ {
+ $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
- { $$= new Item_date_add_interval($3, $6, $7, 0); }
+ {
+ $$= new Item_date_add_interval($3, $6, $7, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| REPEAT_SYM '(' expr ',' expr ')'
- { $$= new Item_func_repeat($3,$5); }
+ {
+ $$= new Item_func_repeat($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ATAN '(' expr ')'
- { $$= new Item_func_atan($3); }
+ {
+ $$= new Item_func_atan($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ATAN '(' expr ',' expr ')'
- { $$= new Item_func_atan($3,$5); }
+ {
+ $$= new Item_func_atan($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CHAR_SYM '(' expr_list ')'
- { $$= new Item_func_char(*$3); }
+ {
+ $$= new Item_func_char(*$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CHAR_SYM '(' expr_list USING charset_name ')'
- { $$= new Item_func_char(*$3, $5); }
+ {
+ $$= new Item_func_char(*$3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CHARSET '(' expr ')'
- { $$= new Item_func_charset($3); }
+ {
+ $$= new Item_func_charset($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| COALESCE '(' expr_list ')'
- { $$= new Item_func_coalesce(* $3); }
+ {
+ $$= new Item_func_coalesce(* $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| COLLATION_SYM '(' expr ')'
- { $$= new Item_func_collation($3); }
+ {
+ $$= new Item_func_collation($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CONCAT '(' expr_list ')'
- { $$= new Item_func_concat(* $3); }
+ {
+ $$= new Item_func_concat(* $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CONCAT_WS '(' expr ',' expr_list ')'
- { $5->push_front($3); $$= new Item_func_concat_ws(*$5); }
+ {
+ $5->push_front($3);
+ $$= new Item_func_concat_ws(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| CONVERT_TZ_SYM '(' expr ',' expr ',' expr ')'
{
if (Lex->add_time_zone_tables_to_query_tables(YYTHD))
MYSQL_YYABORT;
$$= new Item_func_convert_tz($3, $5, $7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| CURDATE optional_braces
- { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; }
+ {
+ $$= new Item_func_curdate_local();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| CURTIME optional_braces
- { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; }
+ {
+ $$= new Item_func_curtime_local();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| CURTIME '(' expr ')'
{
$$= new Item_func_curtime_local($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| CURRENT_USER optional_braces
{
$$= new Item_func_current_user(Lex->current_context());
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query= 0;
}
| DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')'
- { $$= new Item_date_add_interval($3,$5,$6,0); }
+ {
+ $$= new Item_date_add_interval($3,$5,$6,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')'
- { $$= new Item_date_add_interval($3,$5,$6,1); }
+ {
+ $$= new Item_date_add_interval($3,$5,$6,1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DATABASE '(' ')'
{
$$= new Item_func_database();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| DATE_SYM '(' expr ')'
- { $$= new Item_date_typecast($3); }
+ {
+ $$= new Item_date_typecast($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DAY_SYM '(' expr ')'
- { $$= new Item_func_dayofmonth($3); }
+ {
+ $$= new Item_func_dayofmonth($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ELT_FUNC '(' expr ',' expr_list ')'
- { $5->push_front($3); $$= new Item_func_elt(*$5); }
+ {
+ $5->push_front($3);
+ $$= new Item_func_elt(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MAKE_SET_SYM '(' expr ',' expr_list ')'
- { $$= new Item_func_make_set($3, *$5); }
+ {
+ $$= new Item_func_make_set($3, *$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ENCRYPT '(' expr ')'
{
$$= new Item_func_encrypt($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->uncacheable(UNCACHEABLE_RAND);
}
- | ENCRYPT '(' expr ',' expr ')' { $$= new Item_func_encrypt($3,$5); }
+ | ENCRYPT '(' expr ',' expr ')'
+ {
+ $$= new Item_func_encrypt($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DECODE_SYM '(' expr ',' TEXT_STRING_literal ')'
- { $$= new Item_func_decode($3,$5.str); }
+ {
+ $$= new Item_func_decode($3,$5.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ENCODE_SYM '(' expr ',' TEXT_STRING_literal ')'
- { $$= new Item_func_encode($3,$5.str); }
+ {
+ $$= new Item_func_encode($3,$5.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DES_DECRYPT_SYM '(' expr ')'
- { $$= new Item_func_des_decrypt($3); }
+ {
+ $$= new Item_func_des_decrypt($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DES_DECRYPT_SYM '(' expr ',' expr ')'
- { $$= new Item_func_des_decrypt($3,$5); }
+ {
+ $$= new Item_func_des_decrypt($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DES_ENCRYPT_SYM '(' expr ')'
- { $$= new Item_func_des_encrypt($3); }
+ {
+ $$= new Item_func_des_encrypt($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| DES_ENCRYPT_SYM '(' expr ',' expr ')'
- { $$= new Item_func_des_encrypt($3,$5); }
+ {
+ $$= new Item_func_des_encrypt($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| EXPORT_SET '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_export_set($3, $5, $7); }
+ {
+ $$= new Item_func_export_set($3, $5, $7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ')'
- { $$= new Item_func_export_set($3, $5, $7, $9); }
+ {
+ $$= new Item_func_export_set($3, $5, $7, $9);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ',' expr ')'
- { $$= new Item_func_export_set($3, $5, $7, $9, $11); }
+ {
+ $$= new Item_func_export_set($3, $5, $7, $9, $11);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| FORMAT_SYM '(' expr ',' NUM ')'
- { $$= new Item_func_format($3,atoi($5.str)); }
+ {
+ $$= new Item_func_format($3,atoi($5.str));
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| FROM_UNIXTIME '(' expr ')'
- { $$= new Item_func_from_unixtime($3); }
+ {
+ $$= new Item_func_from_unixtime($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| FROM_UNIXTIME '(' expr ',' expr ')'
{
- $$= new Item_func_date_format (new Item_func_from_unixtime($3),$5,0);
+ Item *item= new Item_func_from_unixtime($3);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_date_format (item, $5, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| FIELD_FUNC '(' expr ',' expr_list ')'
- { $5->push_front($3); $$= new Item_func_field(*$5); }
+ {
+ $5->push_front($3);
+ $$= new Item_func_field(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| geometry_function
{
#ifdef HAVE_SPATIAL
$$= $1;
+ /* $1 may be NULL, GEOM_NEW not tested for out of memory */
+ if ($$ == NULL)
+ MYSQL_YYABORT;
#else
my_error(ER_FEATURE_DISABLED, MYF(0),
sym_group_geom.name, sym_group_geom.needed_define);
@@ -4992,16 +5443,36 @@ simple_expr:
#endif
}
| GET_FORMAT '(' date_time_type ',' expr ')'
- { $$= new Item_func_get_format($3, $5); }
+ {
+ $$= new Item_func_get_format($3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| HOUR_SYM '(' expr ')'
- { $$= new Item_func_hour($3); }
+ {
+ $$= new Item_func_hour($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| IF '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_if($3,$5,$7); }
+ {
+ $$= new Item_func_if($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| INSERT '(' expr ',' expr ',' expr ',' expr ')'
- { $$= new Item_func_insert($3,$5,$7,$9); }
+ {
+ $$= new Item_func_insert($3,$5,$7,$9);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| interval_expr interval '+' expr
/* we cannot put interval before - */
- { $$= new Item_date_add_interval($4,$1,$2,0); }
+ {
+ $$= new Item_date_add_interval($4,$1,$2,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| interval_expr
{
if ($1->type() != Item::ROW_ITEM)
@@ -5010,102 +5481,248 @@ simple_expr:
MYSQL_YYABORT;
}
$$= new Item_func_interval((Item_row *)$1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| LAST_INSERT_ID '(' ')'
{
$$= new Item_func_last_insert_id();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query= 0;
}
| LAST_INSERT_ID '(' expr ')'
{
$$= new Item_func_last_insert_id($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query= 0;
}
| LEFT '(' expr ',' expr ')'
- { $$= new Item_func_left($3,$5); }
+ {
+ $$= new Item_func_left($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| LOCATE '(' expr ',' expr ')'
- { $$= new Item_func_locate($5,$3); }
+ {
+ $$= new Item_func_locate($5,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| LOCATE '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_locate($5,$3,$7); }
+ {
+ $$= new Item_func_locate($5,$3,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| GREATEST_SYM '(' expr ',' expr_list ')'
- { $5->push_front($3); $$= new Item_func_max(*$5); }
+ {
+ $5->push_front($3);
+ $$= new Item_func_max(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| LEAST_SYM '(' expr ',' expr_list ')'
- { $5->push_front($3); $$= new Item_func_min(*$5); }
+ {
+ $5->push_front($3);
+ $$= new Item_func_min(*$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| LOG_SYM '(' expr ')'
- { $$= new Item_func_log($3); }
+ {
+ $$= new Item_func_log($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| LOG_SYM '(' expr ',' expr ')'
- { $$= new Item_func_log($3, $5); }
+ {
+ $$= new Item_func_log($3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MASTER_POS_WAIT '(' expr ',' expr ')'
{
$$= new Item_master_pos_wait($3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
- }
+ }
| MASTER_POS_WAIT '(' expr ',' expr ',' expr ')'
{
$$= new Item_master_pos_wait($3, $5, $7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| MICROSECOND_SYM '(' expr ')'
- { $$= new Item_func_microsecond($3); }
+ {
+ $$= new Item_func_microsecond($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MINUTE_SYM '(' expr ')'
- { $$= new Item_func_minute($3); }
+ {
+ $$= new Item_func_minute($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MOD_SYM '(' expr ',' expr ')'
- { $$ = new Item_func_mod( $3, $5); }
+ {
+ $$= new Item_func_mod( $3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MONTH_SYM '(' expr ')'
- { $$= new Item_func_month($3); }
+ {
+ $$= new Item_func_month($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| NOW_SYM optional_braces
- { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;}
+ {
+ $$= new Item_func_now_local();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| NOW_SYM '(' expr ')'
- { $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0;}
+ {
+ $$= new Item_func_now_local($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ 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);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| OLD_PASSWORD '(' expr ')'
- { $$= new Item_func_old_password($3); }
+ {
+ $$= new Item_func_old_password($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| POSITION_SYM '(' bit_expr IN_SYM expr ')'
- { $$ = new Item_func_locate($5,$3); }
+ {
+ $$= new Item_func_locate($5,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| QUARTER_SYM '(' expr ')'
- { $$ = new Item_func_quarter($3); }
+ {
+ $$= new Item_func_quarter($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| RAND '(' expr ')'
- { $$= new Item_func_rand($3); Lex->uncacheable(UNCACHEABLE_RAND);}
+ {
+ $$= new Item_func_rand($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->uncacheable(UNCACHEABLE_RAND);
+ }
| RAND '(' ')'
- { $$= new Item_func_rand(); Lex->uncacheable(UNCACHEABLE_RAND);}
+ {
+ $$= new Item_func_rand();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->uncacheable(UNCACHEABLE_RAND);
+ }
| REPLACE '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_replace($3,$5,$7); }
+ {
+ $$= new Item_func_replace($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| RIGHT '(' expr ',' expr ')'
- { $$= new Item_func_right($3,$5); }
+ {
+ $$= new Item_func_right($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| 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); }
+ {
+ Item *item= new Item_int((char*)"0",0,1);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_round($3, item, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | ROUND '(' expr ',' expr ')'
+ {
+ $$= new Item_func_round($3,$5,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ROW_COUNT_SYM '(' ')'
{
$$= new Item_func_row_count();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query= 0;
}
| SUBDATE_SYM '(' expr ',' expr ')'
- { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);}
+ {
+ $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
- { $$= new Item_date_add_interval($3, $6, $7, 1); }
+ {
+ $$= new Item_date_add_interval($3, $6, $7, 1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SECOND_SYM '(' expr ')'
- { $$= new Item_func_second($3); }
+ {
+ $$= new Item_func_second($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBSTRING '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_substr($3,$5,$7); }
+ {
+ $$= new Item_func_substr($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBSTRING '(' expr ',' expr ')'
- { $$= new Item_func_substr($3,$5); }
+ {
+ $$= new Item_func_substr($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBSTRING '(' expr FROM expr FOR_SYM expr ')'
- { $$= new Item_func_substr($3,$5,$7); }
+ {
+ $$= new Item_func_substr($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBSTRING '(' expr FROM expr ')'
- { $$= new Item_func_substr($3,$5); }
+ {
+ $$= new Item_func_substr($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUBSTRING_INDEX '(' expr ',' expr ',' expr ')'
- { $$= new Item_func_substr_index($3,$5,$7); }
+ {
+ $$= new Item_func_substr_index($3,$5,$7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SYSDATE optional_braces
{
if (global_system_variables.sysdate_is_now == 0)
$$= new Item_func_sysdate_local();
else $$= new Item_func_now_local();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| SYSDATE '(' expr ')'
@@ -5113,36 +5730,94 @@ simple_expr:
if (global_system_variables.sysdate_is_now == 0)
$$= new Item_func_sysdate_local($3);
else $$= new Item_func_now_local($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| TIME_SYM '(' expr ')'
- { $$= new Item_time_typecast($3); }
+ {
+ $$= new Item_time_typecast($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TIMESTAMP '(' expr ')'
- { $$= new Item_datetime_typecast($3); }
+ {
+ $$= new Item_datetime_typecast($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TIMESTAMP '(' expr ',' expr ')'
- { $$= new Item_func_add_time($3, $5, 1, 0); }
+ {
+ $$= new Item_func_add_time($3, $5, 1, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TIMESTAMP_ADD '(' interval_time_stamp ',' expr ',' expr ')'
- { $$= new Item_date_add_interval($7,$5,$3,0); }
+ {
+ $$= new Item_date_add_interval($7,$5,$3,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TIMESTAMP_DIFF '(' interval_time_stamp ',' expr ',' expr ')'
- { $$= new Item_func_timestamp_diff($5,$7,$3); }
+ {
+ $$= new Item_func_timestamp_diff($5,$7,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' expr ')'
- { $$= new Item_func_trim($3); }
+ {
+ $$= new Item_func_trim($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' LEADING expr FROM expr ')'
- { $$= new Item_func_ltrim($6,$4); }
+ {
+ $$= new Item_func_ltrim($6,$4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' TRAILING expr FROM expr ')'
- { $$= new Item_func_rtrim($6,$4); }
+ {
+ $$= new Item_func_rtrim($6,$4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' BOTH expr FROM expr ')'
- { $$= new Item_func_trim($6,$4); }
+ {
+ $$= new Item_func_trim($6,$4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' LEADING FROM expr ')'
- { $$= new Item_func_ltrim($5); }
+ {
+ $$= new Item_func_ltrim($5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' TRAILING FROM expr ')'
- { $$= new Item_func_rtrim($5); }
+ {
+ $$= new Item_func_rtrim($5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' BOTH FROM expr ')'
- { $$= new Item_func_trim($5); }
+ {
+ $$= new Item_func_trim($5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRIM '(' expr FROM expr ')'
- { $$= new Item_func_trim($5,$3); }
+ {
+ $$= new Item_func_trim($5,$3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| TRUNCATE_SYM '(' expr ',' expr ')'
- { $$= new Item_func_round($3,$5,1); }
+ {
+ $$= new Item_func_round($3,$5,1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| ident '.' ident '(' opt_expr_list ')'
{
LEX *lex= Lex;
@@ -5155,6 +5830,8 @@ simple_expr:
$$= new Item_func_sp(Lex->current_context(), name, *$5);
else
$$= new Item_func_sp(Lex->current_context(), name);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
lex->safe_to_cache_query=0;
}
| IDENT_sys '('
@@ -5295,47 +5972,110 @@ simple_expr:
else
$$= new Item_func_sp(Lex->current_context(), name);
}
- lex->safe_to_cache_query=0;
+ lex->safe_to_cache_query=0;
+
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')'
{
$$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| UNIX_TIMESTAMP '(' ')'
{
$$= new Item_func_unix_timestamp();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->safe_to_cache_query=0;
}
| UNIX_TIMESTAMP '(' expr ')'
- { $$= new Item_func_unix_timestamp($3); }
+ {
+ $$= new Item_func_unix_timestamp($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| USER '(' ')'
- { $$= new Item_func_user(); Lex->safe_to_cache_query=0; }
+ {
+ $$= new Item_func_user();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| UTC_DATE_SYM optional_braces
- { $$= new Item_func_curdate_utc(); Lex->safe_to_cache_query=0;}
+ {
+ $$= new Item_func_curdate_utc();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| UTC_TIME_SYM optional_braces
- { $$= new Item_func_curtime_utc(); Lex->safe_to_cache_query=0;}
+ {
+ $$= new Item_func_curtime_utc();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| UTC_TIMESTAMP_SYM optional_braces
- { $$= new Item_func_now_utc(); Lex->safe_to_cache_query=0;}
+ {
+ $$= new Item_func_now_utc();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ Lex->safe_to_cache_query=0;
+ }
| WEEK_SYM '(' expr ')'
{
- $$= new Item_func_week($3,new Item_int((char*) "0",
- YYTHD->variables.default_week_format,1));
+ Item *item= new Item_int((char*) "0",
+ YYTHD->variables.default_week_format,
+ 1);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_week($3, item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| WEEK_SYM '(' expr ',' expr ')'
- { $$= new Item_func_week($3,$5); }
+ {
+ $$= new Item_func_week($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| YEAR_SYM '(' expr ')'
- { $$= new Item_func_year($3); }
+ {
+ $$= new Item_func_year($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| YEARWEEK '(' expr ')'
- { $$= new Item_func_yearweek($3,new Item_int((char*) "0",0,1)); }
+ {
+ Item *item= new Item_int((char*) "0",0,1);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$= new Item_func_yearweek($3, item);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| YEARWEEK '(' expr ',' expr ')'
- { $$= new Item_func_yearweek($3, $5); }
+ {
+ $$= new Item_func_yearweek($3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| BENCHMARK_SYM '(' ulong_num ',' expr ')'
{
$$=new Item_func_benchmark($3,$5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
}
| EXTRACT_SYM '(' interval FROM expr ')'
- { $$=new Item_extract( $3, $5); };
+ {
+ $$=new Item_extract( $3, $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ ;
geometry_function:
CONTAINS_SYM '(' expr ',' expr ')'
@@ -5411,7 +6151,12 @@ udf_expr_list:
;
udf_expr_list2:
- { Select->expr_list.push_front(new List<Item>); }
+ {
+ List<Item> *list= new List<Item>;
+ if (list == NULL)
+ MYSQL_YYABORT;
+ Select->expr_list.push_front(list);
+ }
udf_expr_list3
{ $$= Select->expr_list.pop(); }
;
@@ -5459,53 +6204,132 @@ udf_expr:
;
sum_expr:
- AVG_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_avg($3); }
+ AVG_SYM '(' in_sum_expr ')'
+ {
+ $$=new Item_sum_avg($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| AVG_SYM '(' DISTINCT in_sum_expr ')'
- { $$=new Item_sum_avg_distinct($4); }
+ {
+ $$=new Item_sum_avg_distinct($4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| BIT_AND '(' in_sum_expr ')'
- { $$=new Item_sum_and($3); }
+ {
+ $$=new Item_sum_and($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| BIT_OR '(' in_sum_expr ')'
- { $$=new Item_sum_or($3); }
+ {
+ $$=new Item_sum_or($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| BIT_XOR '(' in_sum_expr ')'
- { $$=new Item_sum_xor($3); }
+ {
+ $$=new Item_sum_xor($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| COUNT_SYM '(' opt_all '*' ')'
- { $$=new Item_sum_count(new Item_int((int32) 0L,1)); }
+ {
+ Item *item= new Item_int((int32) 0L,1);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ $$=new Item_sum_count(new Item_int((int32) 0L,1));
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| COUNT_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_count($3); }
+ {
+ $$=new Item_sum_count($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| COUNT_SYM '(' DISTINCT
{ Select->in_sum_expr++; }
expr_list
{ Select->in_sum_expr--; }
')'
- { $$=new Item_sum_count_distinct(* $5); }
+ {
+ $$=new Item_sum_count_distinct(* $5);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| GROUP_UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' in_sum_expr ')'
- { $$= new Item_sum_unique_users($3,atoi($5.str),atoi($7.str),$9); }
+ {
+ $$= new Item_sum_unique_users($3,atoi($5.str),atoi($7.str),$9);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MIN_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_min($3); }
+ {
+ $$=new Item_sum_min($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
/*
According to ANSI SQL, DISTINCT is allowed and has
no sence inside MIN and MAX grouping functions; so MIN|MAX(DISTINCT ...)
is processed like an ordinary MIN | MAX()
*/
| MIN_SYM '(' DISTINCT in_sum_expr ')'
- { $$=new Item_sum_min($4); }
+ {
+ $$=new Item_sum_min($4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MAX_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_max($3); }
+ {
+ $$=new Item_sum_max($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| MAX_SYM '(' DISTINCT in_sum_expr ')'
- { $$=new Item_sum_max($4); }
+ {
+ $$=new Item_sum_max($4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| STD_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_std($3, 0); }
+ {
+ $$=new Item_sum_std($3, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| VARIANCE_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_variance($3, 0); }
+ {
+ $$=new Item_sum_variance($3, 0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| STDDEV_SAMP_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_std($3, 1); }
+ {
+ $$=new Item_sum_std($3, 1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| VAR_SAMP_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_variance($3, 1); }
+ {
+ $$=new Item_sum_variance($3, 1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUM_SYM '(' in_sum_expr ')'
- { $$=new Item_sum_sum($3); }
+ {
+ $$=new Item_sum_sum($3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| SUM_SYM '(' DISTINCT in_sum_expr ')'
- { $$=new Item_sum_sum_distinct($4); }
+ {
+ $$=new Item_sum_sum_distinct($4);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| GROUP_CONCAT_SYM '(' opt_distinct
{ Select->in_sum_expr++; }
expr_list opt_gorder_clause
@@ -5516,6 +6340,8 @@ sum_expr:
sel->in_sum_expr--;
$$=new Item_func_group_concat(Lex->current_context(), $3, $5,
sel->gorder_list, $7);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
$5->empty();
};
@@ -5538,12 +6364,16 @@ variable_aux:
ident_or_text SET_VAR expr
{
$$= new Item_func_set_user_var($1, $3);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
LEX *lex= Lex;
lex->uncacheable(UNCACHEABLE_RAND);
}
| ident_or_text
{
$$= new Item_func_get_user_var($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
LEX *lex= Lex;
lex->uncacheable(UNCACHEABLE_RAND);
}
@@ -5564,11 +6394,14 @@ opt_distinct:
|DISTINCT { $$ = 1; };
opt_gconcat_separator:
- /* empty */
- {
- $$= new (YYTHD->mem_root) String(",", 1, &my_charset_latin1);
- }
- | SEPARATOR_SYM text_string { $$ = $2; };
+ /* empty */
+ {
+ $$= new (YYTHD->mem_root) String(",", 1, &my_charset_latin1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | SEPARATOR_SYM text_string { $$ = $2; }
+ ;
opt_gorder_clause:
@@ -5582,6 +6415,8 @@ opt_gorder_clause:
select->gorder_list=
(SQL_LIST*) sql_memdup((char*) &select->order_list,
sizeof(st_sql_list));
+ if (select->gorder_list == NULL)
+ MYSQL_YYABORT;
select->order_list.empty();
};
@@ -5622,7 +6457,12 @@ opt_expr_list:
;
expr_list:
- { Select->expr_list.push_front(new List<Item>); }
+ {
+ List<Item> *list= new List<Item>;
+ if (list == NULL)
+ MYSQL_YYABORT;
+ Select->expr_list.push_front(list);
+ }
expr_list2
{ $$= Select->expr_list.pop(); };
@@ -5635,7 +6475,12 @@ ident_list_arg:
| '(' ident_list ')' { $$= $2; };
ident_list:
- { Select->expr_list.push_front(new List<Item>); }
+ {
+ List<Item> *list= new List<Item>;
+ if (list == NULL)
+ MYSQL_YYABORT;
+ Select->expr_list.push_front(new List<Item>);
+ }
ident_list2
{ $$= Select->expr_list.pop(); };
@@ -5655,6 +6500,8 @@ when_list:
WHEN_SYM expr THEN_SYM expr
{
$$= new List<Item>;
+ if ($$ == NULL)
+ MYSQL_YYABORT;
$$->push_back($2);
$$->push_back($4);
}
@@ -6061,32 +6908,53 @@ key_list_or_empty:
key_usage_list2:
key_usage_list2 ',' ident
- { Select->
- interval_list.push_back(new (YYTHD->mem_root) String((const char*) $3.str, $3.length,
- system_charset_info)); }
+ {
+ String *s= new (YYTHD->mem_root) String((const char*) $3.str,
+ $3.length,
+ system_charset_info);
+ if (s == NULL)
+ MYSQL_YYABORT;
+ Select->interval_list.push_back(s);
+ }
| ident
- { Select->
- interval_list.push_back(new (YYTHD->mem_root) String((const char*) $1.str, $1.length,
- system_charset_info)); }
+ {
+ String *s= new (YYTHD->mem_root) String((const char*) $1.str,
+ $1.length,
+ system_charset_info);
+ if (s == NULL)
+ MYSQL_YYABORT;
+ Select->interval_list.push_back(s);
+ }
| PRIMARY_SYM
- { Select->
- interval_list.push_back(new (YYTHD->mem_root) String("PRIMARY", 7,
- system_charset_info)); };
+ {
+ String *s= new (YYTHD->mem_root) String("PRIMARY", 7,
+ system_charset_info);
+ if (s == NULL)
+ MYSQL_YYABORT;
+ Select->interval_list.push_back(s);
+ }
+ ;
using_list:
ident
{
if (!($$= new List<String>))
MYSQL_YYABORT;
- $$->push_back(new (YYTHD->mem_root)
- String((const char *) $1.str, $1.length,
- system_charset_info));
+ String *s= new (YYTHD->mem_root) String((const char *) $1.str,
+ $1.length,
+ system_charset_info);
+ if (s == NULL)
+ MYSQL_YYABORT;
+ $$->push_back(s);
}
| using_list ',' ident
{
- $1->push_back(new (YYTHD->mem_root)
- String((const char *) $3.str, $3.length,
- system_charset_info));
+ String *s= new (YYTHD->mem_root) String((const char *) $3.str,
+ $3.length,
+ system_charset_info);
+ if (s == NULL)
+ MYSQL_YYABORT;
+ $1->push_back(s);
$$= $1;
};
@@ -6151,7 +7019,12 @@ table_alias:
opt_table_alias:
/* empty */ { $$=0; }
| table_alias ident
- { $$= (LEX_STRING*) sql_memdup(&$2,sizeof(LEX_STRING)); };
+ {
+ $$= (LEX_STRING*) sql_memdup(&$2,sizeof(LEX_STRING));
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ ;
opt_all:
/* empty */
@@ -6202,6 +7075,8 @@ opt_escape:
$$= ((YYTHD->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES) ?
new Item_string("", 0, &my_charset_latin1) :
new Item_string("\\", 1, &my_charset_latin1));
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
;
@@ -6372,9 +7247,24 @@ limit_option:
{
((Item_param *) $1)->limit_clause_param= TRUE;
}
- | ULONGLONG_NUM { $$= new Item_uint($1.str, $1.length); }
- | LONG_NUM { $$= new Item_uint($1.str, $1.length); }
- | NUM { $$= new Item_uint($1.str, $1.length); }
+ | ULONGLONG_NUM
+ {
+ $$= new Item_uint($1.str, $1.length);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | LONG_NUM
+ {
+ $$= new Item_uint($1.str, $1.length);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | NUM
+ {
+ $$= new Item_uint($1.str, $1.length);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
delete_limit_clause:
@@ -6427,10 +7317,11 @@ procedure_clause:
lex->proc_list.elements=0;
lex->proc_list.first=0;
lex->proc_list.next= (byte**) &lex->proc_list.first;
- if (add_proc_to_list(lex->thd, new Item_field(&lex->
- current_select->
- context,
- NULL,NULL,$2.str)))
+ Item_field *item= new Item_field(&lex->current_select->context,
+ NULL,NULL,$2.str);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ if (add_proc_to_list(lex->thd, item))
MYSQL_YYABORT;
Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
}
@@ -6481,13 +7372,20 @@ select_var_ident:
{
LEX *lex=Lex;
if (lex->result)
- ((select_dumpvar *)lex->result)->var_list.push_back( new my_var($2,0,0,(enum_field_types)0));
+ {
+ my_var *var= new my_var($2,0,0,(enum_field_types)0);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ ((select_dumpvar *)lex->result)->var_list.push_back(var);
+ }
else
+ {
/*
The parser won't create select_result instance only
if it's an EXPLAIN.
*/
DBUG_ASSERT(lex->describe);
+ }
}
| ident_or_text
{
@@ -6501,12 +7399,12 @@ select_var_ident:
}
if (lex->result)
{
- my_var *var;
- ((select_dumpvar *)lex->result)->
- var_list.push_back(var= new my_var($1,1,t->offset,t->type));
+ my_var *var= new my_var($1,1,t->offset,t->type);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ ((select_dumpvar *)lex->result)->var_list.push_back(var);
#ifndef DBUG_OFF
- if (var)
- var->sp= lex->sphead;
+ var->sp= lex->sphead;
#endif
}
else
@@ -6591,11 +7489,13 @@ drop:
| DROP INDEX_SYM ident ON table_ident {}
{
LEX *lex=Lex;
+ Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $3.str);
+ if (ad == NULL)
+ MYSQL_YYABORT;
lex->sql_command= SQLCOM_DROP_INDEX;
lex->alter_info.reset();
lex->alter_info.flags= ALTER_DROP_INDEX;
- lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::KEY,
- $3.str));
+ lex->alter_info.drop_list.push_back(ad);
if (!lex->current_select->add_table_to_list(lex->thd, $5, NULL,
TL_OPTION_UPDATING))
MYSQL_YYABORT;
@@ -6620,6 +7520,8 @@ drop:
lex->sql_command = SQLCOM_DROP_FUNCTION;
lex->drop_if_exists= $3;
spname= new sp_name($4, $6, true);
+ if (spname == NULL)
+ MYSQL_YYABORT;
spname->init_qname(thd);
lex->spname= spname;
}
@@ -6639,6 +7541,8 @@ drop:
lex->sql_command = SQLCOM_DROP_FUNCTION;
lex->drop_if_exists= $3;
spname= new sp_name(db, $4, false);
+ if (spname == NULL)
+ MYSQL_YYABORT;
spname->init_qname(thd);
lex->spname= spname;
}
@@ -6853,7 +7757,12 @@ values:
expr_or_default:
expr { $$= $1;}
- | DEFAULT {$$= new Item_default_value(Lex->current_context()); }
+ | DEFAULT
+ {
+ $$= new Item_default_value(Lex->current_context());
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
opt_insert_update:
@@ -6971,15 +7880,21 @@ table_wild_list:
table_wild_one:
ident opt_wild opt_table_alias
{
- if (!Select->add_table_to_list(YYTHD, new Table_ident($1), $3,
+ Table_ident *ti= new Table_ident($1);
+ if (ti == NULL)
+ MYSQL_YYABORT;
+ if (!Select->add_table_to_list(YYTHD, ti, $3,
TL_OPTION_UPDATING |
TL_OPTION_ALIAS, Lex->lock_option))
MYSQL_YYABORT;
}
| ident '.' ident opt_wild opt_table_alias
{
+ Table_ident *ti= new Table_ident(YYTHD, $1, $3, 0);
+ if (ti == NULL)
+ MYSQL_YYABORT;
if (!Select->add_table_to_list(YYTHD,
- new Table_ident(YYTHD, $1, $3, 0),
+ ti,
$5,
TL_OPTION_UPDATING |
TL_OPTION_ALIAS,
@@ -7357,8 +8272,12 @@ binlog_from:
wild_and_where:
/* empty */
| LIKE TEXT_STRING_sys
- { Lex->wild= new (YYTHD->mem_root) String($2.str, $2.length,
- system_charset_info); }
+ {
+ Lex->wild= new (YYTHD->mem_root) String($2.str, $2.length,
+ system_charset_info);
+ if (Lex->wild == NULL)
+ MYSQL_YYABORT;
+ }
| WHERE expr
{
Select->where= $2;
@@ -7406,7 +8325,14 @@ opt_describe_column:
/* empty */ {}
| text_string { Lex->wild= $1; }
| ident
- { Lex->wild= new (YYTHD->mem_root) String((const char*) $1.str,$1.length,system_charset_info); };
+ {
+ Lex->wild= new (YYTHD->mem_root) String((const char*) $1.str,
+ $1.length,
+ system_charset_info);
+ if (Lex->wild == NULL)
+ MYSQL_YYABORT;
+ }
+ ;
/* flush things */
@@ -7690,7 +8616,11 @@ fields_or_vars:
field_or_var:
simple_ident_nospvar {$$= $1;}
| '@' ident_or_text
- { $$= new Item_user_var_as_out_param($2); }
+ {
+ $$= new Item_user_var_as_out_param($2);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
opt_load_data_set_spec:
@@ -7715,9 +8645,14 @@ text_literal:
my_charset_is_ascii_based(cs_con)))
tmp= $1;
else
- thd->convert_string(&tmp, cs_con, $1.str, $1.length, cs_cli);
+ {
+ if (thd->convert_string(&tmp, cs_con, $1.str, $1.length, cs_cli))
+ MYSQL_YYABORT;
+ }
$$= new Item_string(tmp.str, tmp.length, cs_con,
DERIVATION_COERCIBLE, repertoire);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| NCHAR_STRING
{
@@ -7726,10 +8661,14 @@ text_literal:
DBUG_ASSERT(my_charset_is_ascii_based(national_charset_info));
$$= new Item_string($1.str, $1.length, national_charset_info,
DERIVATION_COERCIBLE, repertoire);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| UNDERSCORE_CHARSET TEXT_STRING
{
$$= new Item_string($2.str, $2.length, Lex->underscore_charset);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
((Item_string*) $$)->set_repertoire_from_value();
}
| text_literal TEXT_STRING_literal
@@ -7751,28 +8690,37 @@ text_literal:
;
text_string:
- TEXT_STRING_literal
- { $$= new (YYTHD->mem_root) String($1.str,$1.length,YYTHD->variables.collation_connection); }
+ TEXT_STRING_literal
+ {
+ $$= new (YYTHD->mem_root) String($1.str,
+ $1.length,
+ YYTHD->variables.collation_connection);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| HEX_NUM
{
Item *tmp= new Item_hex_string($1.str, $1.length);
+ if (tmp == NULL)
+ MYSQL_YYABORT;
/*
it is OK only emulate fix_fields, because we need only
value of constant
*/
- $$= tmp ?
- tmp->quick_fix_field(), tmp->val_str((String*) 0) :
- (String*) 0;
+ tmp->quick_fix_field();
+ $$= tmp->val_str((String*) 0);
}
| BIN_NUM
{
Item *tmp= new Item_bin_string($1.str, $1.length);
+ if (tmp == NULL)
+ MYSQL_YYABORT;
/*
it is OK only emulate fix_fields, because we need only
value of constant
*/
- $$= tmp ? tmp->quick_fix_field(), tmp->val_str((String*) 0) :
- (String*) 0;
+ tmp->quick_fix_field();
+ $$= tmp->val_str((String*) 0);
}
;
@@ -7814,76 +8762,121 @@ literal:
| NULL_SYM
{
$$ = new Item_null();
+ if ($$ == NULL)
+ MYSQL_YYABORT;
YYLIP->next_state= MY_LEX_OPERATOR_OR_IDENT;
}
- | FALSE_SYM { $$= new Item_int((char*) "FALSE",0,1); }
- | TRUE_SYM { $$= new Item_int((char*) "TRUE",1,1); }
- | HEX_NUM { $$ = new Item_hex_string($1.str, $1.length);}
- | BIN_NUM { $$= new Item_bin_string($1.str, $1.length); }
+ | FALSE_SYM
+ {
+ $$= new Item_int((char*) "FALSE",0,1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | TRUE_SYM
+ {
+ $$= new Item_int((char*) "TRUE",1,1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | HEX_NUM
+ {
+ $$= new Item_hex_string($1.str, $1.length);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | BIN_NUM
+ {
+ $$= new Item_bin_string($1.str, $1.length);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
| UNDERSCORE_CHARSET HEX_NUM
{
Item *tmp= new Item_hex_string($2.str, $2.length);
+ if (tmp == NULL)
+ MYSQL_YYABORT;
/*
it is OK only emulate fix_fieds, because we need only
value of constant
*/
- String *str= tmp ?
- tmp->quick_fix_field(), tmp->val_str((String*) 0) :
- (String*) 0;
- $$= new Item_string(NULL, /* name will be set in select_item */
- str ? str->ptr() : "",
- str ? str->length() : 0,
- Lex->underscore_charset);
- if (!$$ || !$$->check_well_formed_result(&$$->str_value, TRUE))
+ tmp->quick_fix_field();
+ String *str= tmp->val_str((String*) 0);
+ Item_string *item_str;
+ item_str= new Item_string(NULL, /* name will be set in select_item */
+ str ? str->ptr() : "",
+ str ? str->length() : 0,
+ Lex->underscore_charset);
+ if (!item_str ||
+ !item_str->check_well_formed_result(&item_str->str_value, TRUE))
{
MYSQL_YYABORT;
}
- ((Item_string *) $$)->set_repertoire_from_value();
+ item_str->set_repertoire_from_value();
+ $$= item_str;
}
| UNDERSCORE_CHARSET BIN_NUM
{
Item *tmp= new Item_bin_string($2.str, $2.length);
+ if (tmp == NULL)
+ MYSQL_YYABORT;
/*
it is OK only emulate fix_fieds, because we need only
value of constant
*/
- String *str= tmp ?
- tmp->quick_fix_field(), tmp->val_str((String*) 0) :
- (String*) 0;
- $$= new Item_string(NULL, /* name will be set in select_item */
- str ? str->ptr() : "",
- str ? str->length() : 0,
- Lex->underscore_charset);
- if (!$$ || !$$->check_well_formed_result(&$$->str_value, TRUE))
+ tmp->quick_fix_field();
+ String *str= tmp->val_str((String*) 0);
+ Item_string *item_str;
+ item_str= new Item_string(NULL, /* name will be set in select_item */
+ str ? str->ptr() : "",
+ str ? str->length() : 0,
+ Lex->underscore_charset);
+ if (!item_str ||
+ !item_str->check_well_formed_result(&item_str->str_value, TRUE))
{
MYSQL_YYABORT;
}
+ $$= item_str;
}
| DATE_SYM text_literal { $$ = $2; }
| TIME_SYM text_literal { $$ = $2; }
| TIMESTAMP text_literal { $$ = $2; };
NUM_literal:
- NUM { int error; $$ = new Item_int($1.str, (longlong) my_strtoll10($1.str, NULL, &error), $1.length); }
- | LONG_NUM { int error; $$ = new Item_int($1.str, (longlong) my_strtoll10($1.str, NULL, &error), $1.length); }
- | ULONGLONG_NUM { $$ = new Item_uint($1.str, $1.length); }
+ NUM
+ {
+ int error;
+ $$ = new Item_int($1.str,
+ (longlong) my_strtoll10($1.str, NULL, &error),
+ $1.length);
+ }
+ | LONG_NUM
+ {
+ int error;
+ $$ = new Item_int($1.str,
+ (longlong) my_strtoll10($1.str, NULL, &error),
+ $1.length);
+ }
+ | ULONGLONG_NUM
+ {
+ $$= new Item_uint($1.str, $1.length);
+ }
| DECIMAL_NUM
- {
- $$= new Item_decimal($1.str, $1.length, YYTHD->charset());
- if (YYTHD->net.report_error)
- {
- MYSQL_YYABORT;
- }
- }
+ {
+ $$= new Item_decimal($1.str, $1.length, YYTHD->charset());
+ if (($$ == NULL) || (YYTHD->net.report_error))
+ {
+ MYSQL_YYABORT;
+ }
+ }
| FLOAT_NUM
- {
- $$ = new Item_float($1.str, $1.length);
- if (YYTHD->net.report_error)
- {
- MYSQL_YYABORT;
- }
- }
- ;
+ {
+ $$= new Item_float($1.str, $1.length);
+ if (($$ == NULL) || (YYTHD->net.report_error))
+ {
+ MYSQL_YYABORT;
+ }
+ }
+ ;
/**********************************************************************
** Creating different items.
@@ -7898,6 +8891,8 @@ table_wild:
{
SELECT_LEX *sel= Select;
$$ = new Item_field(Lex->current_context(), NullS, $1.str, "*");
+ if ($$ == NULL)
+ MYSQL_YYABORT;
sel->with_wild++;
}
| ident '.' ident '.' '*'
@@ -7906,6 +8901,8 @@ table_wild:
$$ = new Item_field(Lex->current_context(), (YYTHD->client_capabilities &
CLIENT_NO_SCHEMA ? NullS : $1.str),
$3.str,"*");
+ if ($$ == NULL)
+ MYSQL_YYABORT;
sel->with_wild++;
}
;
@@ -7935,11 +8932,12 @@ simple_ident:
lip->tok_start_prev -
lex->sphead->m_tmp_query,
lip->tok_end - lip->tok_start_prev);
+ if (splocal == NULL)
+ MYSQL_YYABORT;
#ifndef DBUG_OFF
- if (splocal)
- splocal->m_sp= lex->sphead;
+ splocal->m_sp= lex->sphead;
#endif
- $$ = (Item*) splocal;
+ $$= splocal;
lex->safe_to_cache_query=0;
}
else
@@ -7949,6 +8947,8 @@ simple_ident:
sel->get_in_sum_expr() > 0) ?
(Item*) new Item_field(Lex->current_context(), NullS, NullS, $1.str) :
(Item*) new Item_ref(Lex->current_context(), NullS, NullS, $1.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
}
| simple_ident_q { $$= $1; }
@@ -7962,6 +8962,8 @@ simple_ident_nospvar:
sel->get_in_sum_expr() > 0) ?
(Item*) new Item_field(Lex->current_context(), NullS, NullS, $1.str) :
(Item*) new Item_ref(Lex->current_context(), NullS, NullS, $1.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| simple_ident_q { $$= $1; }
;
@@ -8033,6 +9035,8 @@ simple_ident_q:
sel->get_in_sum_expr() > 0) ?
(Item*) new Item_field(Lex->current_context(), NullS, $1.str, $3.str) :
(Item*) new Item_ref(Lex->current_context(), NullS, $1.str, $3.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
}
| '.' ident '.' ident
@@ -8049,6 +9053,8 @@ simple_ident_q:
sel->get_in_sum_expr() > 0) ?
(Item*) new Item_field(Lex->current_context(), NullS, $2.str, $4.str) :
(Item*) new Item_ref(Lex->current_context(), NullS, $2.str, $4.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| ident '.' ident '.' ident
{
@@ -8070,6 +9076,8 @@ simple_ident_q:
(YYTHD->client_capabilities &
CLIENT_NO_SCHEMA ? NullS : $1.str),
$3.str, $5.str);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
};
@@ -8104,13 +9112,34 @@ field_ident:
| '.' ident { $$=$2;} /* For Delphi */;
table_ident:
- ident { $$=new Table_ident($1); }
- | ident '.' ident { $$=new Table_ident(YYTHD, $1,$3,0);}
- | '.' ident { $$=new Table_ident($2);} /* For Delphi */
+ ident
+ {
+ $$=new Table_ident($1);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | ident '.' ident
+ {
+ $$=new Table_ident(YYTHD, $1,$3,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | '.' ident
+ {
+ $$=new Table_ident($2); /* For Delphi */
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
table_ident_nodb:
- ident { LEX_STRING db={(char*) any_db,3}; $$=new Table_ident(YYTHD, db,$1,0); }
+ ident
+ {
+ LEX_STRING db={(char*) any_db,3};
+ $$=new Table_ident(YYTHD, db,$1,0);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
IDENT_sys:
@@ -8134,8 +9163,11 @@ IDENT_sys:
$$= $1;
}
else
- thd->convert_string(&$$, system_charset_info,
- $1.str, $1.length, thd->charset());
+ {
+ if (thd->convert_string(&$$, system_charset_info,
+ $1.str, $1.length, thd->charset()))
+ MYSQL_YYABORT;
+ }
}
;
@@ -8146,8 +9178,11 @@ TEXT_STRING_sys:
if (thd->charset_is_system_charset)
$$= $1;
else
- thd->convert_string(&$$, system_charset_info,
- $1.str, $1.length, thd->charset());
+ {
+ if (thd->convert_string(&$$, system_charset_info,
+ $1.str, $1.length, thd->charset()))
+ MYSQL_YYABORT;
+ }
}
;
@@ -8158,8 +9193,11 @@ TEXT_STRING_literal:
if (thd->charset_is_collation_connection)
$$= $1;
else
- thd->convert_string(&$$, thd->variables.collation_connection,
- $1.str, $1.length, thd->charset());
+ {
+ if (thd->convert_string(&$$, thd->variables.collation_connection,
+ $1.str, $1.length, thd->charset()))
+ MYSQL_YYABORT;
+ }
}
;
@@ -8171,8 +9209,11 @@ TEXT_STRING_filesystem:
if (thd->charset_is_character_set_filesystem)
$$= $1;
else
- thd->convert_string(&$$, thd->variables.character_set_filesystem,
- $1.str, $1.length, thd->charset());
+ {
+ if (thd->convert_string(&$$, thd->variables.character_set_filesystem,
+ $1.str, $1.length, thd->charset()))
+ MYSQL_YYABORT;
+ }
}
;
@@ -8182,6 +9223,8 @@ ident:
{
THD *thd= YYTHD;
$$.str= thd->strmake($1.str, $1.length);
+ if ($$.str == NULL)
+ MYSQL_YYABORT;
$$.length= $1.length;
}
;
@@ -8192,6 +9235,8 @@ label_ident:
{
THD *thd= YYTHD;
$$.str= thd->strmake($1.str, $1.length);
+ if ($$.str == NULL)
+ MYSQL_YYABORT;
$$.length= $1.length;
}
;
@@ -8723,29 +9768,50 @@ sys_option_value:
LEX *lex=Lex;
if ($1)
lex->option_type= $1;
- lex->var_list.push_back(new set_var(lex->option_type,
- find_sys_var("tx_isolation"),
- &null_lex_str,
- new Item_int((int32) $5)));
+ Item *item= new Item_int((int32) $5);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ set_var *var= new set_var(lex->option_type,
+ find_sys_var("tx_isolation"),
+ &null_lex_str,
+ item);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ lex->var_list.push_back(var);
}
;
option_value:
'@' ident_or_text equal expr
{
- Lex->var_list.push_back(new set_var_user(new Item_func_set_user_var($2,$4)));
+ Item_func_set_user_var *item= new Item_func_set_user_var($2,$4);
+ if (item == NULL)
+ MYSQL_YYABORT;
+ set_var_user *var= new set_var_user(item);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ Lex->var_list.push_back(var);
}
| '@' '@' opt_var_ident_type internal_variable_name equal set_expr_or_default
{
LEX *lex=Lex;
- lex->var_list.push_back(new set_var($3, $4.var, &$4.base_name, $6));
+ set_var *var= new set_var($3, $4.var, &$4.base_name, $6);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ lex->var_list.push_back(var);
}
| charset old_or_new_charset_name_or_default
{
THD *thd= YYTHD;
LEX *lex= Lex;
$2= $2 ? $2: global_system_variables.character_set_client;
- lex->var_list.push_back(new set_var_collation_client($2,thd->variables.collation_database,$2));
+ set_var_collation_client *var;
+ var= new set_var_collation_client($2,
+ thd->variables.collation_database,
+ $2);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ lex->var_list.push_back(var);
}
| NAMES_SYM equal expr
{
@@ -8773,7 +9839,11 @@ option_value:
$3->name, $2->csname);
MYSQL_YYABORT;
}
- lex->var_list.push_back(new set_var_collation_client($3,$3,$3));
+ set_var_collation_client *var;
+ var= new set_var_collation_client($3,$3,$3);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ lex->var_list.push_back(var);
}
| PASSWORD equal text_or_password
{
@@ -8794,11 +9864,17 @@ option_value:
MYSQL_YYABORT;
user->host=null_lex_str;
user->user.str=thd->security_ctx->priv_user;
- thd->lex->var_list.push_back(new set_var_password(user, $3));
+ set_var_password *var= new set_var_password(user, $3);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ thd->lex->var_list.push_back(var);
}
| PASSWORD FOR_SYM user equal text_or_password
{
- Lex->var_list.push_back(new set_var_password($3,$5));
+ set_var_password *var= new set_var_password($3,$5);
+ if (var == NULL)
+ MYSQL_YYABORT;
+ Lex->var_list.push_back(var);
}
;
@@ -8912,11 +9988,15 @@ text_or_password:
Item_func_old_password::alloc(YYTHD, $3.str) :
Item_func_password::alloc(YYTHD, $3.str) :
$3.str;
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
| OLD_PASSWORD '(' TEXT_STRING ')'
{
$$= $3.length ? Item_func_old_password::alloc(YYTHD, $3.str) :
$3.str;
+ if ($$ == NULL)
+ MYSQL_YYABORT;
}
;
@@ -8924,9 +10004,24 @@ text_or_password:
set_expr_or_default:
expr { $$=$1; }
| DEFAULT { $$=0; }
- | ON { $$=new Item_string("ON", 2, system_charset_info); }
- | ALL { $$=new Item_string("ALL", 3, system_charset_info); }
- | BINARY { $$=new Item_string("binary", 6, system_charset_info); }
+ | ON
+ {
+ $$=new Item_string("ON", 2, system_charset_info);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | ALL
+ {
+ $$=new Item_string("ALL", 3, system_charset_info);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
+ | BINARY
+ {
+ $$=new Item_string("binary", 6, system_charset_info);
+ if ($$ == NULL)
+ MYSQL_YYABORT;
+ }
;
@@ -9027,7 +10122,10 @@ handler:
}
lex->sql_command = SQLCOM_HA_READ;
lex->ha_rkey_mode= HA_READ_KEY_EXACT; /* Avoid purify warnings */
- lex->current_select->select_limit= new Item_int((int32) 1);
+ Item *one= new Item_int((int32) 1);
+ if (one == NULL)
+ MYSQL_YYABORT;
+ lex->current_select->select_limit= one;
lex->current_select->offset_limit= 0;
if (!lex->current_select->add_table_to_list(lex->thd, $2, 0, 0))
MYSQL_YYABORT;
@@ -9334,8 +10432,9 @@ grant_user:
{
char *buff=
(char *) YYTHD->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH_323+1);
- if (buff)
- make_scrambled_password_323(buff, $4.str);
+ if (buff == NULL)
+ MYSQL_YYABORT;
+ make_scrambled_password_323(buff, $4.str);
$1->password.str= buff;
$1->password.length= SCRAMBLED_PASSWORD_CHAR_LENGTH_323;
}
@@ -9343,8 +10442,9 @@ grant_user:
{
char *buff=
(char *) YYTHD->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH+1);
- if (buff)
- make_scrambled_password(buff, $4.str);
+ if (buff == NULL)
+ MYSQL_YYABORT;
+ make_scrambled_password(buff, $4.str);
$1->password.str= buff;
$1->password.length= SCRAMBLED_PASSWORD_CHAR_LENGTH;
}
@@ -9373,6 +10473,8 @@ column_list_id:
ident
{
String *new_str = new (YYTHD->mem_root) String((const char*) $1.str,$1.length,system_charset_info);
+ if (new_str == NULL)
+ MYSQL_YYABORT;
List_iterator <LEX_COLUMN> iter(Lex->columns);
class LEX_COLUMN *point;
LEX *lex=Lex;
@@ -9386,7 +10488,12 @@ column_list_id:
if (point)
point->rights |= lex->which_columns;
else
- lex->columns.push_back(new LEX_COLUMN (*new_str,lex->which_columns));
+ {
+ LEX_COLUMN *col= new LEX_COLUMN (*new_str,lex->which_columns);
+ if (col == NULL)
+ MYSQL_YYABORT;
+ lex->columns.push_back(col);
+ }
}
;
@@ -9800,13 +10907,17 @@ view_list_opt:
view_list:
ident
{
- Lex->view_list.push_back((LEX_STRING*)
- sql_memdup(&$1, sizeof(LEX_STRING)));
+ LEX_STRING *ls= (LEX_STRING*) sql_memdup(&$1, sizeof(LEX_STRING));
+ if (ls == NULL)
+ MYSQL_YYABORT;
+ Lex->view_list.push_back(ls);
}
| view_list ',' ident
{
- Lex->view_list.push_back((LEX_STRING*)
- sql_memdup(&$3, sizeof(LEX_STRING)));
+ LEX_STRING *ls= (LEX_STRING*) sql_memdup(&$3, sizeof(LEX_STRING));
+ if (ls == NULL)
+ MYSQL_YYABORT;
+ Lex->view_list.push_back(ls);
}
;
@@ -9979,6 +11090,8 @@ sf_tail:
/* Order is important here: new - reset - init */
sp= new sp_head();
+ if (sp == NULL)
+ MYSQL_YYABORT;
sp->reset_thd_mem_root(thd);
sp->init(lex);
sp->init_sp_name(thd, lex->spname);
=== modified file 'sql/thr_malloc.cc'
--- a/sql/thr_malloc.cc 2006-12-31 00:02:27 +0000
+++ b/sql/thr_malloc.cc 2008-08-11 16:10:00 +0000
@@ -21,10 +21,35 @@
extern "C" {
void sql_alloc_error_handler(void)
{
- THD *thd=current_thd;
- if (thd) // QQ; To be removed
- thd->fatal_error(); /* purecov: inspected */
sql_print_error(ER(ER_OUT_OF_RESOURCES));
+
+ THD *thd=current_thd;
+ if (thd)
+ {
+ /*
+ This thread is Out Of Memory.
+ An OOM condition is a fatal error.
+ It should not be caught by error handlers in stored procedures.
+ Also, recording that SQL condition in the condition area could
+ cause more memory allocations, which in turn could raise more
+ OOM conditions, causing recursion in the error handling code itself.
+ As a result, my_error() should not be invoked, and the
+ thread diagnostics area is set to an error status directly.
+ The visible result for a client application will be:
+ - a query fails with an ER_OUT_OF_RESOURCES error,
+ returned in the error packet.
+ - SHOW ERROR/SHOW WARNINGS may be empty.
+ */
+
+ NET *net= &thd->net;
+ thd->fatal_error();
+ if (!net->last_error[0]) // Return only first message
+ {
+ strmake(net->last_error, ER(ER_OUT_OF_RESOURCES),
+ sizeof(net->last_error)-1);
+ net->last_errno= ER_OUT_OF_RESOURCES;
+ }
+ }
}
}
=== modified file 'support-files/build-tags'
--- a/support-files/build-tags 2002-01-20 02:16:52 +0000
+++ b/support-files/build-tags 2008-08-06 20:25:25 +0000
@@ -2,8 +2,11 @@
rm -f TAGS
filter='\.cc$\|\.c$\|\.h$\|\.yy$'
-files=`bk -r sfiles -gU | grep $filter `
-for f in $files ;
+
+list="find . -type f"
+bzr root >/dev/null 2>/dev/null && list="bzr ls --kind=file --versioned"
+
+$list |grep $filter |while read f;
do
etags -o TAGS --append $f
done
=== modified file 'tests/mysql_client_test.c'
--- a/tests/mysql_client_test.c 2008-05-27 11:33:08 +0000
+++ b/tests/mysql_client_test.c 2008-08-11 23:27:09 +0000
@@ -16189,6 +16189,38 @@ static void test_bug32265()
DBUG_VOID_RETURN;
}
+
+/**
+ Bug#38486 Crash when using cursor protocol
+*/
+
+static void test_bug38486(void)
+{
+ MYSQL_STMT *stmt;
+ const char *stmt_text;
+ unsigned long type= CURSOR_TYPE_READ_ONLY;
+
+ DBUG_ENTER("test_bug38486");
+ myheader("test_bug38486");
+
+ stmt= mysql_stmt_init(mysql);
+ mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*)&type);
+ stmt_text= "CREATE TABLE t1 (a INT)";
+ mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));
+ mysql_stmt_execute(stmt);
+ mysql_stmt_close(stmt);
+
+ stmt= mysql_stmt_init(mysql);
+ mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*)&type);
+ stmt_text= "INSERT INTO t1 VALUES (1)";
+ mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));
+ mysql_stmt_execute(stmt);
+ mysql_stmt_close(stmt);
+
+ DBUG_VOID_RETURN;
+}
+
+
/*
Read and parse arguments and MySQL options from my.cnf
*/
@@ -16483,6 +16515,7 @@ static struct my_tests_st my_tests[]= {
{ "test_bug29306", test_bug29306 },
{ "test_bug31669", test_bug31669 },
{ "test_bug32265", test_bug32265 },
+ { "test_bug38486", test_bug38486 },
{ 0, 0 }
};
| Thread | ||
|---|---|---|
| • bzr commit into mysql-5.0 branch (davi:2647) Bug#29738 Bug#31605 Bug#33362Bug#37201 Bug#37781 Bug#37830 Bug#38296 Bug#38486 | Davi Arnaut | 12 Aug |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 1.244 sec. using MySQL 5.1.14-beta-log