List:Commits« Previous MessageNext Message »
From:Davi Arnaut Date:August 12 2008 6: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#38486Davi Arnaut12 Aug