Bug#19194 (Right recursion in parser for CASE causes excessive stack usage,

  limitation)
Bug#24854 (Mixing Searched Case with Simple Case inside Stored Procedure
  crashes Mysqld)

Implemented code review (19194) comments

3 files changed, 178 insertions, 109 deletions

diff --git a/mysql-test/r/sp_stress_case.result b/mysql-test/r/sp_stress_case.result
index b85fb41d0bf..8ec68363c8d 100644
--- a/mysql-test/r/sp_stress_case.result
+++ b/mysql-test/r/sp_stress_case.result
@@ -1,42 +1,120 @@
-DROP PROCEDURE IF EXISTS bug_19194_a;
-DROP PROCEDURE IF EXISTS bug_19194_b;
-'Silently creating PROCEDURE bug_19194_a'
-'Silently creating PROCEDURE bug_19194_b'
-CALL bug_19194_a(1);
+DROP PROCEDURE IF EXISTS proc_19194_codegen;
+DROP PROCEDURE IF EXISTS bug_19194_simple;
+DROP PROCEDURE IF EXISTS bug_19194_searched;
+CREATE PROCEDURE proc_19194_codegen(
+IN proc_name VARCHAR(50),
+IN count INTEGER,
+IN simple INTEGER,
+OUT body MEDIUMTEXT)
+BEGIN
+DECLARE code MEDIUMTEXT;
+DECLARE i INT DEFAULT 1;
+SET code = concat("CREATE PROCEDURE ", proc_name, "(i INT)\n");
+SET code = concat(code, "BEGIN\n");
+SET code = concat(code, "  DECLARE str CHAR(10);\n");
+IF (simple)
+THEN
+SET code = concat(code, "  CASE i\n");
+ELSE
+SET code = concat(code, "  CASE\n");
+END IF;
+WHILE (i <= count)
+DO
+IF (simple)
+THEN
+SET code = concat(code, "    WHEN ", i, " THEN SET str=\"", i, "\";\n");
+ELSE
+SET code = concat(code, "    WHEN i=", i, " THEN SET str=\"", i, "\";\n");
+END IF;
+SET i = i + 1;
+END WHILE;
+SET code = concat(code, "    ELSE SET str=\"unknown\";\n");
+SET code = concat(code, "  END CASE;\n");
+SET code = concat(code, "  SELECT str;\n");
+SET code = concat(code, "END\n");
+SET body = code;
+END|
+set @body="";
+call proc_19194_codegen("test_simple", 10, 1, @body);
+select @body;
+@body
+CREATE PROCEDURE test_simple(i INT)
+BEGIN
+  DECLARE str CHAR(10);
+  CASE i
+    WHEN 1 THEN SET str="1";
+    WHEN 2 THEN SET str="2";
+    WHEN 3 THEN SET str="3";
+    WHEN 4 THEN SET str="4";
+    WHEN 5 THEN SET str="5";
+    WHEN 6 THEN SET str="6";
+    WHEN 7 THEN SET str="7";
+    WHEN 8 THEN SET str="8";
+    WHEN 9 THEN SET str="9";
+    WHEN 10 THEN SET str="10";
+    ELSE SET str="unknown";
+  END CASE;
+  SELECT str;
+END
+
+call proc_19194_codegen("test_searched", 10, 0, @body);
+select @body;
+@body
+CREATE PROCEDURE test_searched(i INT)
+BEGIN
+  DECLARE str CHAR(10);
+  CASE
+    WHEN i=1 THEN SET str="1";
+    WHEN i=2 THEN SET str="2";
+    WHEN i=3 THEN SET str="3";
+    WHEN i=4 THEN SET str="4";
+    WHEN i=5 THEN SET str="5";
+    WHEN i=6 THEN SET str="6";
+    WHEN i=7 THEN SET str="7";
+    WHEN i=8 THEN SET str="8";
+    WHEN i=9 THEN SET str="9";
+    WHEN i=10 THEN SET str="10";
+    ELSE SET str="unknown";
+  END CASE;
+  SELECT str;
+END
+
+CALL bug_19194_simple(1);
 str
 1
-CALL bug_19194_a(2);
+CALL bug_19194_simple(2);
 str
 2
-CALL bug_19194_a(1000);
+CALL bug_19194_simple(1000);
 str
 1000
-CALL bug_19194_a(4998);
+CALL bug_19194_simple(4998);
 str
 4998
-CALL bug_19194_a(4999);
+CALL bug_19194_simple(4999);
 str
 4999
-CALL bug_19194_a(9999);
+CALL bug_19194_simple(9999);
 str
 unknown
-CALL bug_19194_b(1);
+CALL bug_19194_searched(1);
 str
 1
-CALL bug_19194_b(2);
+CALL bug_19194_searched(2);
 str
 2
-CALL bug_19194_b(1000);
+CALL bug_19194_searched(1000);
 str
 1000
-CALL bug_19194_b(4998);
+CALL bug_19194_searched(4998);
 str
 4998
-CALL bug_19194_b(4999);
+CALL bug_19194_searched(4999);
 str
 4999
-CALL bug_19194_b(9999);
+CALL bug_19194_searched(9999);
 str
 unknown
-DROP PROCEDURE bug_19194_a;
-DROP PROCEDURE bug_19194_b;
+DROP PROCEDURE proc_19194_codegen;
+DROP PROCEDURE bug_19194_simple;
+DROP PROCEDURE bug_19194_searched;
diff --git a/mysql-test/t/sp_stress_case.sh b/mysql-test/t/sp_stress_case.sh
deleted file mode 100755
index a2ac948e110..00000000000
--- a/mysql-test/t/sp_stress_case.sh
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/bin/sh
-
-#
-# Bug#19194 (Right recursion in parser for CASE causes excessive stack
-#   usage, limitation)
-#
-# Because the code for the CASE statement is so massive,
-# checking in an already generated .test is not practical,
-# due to it's size (10 000 lines or 356 000 bytes).
-#
-# Patches are sent by email, which introduce size limitations.
-#
-# As a result, code is generated dynamically here.
-# This script takes no argument, and generates code in stdout.
-#
-
-cat <<EOF
-echo 'Silently creating PROCEDURE bug_19194_a';
---disable_query_log
-delimiter |;
-CREATE PROCEDURE bug_19194_a(i int)
-BEGIN
-DECLARE str CHAR(10);
-  CASE i
-EOF
-
-count=1;
-while true; do
-  echo "    WHEN $count THEN SET str=\"$count\";"
-  count=`expr $count + 1`
-  test $count -gt 5000 && break
-done
-
-cat <<EOF
-    ELSE SET str="unknown";
-  END CASE;
-  SELECT str;
-END|
-delimiter ;|
---enable_query_log
-EOF
-
-cat <<EOF
-echo 'Silently creating PROCEDURE bug_19194_b';
---disable_query_log
-delimiter |;
-CREATE PROCEDURE bug_19194_b(i int)
-BEGIN
-DECLARE str CHAR(10);
-  CASE
-EOF
-
-count=1;
-while true; do
-  echo "    WHEN i=$count THEN SET str=\"$count\";"
-  count=`expr $count + 1`
-  test $count -gt 5000 && break
-done
-
-cat <<EOF
-    ELSE SET str="unknown";
-  END CASE;
-  SELECT str;
-END|
-delimiter ;|
---enable_query_log
-EOF
-
diff --git a/mysql-test/t/sp_stress_case.test b/mysql-test/t/sp_stress_case.test
index ef9c31b6dcf..5b278802e26 100644
--- a/mysql-test/t/sp_stress_case.test
+++ b/mysql-test/t/sp_stress_case.test
@@ -1,35 +1,94 @@
-
-# The production code tested is not platform specific,
-# but /bin/sh is needed to run the test case.
-
---source include/not_windows.inc
-
 #
 # Bug#19194 (Right recursion in parser for CASE causes excessive stack
 #   usage, limitation)
 #
 
+# This test takes some time (8 min) in debug builds
+# It's provided as a separate file so that the next line can be uncommented
+# later if needed:
+# -- source include/big_test.inc
+
 --disable_warnings
-DROP PROCEDURE IF EXISTS bug_19194_a;
-DROP PROCEDURE IF EXISTS bug_19194_b;
+DROP PROCEDURE IF EXISTS proc_19194_codegen;
+DROP PROCEDURE IF EXISTS bug_19194_simple;
+DROP PROCEDURE IF EXISTS bug_19194_searched;
 --enable_warnings
 
---exec $MYSQL_TEST_DIR/t/sp_stress_case.sh | $MYSQL_TEST 2>&1
+delimiter |;
+
+CREATE PROCEDURE proc_19194_codegen(
+  IN proc_name VARCHAR(50),
+  IN count INTEGER,
+  IN simple INTEGER,
+  OUT body MEDIUMTEXT)
+BEGIN
+  DECLARE code MEDIUMTEXT;
+  DECLARE i INT DEFAULT 1;
+
+  SET code = concat("CREATE PROCEDURE ", proc_name, "(i INT)\n");
+  SET code = concat(code, "BEGIN\n");
+  SET code = concat(code, "  DECLARE str CHAR(10);\n");
+
+  IF (simple)
+  THEN
+    SET code = concat(code, "  CASE i\n");
+  ELSE
+    SET code = concat(code, "  CASE\n");
+  END IF;
+
+  WHILE (i <= count)
+  DO
+    IF (simple)
+    THEN
+      SET code = concat(code, "    WHEN ", i, " THEN SET str=\"", i, "\";\n");
+    ELSE
+      SET code = concat(code, "    WHEN i=", i, " THEN SET str=\"", i, "\";\n");
+    END IF;
+
+    SET i = i + 1;
+  END WHILE;
+
+  SET code = concat(code, "    ELSE SET str=\"unknown\";\n");
+  SET code = concat(code, "  END CASE;\n");
+  SET code = concat(code, "  SELECT str;\n");
+
+  SET code = concat(code, "END\n");
+
+  SET body = code;
+END|
+
+delimiter ;|
+
+set @body="";
+call proc_19194_codegen("test_simple", 10, 1, @body);
+select @body;
+call proc_19194_codegen("test_searched", 10, 0, @body);
+select @body;
+
+--disable_query_log
+call proc_19194_codegen("bug_19194_simple", 5000, 1, @body);
+let $proc_body = `select @body`;
+eval $proc_body;
+call proc_19194_codegen("bug_19194_searched", 5000, 1, @body);
+let $proc_body = `select @body`;
+eval $proc_body;
+--enable_query_log
 
-CALL bug_19194_a(1);
-CALL bug_19194_a(2);
-CALL bug_19194_a(1000);
-CALL bug_19194_a(4998);
-CALL bug_19194_a(4999);
-CALL bug_19194_a(9999);
+CALL bug_19194_simple(1);
+CALL bug_19194_simple(2);
+CALL bug_19194_simple(1000);
+CALL bug_19194_simple(4998);
+CALL bug_19194_simple(4999);
+CALL bug_19194_simple(9999);
 
-CALL bug_19194_b(1);
-CALL bug_19194_b(2);
-CALL bug_19194_b(1000);
-CALL bug_19194_b(4998);
-CALL bug_19194_b(4999);
-CALL bug_19194_b(9999);
+CALL bug_19194_searched(1);
+CALL bug_19194_searched(2);
+CALL bug_19194_searched(1000);
+CALL bug_19194_searched(4998);
+CALL bug_19194_searched(4999);
+CALL bug_19194_searched(9999);
 
-DROP PROCEDURE bug_19194_a;
-DROP PROCEDURE bug_19194_b;
+DROP PROCEDURE proc_19194_codegen;
+DROP PROCEDURE bug_19194_simple;
+DROP PROCEDURE bug_19194_searched;