From f603c1cce8fb44772f30d69ab402b036d1fb1593 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Fri, 6 Oct 2006 13:34:07 +0400
Subject: BUG#21726: Incorrect result with multiple invocations of
 LAST_INSERT_ID.

Note: bug#21726 does not directly apply to 4.1, as it doesn't have stored
procedures.  However, 4.1 had some bugs that were fixed in 5.0 by the
patch for bug#21726, and this patch is a backport of those fixes.
Namely, in 4.1 it fixes:

  - LAST_INSERT_ID(expr) didn't return value of expr (4.1 specific).

  - LAST_INSERT_ID() could return the value generated by current
    statement if the call happens after the generation, like in

      CREATE TABLE t1 (i INT AUTO_INCREMENT PRIMARY KEY, j INT);
      INSERT INTO t1 VALUES (NULL, 0), (NULL, LAST_INSERT_ID());

  - Redundant binary log LAST_INSERT_ID_EVENTs could be generated.


mysql-test/r/rpl_insert_id.result:
  Add result for bug#21726: Incorrect result with multiple invocations
  of LAST_INSERT_ID.
mysql-test/t/rpl_insert_id.test:
  Add test case for bug#21726: Incorrect result with multiple invocations
  of LAST_INSERT_ID.
sql/item_func.cc:
  Add implementation of Item_func_last_insert_id::fix_fields(), where we
  set THD::last_insert_id_used when statement calls LAST_INSERT_ID().
  In Item_func_last_insert_id::val_int(), return THD::current_insert_id
  if called like LAST_INSERT_ID(), otherwise return value of argument if
  called like LAST_INSERT_ID(expr).
sql/item_func.h:
  Add declaration of Item_func_last_insert_id::fix_fields().
sql/log_event.cc:
  Do not set THD::last_insert_id_used on LAST_INSERT_ID_EVENT.  Though we
  know the statement will call LAST_INSERT_ID(), it wasn't called yet.
sql/set_var.cc:
  In sys_var_last_insert_id::value_ptr(), set THD::last_insert_id_used,
  and return THD::current_insert_id for @@LAST_INSERT_ID.
sql/sql_class.h:
  Update comments.
  Remove THD::insert_id(), as it has lost its purpose now.
sql/sql_insert.cc:
  Now it is OK to read THD::last_insert_id directly.
sql/sql_load.cc:
  Now it is OK to read THD::last_insert_id directly.
sql/sql_parse.cc:
  In mysql_execute_command(), remember THD::last_insert_id (first
  generated value of the previous statement) in THD::current_insert_id,
  which then will be returned for LAST_INSERT_ID() and @@LAST_INSERT_ID.
sql/sql_select.cc:
  If "IS NULL" is replaced with "= <LAST_INSERT_ID>", use right value,
  which is THD::current_insert_id, and also set THD::last_insert_id_used
  to issue binary log LAST_INSERT_ID_EVENT.
sql/sql_update.cc:
  Now it is OK to read THD::last_insert_id directly.
tests/mysql_client_test.c:
  Add test case for bug#21726: Incorrect result with multiple invocations
  of LAST_INSERT_ID.
---
 mysql-test/r/rpl_insert_id.result | 27 ++++++++++++++++++++++
 mysql-test/t/rpl_insert_id.test   | 32 ++++++++++++++++++++++++++
 sql/item_func.cc                  | 31 ++++++++++++++++++++++---
 sql/item_func.h                   |  1 +
 sql/log_event.cc                  |  1 -
 sql/set_var.cc                    |  8 +++++--
 sql/sql_class.h                   | 48 +++++++++++++++++++++++++++------------
 sql/sql_insert.cc                 |  8 +++----
 sql/sql_load.cc                   | 12 ++++------
 sql/sql_parse.cc                  |  6 +++++
 sql/sql_select.cc                 | 11 +++++++--
 sql/sql_update.cc                 |  4 ++--
 tests/mysql_client_test.c         | 38 +++++++++++++++++++++++++++++++
 13 files changed, 189 insertions(+), 38 deletions(-)

diff --git a/mysql-test/r/rpl_insert_id.result b/mysql-test/r/rpl_insert_id.result
index fbdc9dc06cf..43aba68d041 100644
--- a/mysql-test/r/rpl_insert_id.result
+++ b/mysql-test/r/rpl_insert_id.result
@@ -108,6 +108,33 @@ a
 1
 drop table t1;
 drop table t2;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (
+i INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+j INT DEFAULT 0
+);
+INSERT INTO t1 VALUES (NULL, -1);
+INSERT INTO t1 VALUES (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID(5)),
+(NULL, @@LAST_INSERT_ID);
+INSERT INTO t1 VALUES (NULL, 0), (NULL, LAST_INSERT_ID());
+UPDATE t1 SET j= -1 WHERE i IS NULL;
+SELECT * FROM t1;
+i	j
+1	-1
+2	1
+3	5
+4	1
+5	-1
+6	2
+SELECT * FROM t1;
+i	j
+1	-1
+2	1
+3	5
+4	1
+5	-1
+6	2
+DROP TABLE t1;
 #
 # End of 4.1 tests
 #
diff --git a/mysql-test/t/rpl_insert_id.test b/mysql-test/t/rpl_insert_id.test
index 327094a1394..7fb514fb7af 100644
--- a/mysql-test/t/rpl_insert_id.test
+++ b/mysql-test/t/rpl_insert_id.test
@@ -108,6 +108,38 @@ drop table t1;
 drop table t2;
 sync_slave_with_master;
 
+
+#
+# BUG#21726: Incorrect result with multiple invocations of
+# LAST_INSERT_ID
+#
+connection master;
+
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (
+    i INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+    j INT DEFAULT 0
+);
+
+INSERT INTO t1 VALUES (NULL, -1);
+INSERT INTO t1 VALUES (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID(5)),
+                      (NULL, @@LAST_INSERT_ID);
+# Test replication of substitution "IS NULL" -> "= LAST_INSERT_ID".
+INSERT INTO t1 VALUES (NULL, 0), (NULL, LAST_INSERT_ID());
+UPDATE t1 SET j= -1 WHERE i IS NULL;
+
+SELECT * FROM t1;
+
+sync_slave_with_master;
+SELECT * FROM t1;
+
+connection master;
+DROP TABLE t1;
+
+
 --echo #
 --echo # End of 4.1 tests
 --echo #
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 91ccef6511f..6f8eed42e51 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -2230,6 +2230,30 @@ longlong Item_func_release_lock::val_int()
 }
 
 
+bool Item_func_last_insert_id::fix_fields(THD *thd, TABLE_LIST *tables,
+                                          Item **ref)
+{
+  DBUG_ASSERT(fixed == 0);
+
+  if (Item_int_func::fix_fields(thd, tables, ref))
+    return TRUE;
+
+  if (arg_count == 0)
+  {
+    /*
+      As this statement calls LAST_INSERT_ID(), set
+      THD::last_insert_id_used.
+    */
+    thd->last_insert_id_used= TRUE;
+    null_value= FALSE;
+  }
+
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+
+  return FALSE;
+}
+
+
 longlong Item_func_last_insert_id::val_int()
 {
   DBUG_ASSERT(fixed == 1);
@@ -2239,12 +2263,13 @@ longlong Item_func_last_insert_id::val_int()
     longlong value=args[0]->val_int();
     thd->insert_id(value);
     null_value=args[0]->null_value;
+    return value;
   }
-  else
-    thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return thd->last_insert_id_used ? thd->current_insert_id : thd->insert_id();
+
+  return thd->current_insert_id;
 }
 
+
 /* This function is just used to test speed of different functions */
 
 longlong Item_func_benchmark::val_int()
diff --git a/sql/item_func.h b/sql/item_func.h
index bc6c955b99f..467b88eda76 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -758,6 +758,7 @@ public:
   longlong val_int();
   const char *func_name() const { return "last_insert_id"; }
   void fix_length_and_dec() { if (arg_count) max_length= args[0]->max_length; }
+  bool fix_fields(THD *thd, TABLE_LIST *tables, Item **ref);
 };
 
 class Item_func_benchmark :public Item_int_func
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 19c32b2d28e..412ebbce0ac 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -2255,7 +2255,6 @@ int Intvar_log_event::exec_event(struct st_relay_log_info* rli)
 {
   switch (type) {
   case LAST_INSERT_ID_EVENT:
-    thd->last_insert_id_used = 1;
     thd->last_insert_id = val;
     break;
   case INSERT_ID_EVENT:
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 4acedc7bcbd..88e120632e2 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -2404,8 +2404,12 @@ bool sys_var_last_insert_id::update(THD *thd, set_var *var)
 byte *sys_var_last_insert_id::value_ptr(THD *thd, enum_var_type type,
 					LEX_STRING *base)
 {
-  thd->sys_var_tmp.long_value= (long) thd->insert_id();
-  return (byte*) &thd->last_insert_id;
+  /*
+    As this statement reads @@LAST_INSERT_ID, set
+    THD::last_insert_id_used.
+  */
+  thd->last_insert_id_used= TRUE;
+  return (byte*) &thd->current_insert_id;
 }
 
 
diff --git a/sql/sql_class.h b/sql/sql_class.h
index a995a492bc8..5c4c3af7acb 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -835,17 +835,29 @@ public:
     generated auto_increment value in handler.cc
   */
   ulonglong  next_insert_id;
+
   /*
-    The insert_id used for the last statement or set by SET LAST_INSERT_ID=#
-    or SELECT LAST_INSERT_ID(#).  Used for binary log and returned by
-    LAST_INSERT_ID()
+    At the beginning of the statement last_insert_id holds the first
+    generated value of the previous statement.  During statement
+    execution it is updated to the value just generated, but then
+    restored to the value that was generated first, so for the next
+    statement it will again be "the first generated value of the
+    previous statement".
+
+    It may also be set with "LAST_INSERT_ID(expr)" or
+    "@@LAST_INSERT_ID= expr", but the effect of such setting will be
+    seen only in the next statement.
   */
   ulonglong  last_insert_id;
+
   /*
-    Set to the first value that LAST_INSERT_ID() returned for the last
-    statement.  When this is set, last_insert_id_used is set to true.
+    current_insert_id remembers the first generated value of the
+    previous statement, and does not change during statement
+    execution.  Its value returned from LAST_INSERT_ID() and
+    @@LAST_INSERT_ID.
   */
   ulonglong  current_insert_id;
+
   ulonglong  limit_found_rows;
   ha_rows    cuted_fields,
              sent_row_count, examined_row_count;
@@ -896,7 +908,22 @@ public:
   bool	     locked, some_tables_deleted;
   bool       last_cuted_field;
   bool	     no_errors, password, is_fatal_error;
-  bool	     query_start_used,last_insert_id_used,insert_id_used,rand_used;
+  bool	     query_start_used, rand_used;
+
+  /*
+    last_insert_id_used is set when current statement calls
+    LAST_INSERT_ID() or reads @@LAST_INSERT_ID, so that binary log
+    LAST_INSERT_ID_EVENT be generated.
+  */
+  bool	     last_insert_id_used;
+
+  /*
+    insert_id_used is set when current statement updates
+    THD::last_insert_id, so that binary log INSERT_ID_EVENT be
+    generated.
+  */
+  bool       insert_id_used;
+
   /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
   bool       substitute_null_with_insert_id;
   bool	     time_zone_used;
@@ -996,15 +1023,6 @@ public:
     insert_id_used=1;
     substitute_null_with_insert_id= TRUE;
   }
-  inline ulonglong insert_id(void)
-  {
-    if (!last_insert_id_used)
-    {      
-      last_insert_id_used=1;
-      current_insert_id=last_insert_id;
-    }
-    return last_insert_id;
-  }
   inline ulonglong found_rows(void)
   {
     return limit_found_rows;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 283fe571d53..43c7e5d456f 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -374,10 +374,8 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
     if (error)
       break;
     /*
-      If auto_increment values are used, save the first one
-       for LAST_INSERT_ID() and for the update log.
-       We can't use insert_id() as we don't want to touch the
-       last_insert_id_used flag.
+      If auto_increment values are used, save the first one for
+      LAST_INSERT_ID() and for the update log.
     */
     if (! id && thd->insert_id_used)
     {						// Get auto increment value
@@ -1687,7 +1685,7 @@ bool select_insert::send_data(List<Item> &values)
     {
       table->next_number_field->reset();
       if (! last_insert_id && thd->insert_id_used)
-        last_insert_id=thd->insert_id();
+        last_insert_id= thd->last_insert_id;
     }
   }
   DBUG_RETURN(error);
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index 4e6c458cc43..48862506729 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -466,10 +466,8 @@ read_fixed_length(THD *thd,COPY_INFO &info,TABLE *table,List<Item> &fields,
     if (write_record(table,&info))
       DBUG_RETURN(1);
     /*
-      If auto_increment values are used, save the first one
-       for LAST_INSERT_ID() and for the binary/update log.
-       We can't use insert_id() as we don't want to touch the
-       last_insert_id_used flag.
+      If auto_increment values are used, save the first one for
+      LAST_INSERT_ID() and for the binary/update log.
     */
     if (!id && thd->insert_id_used)
       id= thd->last_insert_id;
@@ -572,10 +570,8 @@ read_sep_field(THD *thd,COPY_INFO &info,TABLE *table,
     if (write_record(table,&info))
       DBUG_RETURN(1);
     /*
-      If auto_increment values are used, save the first one
-       for LAST_INSERT_ID() and for the binary/update log.
-       We can't use insert_id() as we don't want to touch the
-       last_insert_id_used flag.
+      If auto_increment values are used, save the first one for
+      LAST_INSERT_ID() and for the binary/update log.
     */
     if (!id && thd->insert_id_used)
       id= thd->last_insert_id;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 98199ed22f1..cb2fa0f7014 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1977,6 +1977,12 @@ mysql_execute_command(THD *thd)
   SELECT_LEX_UNIT *unit= &lex->unit;
   DBUG_ENTER("mysql_execute_command");
 
+  /*
+    Remember first generated insert id value of the previous
+    statement.
+  */
+  thd->current_insert_id= thd->last_insert_id;
+
   /*
     Reset warning count for each query that uses tables
     A better approach would be to reset this for any commands
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index da96c98cd4f..117795059f0 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -4820,7 +4820,7 @@ remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
       Field *field=((Item_field*) args[0])->field;
       if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&
 	  (thd->options & OPTION_AUTO_IS_NULL) &&
-	  thd->insert_id() && thd->substitute_null_with_insert_id)
+	  thd->current_insert_id && thd->substitute_null_with_insert_id)
       {
 #ifdef HAVE_QUERY_CACHE
 	query_cache_abort(&thd->net);
@@ -4828,9 +4828,16 @@ remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
 	COND *new_cond;
 	if ((new_cond= new Item_func_eq(args[0],
 					new Item_int("last_insert_id()",
-						     thd->insert_id(),
+						     thd->current_insert_id,
 						     21))))
 	{
+          /*
+            Set THD::last_insert_id_used manually, as this statement
+            uses LAST_INSERT_ID() in a sense, and should issue
+            LAST_INSERT_ID_EVENT.
+          */
+          thd->last_insert_id_used= TRUE;
+
 	  cond=new_cond;
 	  cond->fix_fields(thd, 0, &cond);
 	}
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index af4ba8025f9..51643fc611d 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -408,7 +408,7 @@ int mysql_update(THD *thd,
 	    (ulong) thd->cuted_fields);
     send_ok(thd,
 	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
-	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
+	    thd->insert_id_used ? thd->last_insert_id : 0L,buff);
     DBUG_PRINT("info",("%d records updated",updated));
   }
   thd->count_cuted_fields= CHECK_FIELD_IGNORE;		/* calc cuted fields */
@@ -1318,6 +1318,6 @@ bool multi_update::send_eof()
 	  (ulong) thd->cuted_fields);
   ::send_ok(thd,
 	    (thd->client_capabilities & CLIENT_FOUND_ROWS) ? found : updated,
-	    thd->insert_id_used ? thd->insert_id() : 0L,buff);
+	    thd->insert_id_used ? thd->last_insert_id : 0L,buff);
   return 0;
 }
diff --git a/tests/mysql_client_test.c b/tests/mysql_client_test.c
index 9fabde993b8..6ae9dcb9476 100644
--- a/tests/mysql_client_test.c
+++ b/tests/mysql_client_test.c
@@ -11908,6 +11908,43 @@ static void test_bug20152()
 }
 
 
+/*
+  Bug#21726: Incorrect result with multiple invocations of
+  LAST_INSERT_ID
+
+  Test that client gets updated value of insert_id on UPDATE that uses
+  LAST_INSERT_ID(expr).
+*/
+static void test_bug21726()
+{
+  const char *update_query = "UPDATE t1 SET i= LAST_INSERT_ID(i + 1)";
+  int rc;
+  my_ulonglong insert_id;
+
+  DBUG_ENTER("test_bug21726");
+  myheader("test_bug21726");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  myquery(rc);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (i INT)");
+  myquery(rc);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");
+  myquery(rc);
+
+  rc= mysql_query(mysql, update_query);
+  myquery(rc);
+  insert_id= mysql_insert_id(mysql);
+  DIE_UNLESS(insert_id == 2);
+
+  rc= mysql_query(mysql, update_query);
+  myquery(rc);
+  insert_id= mysql_insert_id(mysql);
+  DIE_UNLESS(insert_id == 3);
+
+  DBUG_VOID_RETURN;
+}
+
+
 /*
   Read and parse arguments and MySQL options from my.cnf
 */
@@ -12134,6 +12171,7 @@ static struct my_tests_st my_tests[]= {
   { "test_bug12925", test_bug12925 },
   { "test_bug15613", test_bug15613 },
   { "test_bug20152", test_bug20152 },
+  { "test_bug21726", test_bug21726 },
   { 0, 0 }
 };
 
-- 
cgit v1.2.1


From 469ff92d81d496862ed1fcb7cf700390b7c2de72 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Tue, 10 Oct 2006 13:44:04 +0400
Subject: Bug#19111: TRIGGERs selecting from a VIEW on the firing base table
 fail.

In a trigger or a function used in a statement it is possible to do
SELECT from a table being modified by the statement.  However,
encapsulation of such SELECT into a view and selecting from a view
instead of direct SELECT was not possible.

This happened because tables used by views (which in their turn
were used from functions/triggers) were not excluded from checks
in unique_table() routine as it happens for the rest of tables
added to the statement table list for prelocking.

With this fix we ignore all such tables in unique_table(), thus
providing consistency: inside a trigger or a functions SELECT from
a view may be used where plain SELECT is allowed.  Modification of
the same table from function or trigger is still disallowed.  Also,
this patch doesn't affect the case where SELECT from the table being
modified is done outside of function of trigger, such SELECTs are
still disallowed (this limitation and visibility problem when function
select from a table being modified are subjects of bug 21326).  See
also bug 22427.


mysql-test/r/view.result:
  Add result for bug#19111: TRIGGERs selecting from a VIEW on the
  firing base table fail.
mysql-test/t/view.test:
  Add test case for bug#19111: TRIGGERs selecting from a VIEW on the
  firing base table fail.
sql/sql_base.cc:
  In unique_table() do not check tables that are used in a stored
  function or a trigger ('prelocking_placeholder' is set).  If such
  function or a trigger will attempt to modify a table, the error will
  be given, however select is allowed there.
---
 mysql-test/r/view.result | 17 ++++++++++++++++-
 mysql-test/t/view.test   | 39 ++++++++++++++++++++++++++++++++++++++-
 sql/sql_base.cc          | 11 ++++++++---
 3 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 72cffb9531c..39db2164f2f 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -2735,4 +2735,19 @@ m	e
 4	a
 1	b
 DROP VIEW v1;
-DROP TABLE IF EXISTS t1,t2;
+DROP TABLE t1,t2;
+DROP FUNCTION IF EXISTS f1;
+DROP VIEW IF EXISTS v1;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT);
+INSERT INTO t1 VALUES (1);
+CREATE VIEW v1 AS SELECT MAX(i) FROM t1;
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+SET NEW.i = (SELECT * FROM v1) + 1;
+INSERT INTO t1 VALUES (1);
+CREATE FUNCTION f1() RETURNS INT RETURN (SELECT * FROM v1);
+UPDATE t1 SET i= f1();
+DROP FUNCTION f1;
+DROP VIEW v1;
+DROP TABLE t1;
+End of 5.0 tests.
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index a1c1e9b2ad1..56c0529a67b 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -2595,4 +2595,41 @@ CREATE TABLE t2 SELECT * FROM v1;
 SELECT * FROM t2;
 
 DROP VIEW v1;
-DROP TABLE IF EXISTS t1,t2;
+DROP TABLE t1,t2;
+
+
+#
+# Bug#19111: TRIGGERs selecting from a VIEW on the firing base table
+# fail
+#
+# Allow to select from a view on a table being modified in a trigger
+# and stored function, since plain select is allowed there.
+#
+--disable_warnings
+DROP FUNCTION IF EXISTS f1;
+DROP VIEW IF EXISTS v1;
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT);
+INSERT INTO t1 VALUES (1);
+
+CREATE VIEW v1 AS SELECT MAX(i) FROM t1;
+
+# Plain 'SET NEW.i = (SELECT MAX(i) FROM t1) + 1' works, so select
+# from a view should work too.
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+  SET NEW.i = (SELECT * FROM v1) + 1;
+INSERT INTO t1 VALUES (1);
+
+# Plain 'RETURN (SELECT MAX(i) FROM t1)' works in INSERT, so select
+# from a view should work too.
+CREATE FUNCTION f1() RETURNS INT RETURN (SELECT * FROM v1);
+UPDATE t1 SET i= f1();
+
+DROP FUNCTION f1;
+DROP VIEW v1;
+DROP TABLE t1;
+
+
+--echo End of 5.0 tests.
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 5383bb52aaa..858d820c85e 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -805,6 +805,10 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
     Also SELECT::exclude_from_table_unique_test used to exclude from check
     tables of main SELECT of multi-delete and multi-update
 
+    We also skip tables with TABLE_LIST::prelocking_placeholder set,
+    because we want to allow SELECTs from them, and their modification
+    will rise the error anyway.
+
     TODO: when we will have table/view change detection we can do this check
           only once for PS/SP
 
@@ -851,12 +855,13 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
     if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
          (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
         ((!res->table || res->table != table->table) &&
-         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
+         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
+         !res->prelocking_placeholder))
       break;
     /*
-      If we found entry of this table or or table of SELECT which already
+      If we found entry of this table or table of SELECT which already
       processed in derived table or top select of multi-update/multi-delete
-      (exclude_from_table_unique_test).
+      (exclude_from_table_unique_test) or prelocking placeholder.
     */
     table_list= res->next_global;
     DBUG_PRINT("info",
-- 
cgit v1.2.1


From 3177e8ebc49d95bb9c7768e5fc6aceb66bbb1783 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Tue, 10 Oct 2006 17:08:47 +0400
Subject: BUG#21354: (COUNT(*) = 1) not working in SELECT inside prepared      
      statement.

The problem was that during statement re-execution if the result was
empty the old result could be returned for group functions.

The solution is to implement proper cleanup() method in group
functions.


mysql-test/r/ps.result:
  Add result for bug#21354: (COUNT(*) = 1) not working in SELECT inside
  prepared statement.
mysql-test/t/func_gconcat.test:
  Add a comment that the test case is from bug#836.
mysql-test/t/ps.test:
  Add test case for bug#21354: (COUNT(*) = 1) not working in SELECT inside
  prepared statement.
sql/item_sum.cc:
  Call clear() in Item_sum_count::cleanup().
sql/item_sum.h:
  Add comments.
  Add proper cleanup() methods.
  Change Item_sum::no_rows_in_result() to call clear() instead of reset(),
  as the latter also issues add(), and there is nothing to add when there
  are no rows in result.
---
 mysql-test/r/ps.result         | 97 ++++++++++++++++++++++++++++++++++++++++++
 mysql-test/t/func_gconcat.test |  2 +-
 mysql-test/t/ps.test           | 74 +++++++++++++++++++++++++++++++-
 sql/item_sum.cc                |  1 +
 sql/item_sum.h                 | 48 ++++++++++++++++++++-
 5 files changed, 219 insertions(+), 3 deletions(-)

diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result
index 01aa4ddf859..82d8ba275b6 100644
--- a/mysql-test/r/ps.result
+++ b/mysql-test/r/ps.result
@@ -889,3 +889,100 @@ create temporary table if not exists t1 (a1 int);
 execute stmt;
 drop temporary table t1;
 deallocate prepare stmt;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT, INDEX(i));
+INSERT INTO t1 VALUES (1);
+PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+1	1.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;
+End of 4.1 tests.
diff --git a/mysql-test/t/func_gconcat.test b/mysql-test/t/func_gconcat.test
index 8f50690dd8b..21ec7362877 100644
--- a/mysql-test/t/func_gconcat.test
+++ b/mysql-test/t/func_gconcat.test
@@ -99,7 +99,7 @@ select ifnull(group_concat(concat(t1.id, ':', t1.name)), 'shortname') as 'withou
 select distinct ifnull(group_concat(concat(t1.id, ':', t1.name)), 'shortname') as 'with distinct: cutoff at length of shortname' from t1;
 drop table t1;
 
-# check zero rows
+# check zero rows (bug#836)
 create table t1(id int);
 create table t2(id int);
 insert into t1 values(0),(1);
diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test
index 0ca293eb1ba..03fcc241d23 100644
--- a/mysql-test/t/ps.test
+++ b/mysql-test/t/ps.test
@@ -951,4 +951,76 @@ execute stmt;
 drop temporary table t1;
 deallocate prepare stmt;
 
-# End of 4.1 tests
+
+#
+# BUG#21354: (COUNT(*) = 1) not working in SELECT inside prepared
+# statement 
+#
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT, INDEX(i));
+INSERT INTO t1 VALUES (1);
+
+PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;
+
+
+--echo End of 4.1 tests.
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 0b9b10d05d4..e480cb031d8 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -312,6 +312,7 @@ longlong Item_sum_count::val_int()
 void Item_sum_count::cleanup()
 {
   DBUG_ENTER("Item_sum_count::cleanup");
+  clear();
   Item_sum_int::cleanup();
   used_table_cache= ~(table_map) 0;
   DBUG_VOID_RETURN;
diff --git a/sql/item_sum.h b/sql/item_sum.h
index 0cc2a20faa3..ea0863fc41c 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -58,9 +58,30 @@ public:
   Item_sum(THD *thd, Item_sum *item);
   enum Type type() const { return SUM_FUNC_ITEM; }
   virtual enum Sumfunctype sum_func () const=0;
+
+  /*
+    This method is similar to add(), but it is called when the current
+    aggregation group changes. Thus it performs a combination of
+    clear() and add().
+  */
   inline bool reset() { clear(); return add(); };
+
+  /*
+    Prepare this item for evaluation of an aggregate value. This is
+    called by reset() when a group changes, or, for correlated
+    subqueries, between subquery executions.  E.g. for COUNT(), this
+    method should set count= 0;
+  */
   virtual void clear()= 0;
+
+  /*
+    This method is called for the next row in the same group. Its
+    purpose is to aggregate the new value to the previous values in
+    the group (i.e. since clear() was called last time). For example,
+    for COUNT(), do count++.
+  */
   virtual bool add()=0;
+
   /*
     Called when new group is started and results are being saved in
     a temporary table. Similar to reset(), but must also store value in
@@ -86,7 +107,17 @@ public:
   void make_field(Send_field *field);
   void print(String *str);
   void fix_num_length_and_dec();
-  void no_rows_in_result() { reset(); }
+
+  /*
+    This function is called by the execution engine to assign 'NO ROWS
+    FOUND' value to an aggregate item, when the underlying result set
+    has no rows. Such value, in a general case, may be different from
+    the default value of the item after 'clear()': e.g. a numeric item
+    may be initialized to 0 by clear() and to NULL by
+    no_rows_in_result().
+  */
+  void no_rows_in_result() { clear(); }
+
   virtual bool setup(THD *thd) {return 0;}
   virtual void make_unique() {}
   Item *get_tmp_table_item(THD *thd);
@@ -304,6 +335,11 @@ class Item_sum_avg :public Item_sum_num
   void no_rows_in_result() {}
   const char *func_name() const { return "avg"; }
   Item *copy_or_same(THD* thd);
+  void cleanup()
+  {
+    clear();
+    Item_sum_num::cleanup();
+  }
 };
 
 class Item_sum_variance;
@@ -361,6 +397,11 @@ class Item_sum_variance : public Item_sum_num
   void no_rows_in_result() {}
   const char *func_name() const { return "variance"; }
   Item *copy_or_same(THD* thd);
+  void cleanup()
+  {
+    clear();
+    Item_sum_num::cleanup();
+  }
 };
 
 class Item_sum_std;
@@ -485,6 +526,11 @@ public:
   void update_field();
   void fix_length_and_dec()
   { decimals=0; max_length=21; unsigned_flag=1; maybe_null=null_value=0; }
+  void cleanup()
+  {
+    clear();
+    Item_sum_int::cleanup();
+  }
 };
 
 
-- 
cgit v1.2.1


From 0540c6ad4bc0e293382ba54a908abaaf3d8a6278 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Tue, 10 Oct 2006 18:06:08 +0400
Subject: Fix after manual merge.

---
 mysql-test/r/ps.result | 335 ++++++++++++++-----------------------------------
 1 file changed, 97 insertions(+), 238 deletions(-)

diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result
index e7b41ac5ed6..b28192c2e73 100644
--- a/mysql-test/r/ps.result
+++ b/mysql-test/r/ps.result
@@ -546,7 +546,103 @@ GROUP_CONCAT(Track SEPARATOR ', ')
 CAD
 DEALLOCATE PREPARE STMT;
 DROP TABLE t1;
-End of 4.1 tests
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT, INDEX(i));
+INSERT INTO t1 VALUES (1);
+PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+1	1.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;
+End of 4.1 tests.
 create table t1 (a varchar(20));
 insert into t1 values ('foo');
 prepare stmt FROM 'SELECT char_length (a) FROM t1';
@@ -1064,243 +1160,6 @@ select @@max_prepared_stmt_count, @@prepared_stmt_count;
 @@max_prepared_stmt_count	@@prepared_stmt_count
 3	0
 set global max_prepared_stmt_count= @old_max_prepared_stmt_count;
-drop table if exists t1;
-create temporary table if not exists t1 (a1 int);
-prepare stmt from "delete t1 from t1 where (cast(a1/3 as unsigned) * 3) = a1";
-drop temporary table t1;
-create temporary table if not exists t1 (a1 int);
-execute stmt;
-drop temporary table t1;
-create temporary table if not exists t1 (a1 int);
-execute stmt;
-drop temporary table t1;
-create temporary table if not exists t1 (a1 int);
-execute stmt;
-drop temporary table t1;
-deallocate prepare stmt;
-DROP TABLE IF EXISTS t1;
-CREATE TABLE t1 (i INT, INDEX(i));
-INSERT INTO t1 VALUES (1);
-PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(COUNT(i) = 1)	COUNT(i)
-0	0
-SET @a = 1;
-EXECUTE stmt USING @a;
-(COUNT(i) = 1)	COUNT(i)
-1	1
-SET @a = 0;
-EXECUTE stmt USING @a;
-(COUNT(i) = 1)	COUNT(i)
-0	0
-PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(AVG(i) = 1)	AVG(i)
-NULL	NULL
-SET @a = 1;
-EXECUTE stmt USING @a;
-(AVG(i) = 1)	AVG(i)
-1	1.0000
-SET @a = 0;
-EXECUTE stmt USING @a;
-(AVG(i) = 1)	AVG(i)
-NULL	NULL
-PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(VARIANCE(i) = 1)	VARIANCE(i)
-NULL	NULL
-SET @a = 1;
-EXECUTE stmt USING @a;
-(VARIANCE(i) = 1)	VARIANCE(i)
-0	0.0000
-SET @a = 0;
-EXECUTE stmt USING @a;
-(VARIANCE(i) = 1)	VARIANCE(i)
-NULL	NULL
-PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(STDDEV(i) = 1)	STDDEV(i)
-NULL	NULL
-SET @a = 1;
-EXECUTE stmt USING @a;
-(STDDEV(i) = 1)	STDDEV(i)
-0	0.0000
-SET @a = 0;
-EXECUTE stmt USING @a;
-(STDDEV(i) = 1)	STDDEV(i)
-NULL	NULL
-PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_OR(i) = 1)	BIT_OR(i)
-0	0
-SET @a = 1;
-EXECUTE stmt USING @a;
-(BIT_OR(i) = 1)	BIT_OR(i)
-1	1
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_OR(i) = 1)	BIT_OR(i)
-0	0
-PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_AND(i) = 1)	BIT_AND(i)
-0	18446744073709551615
-SET @a = 1;
-EXECUTE stmt USING @a;
-(BIT_AND(i) = 1)	BIT_AND(i)
-1	1
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_AND(i) = 1)	BIT_AND(i)
-0	18446744073709551615
-PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_XOR(i) = 1)	BIT_XOR(i)
-0	0
-SET @a = 1;
-EXECUTE stmt USING @a;
-(BIT_XOR(i) = 1)	BIT_XOR(i)
-1	1
-SET @a = 0;
-EXECUTE stmt USING @a;
-(BIT_XOR(i) = 1)	BIT_XOR(i)
-0	0
-DEALLOCATE PREPARE stmt;
-DROP TABLE t1;
-End of 4.1 tests.
-create table t1 (a varchar(20));
-insert into t1 values ('foo');
-prepare stmt FROM 'SELECT char_length (a) FROM t1';
-ERROR 42000: FUNCTION test.char_length does not exist
-drop table t1;
-create table t1 (a char(3) not null, b char(3) not null,
-c char(3) not null, primary key  (a, b, c));
-create table t2 like t1;
-prepare stmt from
-"select t1.a from (t1 left outer join t2 on t2.a=1 and t1.b=t2.b)
-  where t1.a=1";
-execute stmt;
-a
-execute stmt;
-a
-execute stmt;
-a
-prepare stmt from
-"select t1.a, t1.b, t1.c, t2.a, t2.b, t2.c from
-(t1 left outer join t2 on t2.a=? and t1.b=t2.b)
-left outer join t2 t3 on t3.a=? where t1.a=?";
-set @a:=1, @b:=1, @c:=1;
-execute stmt using @a, @b, @c;
-a	b	c	a	b	c
-execute stmt using @a, @b, @c;
-a	b	c	a	b	c
-execute stmt using @a, @b, @c;
-a	b	c	a	b	c
-deallocate prepare stmt;
-drop table t1,t2;
-SET @aux= "SELECT COUNT(*)
-                FROM INFORMATION_SCHEMA.COLUMNS A,
-                INFORMATION_SCHEMA.COLUMNS B
-                WHERE A.TABLE_SCHEMA = B.TABLE_SCHEMA
-                AND A.TABLE_NAME = B.TABLE_NAME
-                AND A.COLUMN_NAME = B.COLUMN_NAME AND
-                A.TABLE_NAME = 'user'";
-prepare my_stmt from @aux;
-execute my_stmt;
-COUNT(*)
-37
-execute my_stmt;
-COUNT(*)
-37
-execute my_stmt;
-COUNT(*)
-37
-deallocate prepare my_stmt;
-drop procedure if exists p1|
-drop table if exists t1|
-create table t1 (id int)|
-insert into t1 values(1)|
-create procedure p1(a int, b int)
-begin
-declare c int;
-select max(id)+1 into c from t1;
-insert into t1 select a+b;
-insert into t1 select a-b;
-insert into t1 select a-c;
-end|
-set @a= 3, @b= 4|
-prepare stmt from "call p1(?, ?)"|
-execute stmt using @a, @b|
-execute stmt using @a, @b|
-select * from t1|
-id
-1
-7
--1
-1
-7
--1
--5
-deallocate prepare stmt|
-drop procedure p1|
-drop table t1|
-create table t1 (a int);
-insert into t1 (a) values (1), (2), (3), (4), (5), (6), (7), (8), (9), (10);
-prepare stmt from "select * from t1 limit ?, ?";
-set @offset=0, @limit=1;
-execute stmt using @offset, @limit;
-a
-1
-select * from t1 limit 0, 1;
-a
-1
-set @offset=3, @limit=2;
-execute stmt using @offset, @limit;
-a
-4
-5
-select * from t1 limit 3, 2;
-a
-4
-5
-prepare stmt from "select * from t1 limit ?";
-execute stmt using @limit;
-a
-1
-2
-prepare stmt from "select * from t1 where a in (select a from t1 limit ?)";
-ERROR 42000: This version of MySQL doesn't yet support 'LIMIT & IN/ALL/ANY/SOME subquery'
-prepare stmt from "select * from t1 union all select * from t1 limit ?, ?";
-set @offset=9;
-set @limit=2;
-execute stmt using @offset, @limit;
-a
-10
-1
-prepare stmt from "(select * from t1 limit ?, ?) union all
-                   (select * from t1 limit ?, ?) order by a limit ?";
-execute stmt using @offset, @limit, @offset, @limit, @limit;
-a
-10
-10
-drop table t1;
-deallocate prepare stmt;
-CREATE TABLE b12651_T1(a int) ENGINE=MYISAM;
-CREATE TABLE b12651_T2(b int) ENGINE=MYISAM;
-CREATE VIEW  b12651_V1 as SELECT b FROM b12651_T2;
-PREPARE b12651 FROM 'SELECT 1 FROM b12651_T1 WHERE a IN (SELECT b FROM b12651_V1)';
-EXECUTE b12651;
-1
-DROP VIEW b12651_V1;
-DROP TABLE b12651_T1, b12651_T2;
-DEALLOCATE PREPARE b12651;
 create table t1 (id int);
 prepare ins_call from "insert into t1 (id) values (1)";
 execute ins_call;
-- 
cgit v1.2.1


From 92b3a32b50f113da22233b8c6393d6242bb11437 Mon Sep 17 00:00:00 2001
From: unknown <andrey@example.com>
Date: Tue, 10 Oct 2006 17:59:46 +0200
Subject:   Remove direct mapping of enum interval_type to
 mysql.event.interval_field   This decoupling allows in further versions of
 MySQL enum interval_type to   be reordered without this affecting any
 backward compatibility in the   events code.   This changeset doesn't change
 any exposed behavior but makes events' code   more durable to changes outside
 of their code base.

  To the reviewer: There is no regression test included as it is impossible
  to construct one with the current infrastructure which can test it. To test
  the code one has create and event, then change the order of
  enum interval_type in my_time.h, update sql/time.cc, recompile the server
  and run it with scheduler running.


include/my_time.h:
  Add a reminder to keep enum interval_type and
  interval_type_to_name in sync
sql/event_data_objects.cc:
  When loading from disk don't use the integer value of
  mysql.event.interval_field because it could be different of the
  values of enum interval_type, if the latter is reordered in a later
  version of MySQL. Loaded from disk is the string value which is then
  resolved against interval_type_to_name to get the exact enum value we
  need for Event_queue_element::interval.
sql/event_db_repository.cc:
  Use interval_type_to_name from sql/time.cc during storage thus
  decoupling the value stored on disk (the enum) from the integer
  representation in memory. interval_type can be changed and as
  long as interval_type_to_name is kept in sync correct values will
  be saved to disk.
sql/mysql_priv.h:
  add proto of find_string_in_array
sql/strfunc.cc:
  Add a function for searching a LEX_STRING in an array of LEX_STRINGs
---
 include/my_time.h          |  2 ++
 sql/event_data_objects.cc  | 27 +++++++++++++++++++++------
 sql/event_db_repository.cc | 10 +++++-----
 sql/mysql_priv.h           |  2 ++
 sql/strfunc.cc             | 30 ++++++++++++++++++++++++++++++
 5 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/include/my_time.h b/include/my_time.h
index d0f2fc323d8..6f053e71000 100644
--- a/include/my_time.h
+++ b/include/my_time.h
@@ -100,6 +100,8 @@ int my_TIME_to_str(const MYSQL_TIME *l_time, char *to);
 /*
   The following must be sorted so that simple intervals comes first.
   (get_interval_value() depends on this)
+  When updating this enum please update 
+  LEX_STRING interval_type_to_name[] in sql/time.cc
 */
 
 enum interval_type
diff --git a/sql/event_data_objects.cc b/sql/event_data_objects.cc
index 4b9aa43b14b..afd10350bb5 100644
--- a/sql/event_data_objects.cc
+++ b/sql/event_data_objects.cc
@@ -886,14 +886,29 @@ Event_queue_element::load_from_row(TABLE *table)
     goto error;
 
   /*
-    In DB the values start from 1 but enum interval_type starts
-    from 0
+    We load the interval type from disk as string and then map it to
+    an integer. This decouples the values of enum interval_type
+    and values actually stored on disk. Therefore the type can be
+    reordered without risking incompatibilities of data between versions.
   */
   if (!table->field[ET_FIELD_TRANSIENT_INTERVAL]->is_null())
-    interval= (interval_type) ((ulonglong)
-          table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_int() - 1);
-  else
-    interval= (interval_type) 0;
+  {
+    int i;
+    char buff[MAX_FIELD_WIDTH];
+    String str(buff, sizeof(buff), &my_charset_bin);
+    LEX_STRING tmp;
+
+    table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_str(&str);
+    if (!(tmp.length= str.length()))
+      goto error;
+
+    tmp.str= str.c_ptr_safe();
+
+    i= find_string_in_array(interval_type_to_name, &tmp, system_charset_info);
+    if (i < 0)
+      goto error;
+    interval= (interval_type) i;
+  }
 
   table->field[ET_FIELD_LAST_EXECUTED]->get_date(&last_executed,
                                                  TIME_NO_ZERO_DATE);
diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc
index 464c26044c7..3d30aff669b 100644
--- a/sql/event_db_repository.cc
+++ b/sql/event_db_repository.cc
@@ -188,11 +188,11 @@ mysql_event_fill_row(THD *thd, TABLE *table, Event_parse_data *et,
     fields[ET_FIELD_INTERVAL_EXPR]->store((longlong)et->expression, TRUE);
 
     fields[ET_FIELD_TRANSIENT_INTERVAL]->set_notnull();
-    /*
-      In the enum (C) intervals start from 0 but in mysql enum valid values
-      start from 1. Thus +1 offset is needed!
-    */
-    fields[ET_FIELD_TRANSIENT_INTERVAL]->store((longlong)et->interval+1, TRUE);
+
+    fields[ET_FIELD_TRANSIENT_INTERVAL]->
+                            store(interval_type_to_name[et->interval].str,
+                                  interval_type_to_name[et->interval].length,
+                                  scs);
 
     fields[ET_FIELD_EXECUTE_AT]->set_null();
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 339ca9d965a..89a3a30c338 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1481,6 +1481,8 @@ uint find_type2(TYPELIB *lib, const char *find, uint length, CHARSET_INFO *cs);
 void unhex_type2(TYPELIB *lib);
 uint check_word(TYPELIB *lib, const char *val, const char *end,
 		const char **end_of_word);
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO *cs);
 
 
 bool is_keyword(const char *name, uint len);
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 2525703172f..ef769a5b16e 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -312,3 +312,33 @@ outp:
   return (uint32) (to - to_start);
 
 }
+
+
+/*
+  Searches for a LEX_STRING in an LEX_STRING array.
+
+  SYNOPSIS
+    find_string_in_array()
+      heap    The array
+      needle  The string to search for
+
+  NOTE
+    The last LEX_STRING in the array should have str member set to NULL
+
+  RETURN VALUES
+    -1   Not found
+    >=0  Ordinal position
+*/
+
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO * const cs)
+{
+  const LEX_STRING *pos;
+  for (pos= haystack; pos->str; pos++)
+    if (!cs->coll->strnncollsp(cs, (uchar *) pos->str, pos->length,
+                               (uchar *) needle->str, needle->length, 0))
+    {
+      return (pos - haystack);
+    }
+  return -1;
+}
-- 
cgit v1.2.1


From d07b5b24efe20d795ba1ca3aba3e4544cb0c0142 Mon Sep 17 00:00:00 2001
From: unknown <andrey@example.com>
Date: Tue, 10 Oct 2006 21:19:34 +0200
Subject: fix build failure on Solaris10

sql/mysql_priv.h:
  synchronize definition and declaration
---
 sql/mysql_priv.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 89a3a30c338..f06f38e3bcb 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1482,7 +1482,7 @@ void unhex_type2(TYPELIB *lib);
 uint check_word(TYPELIB *lib, const char *val, const char *end,
 		const char **end_of_word);
 int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
-                         CHARSET_INFO *cs);
+                         CHARSET_INFO * const cs);
 
 
 bool is_keyword(const char *name, uint len);
-- 
cgit v1.2.1


From 6d1fdc7308d73c439d7a2da6851199939cde93f4 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Thu, 12 Oct 2006 18:02:57 +0400
Subject: BUG#20953: create proc with a create view that uses local vars/params
            should fail to create

The problem was that this type of errors was checked during view
creation, which doesn't happen when CREATE VIEW is a statement of
a created stored routine.

The solution is to perform the checks at parse time.  The idea of the
fix is that the parser checks if a construction just parsed is allowed
in current circumstances by testing certain flags, and this flags are
reset for VIEWs.

The side effect of this change is that if the user already have
such bogus routines, it will now get a error when trying to do

  SHOW CREATE PROCEDURE proc;

(and some other) and when trying to execute such routine he will get

  ERROR 1457 (HY000): Failed to load routine test.p5. The table mysql.proc is missing, corrupt, or contains bad data (internal code -6)

However there should be very few such users (if any), and they may
(and should) drop these bogus routines.


mysql-test/r/sp-error.result:
  Add result for bug#20953: create proc with a create view that uses
  local vars/params should fail to create.
mysql-test/r/view.result:
  Update results.
mysql-test/t/sp-error.test:
  Add test case for bug#20953: create proc with a create view that uses
  local vars/params should fail to create.
mysql-test/t/view.test:
  Add second test for variable in a view.
  Remove SP variable in a view test, as it tests wrong behaviour.
  Add test for derived table in a view.
sql/sql_lex.cc:
  Remove LEX::variables_used.
sql/sql_lex.h:
  Remove LEX::variables_used and add st_parsing_options structure and
  LEX::parsing_options member.
sql/sql_view.cc:
  Move some error checking to sql/sql_yacc.yy.
sql/sql_yacc.yy:
  Check for disallowed syntax in a CREATE VIEW at parse time to rise a
  error when it is used inside CREATE PROCEDURE and CREATE FUNCTION, as
  well as by itself.
---
 mysql-test/r/sp-error.result |  24 ++++++++
 mysql-test/r/view.result     |  10 ++--
 mysql-test/t/sp-error.test   |  42 +++++++++++++
 mysql-test/t/view.test       |  20 ++-----
 sql/sql_lex.cc               |   1 -
 sql/sql_lex.h                |  21 ++++++-
 sql/sql_view.cc              |  22 +------
 sql/sql_yacc.yy              | 139 ++++++++++++++++++++++++++++++++-----------
 8 files changed, 204 insertions(+), 75 deletions(-)

diff --git a/mysql-test/r/sp-error.result b/mysql-test/r/sp-error.result
index 924963017eb..a967f4de10c 100644
--- a/mysql-test/r/sp-error.result
+++ b/mysql-test/r/sp-error.result
@@ -1174,3 +1174,27 @@ drop procedure bug15091;
 drop function if exists bug16896;
 create aggregate function bug16896() returns int return 1;
 ERROR 42000: AGGREGATE is not supported for stored functions
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT);
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO @a;
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO DUMPFILE "file";
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO OUTFILE "file";
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953()
+CREATE VIEW v AS SELECT i FROM t1 PROCEDURE ANALYSE();
+ERROR HY000: View's SELECT contains a 'PROCEDURE' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 FROM (SELECT 1) AS d1;
+ERROR HY000: View's SELECT contains a subquery in the FROM clause
+CREATE PROCEDURE bug20953(i INT) CREATE VIEW v AS SELECT i;
+ERROR HY000: View's SELECT contains a variable or parameter
+CREATE PROCEDURE bug20953()
+BEGIN
+DECLARE i INT;
+CREATE VIEW v AS SELECT i;
+END |
+ERROR HY000: View's SELECT contains a variable or parameter
+PREPARE stmt FROM "CREATE VIEW v AS SELECT ?";
+ERROR HY000: View's SELECT contains a variable or parameter
+DROP TABLE t1;
diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 72cffb9531c..99e71dd30bd 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -12,6 +12,9 @@ create table t1 (a int, b int);
 insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10);
 create view v1 (c,d) as select a,b+@@global.max_user_connections from t1;
 ERROR HY000: View's SELECT contains a variable or parameter
+create view v1 (c,d) as select a,b from t1
+where a = @@global.max_user_connections;
+ERROR HY000: View's SELECT contains a variable or parameter
 create view v1 (c) as select b+1 from t1;
 select c from v1;
 c
@@ -596,11 +599,6 @@ ERROR HY000: View 'test.v1' references invalid table(s) or column(s) or function
 drop view v1;
 create view v1 (a,a) as select 'a','a';
 ERROR 42S21: Duplicate column name 'a'
-drop procedure if exists p1;
-create procedure p1 () begin declare v int; create view v1 as select v; end;//
-call p1();
-ERROR HY000: View's SELECT contains a variable or parameter
-drop procedure p1;
 create table t1 (col1 int,col2 char(22));
 insert into t1 values(5,'Hello, world of views');
 create view v1 as select * from t1;
@@ -886,6 +884,8 @@ ERROR HY000: View's SELECT contains a 'INTO' clause
 create table t1 (a int);
 create view v1 as select a from t1 procedure analyse();
 ERROR HY000: View's SELECT contains a 'PROCEDURE' clause
+create view v1 as select 1 from (select 1) as d1;
+ERROR HY000: View's SELECT contains a subquery in the FROM clause
 drop table t1;
 create table t1 (s1 int, primary key (s1));
 create view v1 as select * from t1;
diff --git a/mysql-test/t/sp-error.test b/mysql-test/t/sp-error.test
index a4ab5d98922..2340bfdc899 100644
--- a/mysql-test/t/sp-error.test
+++ b/mysql-test/t/sp-error.test
@@ -1706,6 +1706,48 @@ drop function if exists bug16896;
 create aggregate function bug16896() returns int return 1;
 
 
+
+#
+# BUG#20953: create proc with a create view that uses local
+# vars/params should fail to create
+#
+# See test case for what syntax is forbidden in a view.
+#
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT);
+
+# We do not have to drop this procedure and view because they won't be
+# created.
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO @a;
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO DUMPFILE "file";
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO OUTFILE "file";
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953()
+  CREATE VIEW v AS SELECT i FROM t1 PROCEDURE ANALYSE();
+--error ER_VIEW_SELECT_DERIVED
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 FROM (SELECT 1) AS d1;
+--error ER_VIEW_SELECT_VARIABLE
+CREATE PROCEDURE bug20953(i INT) CREATE VIEW v AS SELECT i;
+delimiter |;
+--error ER_VIEW_SELECT_VARIABLE
+CREATE PROCEDURE bug20953()
+BEGIN
+  DECLARE i INT;
+  CREATE VIEW v AS SELECT i;
+END |
+delimiter ;|
+--error ER_VIEW_SELECT_VARIABLE
+PREPARE stmt FROM "CREATE VIEW v AS SELECT ?";
+
+DROP TABLE t1;
+
+
 #
 # BUG#NNNN: New bug synopsis
 #
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index a1c1e9b2ad1..48555960924 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -23,8 +23,11 @@ create table t1 (a int, b int);
 insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10);
 
 # view with variable
--- error 1351
+-- error ER_VIEW_SELECT_VARIABLE
 create view v1 (c,d) as select a,b+@@global.max_user_connections from t1;
+-- error ER_VIEW_SELECT_VARIABLE
+create view v1 (c,d) as select a,b from t1
+  where a = @@global.max_user_connections;
 
 # simple view
 create view v1 (c) as select b+1 from t1;
@@ -486,19 +489,6 @@ drop view v1;
 -- error 1060
 create view v1 (a,a) as select 'a','a';
 
-#
-# SP variables inside view test
-#
---disable_warnings
-drop procedure if exists p1;
---enable_warnings
-delimiter //;
-create procedure p1 () begin declare v int; create view v1 as select v; end;//
-delimiter ;//
--- error 1351
-call p1();
-drop procedure p1;
-
 #
 # updatablity should be transitive
 #
@@ -820,6 +810,8 @@ create view v1 as select 5 into outfile 'ttt';
 create table t1 (a int);
 -- error 1350
 create view v1 as select a from t1 procedure analyse();
+-- error ER_VIEW_SELECT_DERIVED
+create view v1 as select 1 from (select 1) as d1;
 drop table t1;
 
 #
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index efbf29cf207..6f3b785d87e 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -150,7 +150,6 @@ void lex_start(THD *thd, uchar *buf,uint length)
   lex->safe_to_cache_query= 1;
   lex->time_zone_tables_used= 0;
   lex->leaf_tables_insert= 0;
-  lex->variables_used= 0;
   lex->empty_field_list_on_rset= 0;
   lex->select_lex.select_number= 1;
   lex->next_state=MY_LEX_START;
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index e5b087fc72a..d2669fb4ec3 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -801,6 +801,25 @@ public:
 };
 
 
+/*
+  st_parsing_options contains the flags for constructions that are
+  allowed in the current statement.
+*/
+
+struct st_parsing_options
+{
+  bool allows_variable;
+  bool allows_select_into;
+  bool allows_select_procedure;
+  bool allows_derived;
+
+  st_parsing_options()
+    : allows_variable(TRUE), allows_select_into(TRUE),
+      allows_select_procedure(TRUE), allows_derived(TRUE)
+  {}
+};
+
+
 /* The state of the lex parsing. This is saved in the THD struct */
 
 typedef struct st_lex : public Query_tables_list
@@ -944,7 +963,7 @@ typedef struct st_lex : public Query_tables_list
   bool stmt_prepare_mode;
   bool safe_to_cache_query;
   bool subqueries, ignore;
-  bool variables_used;
+  st_parsing_options parsing_options;
   ALTER_INFO alter_info;
   /* Prepared statements SQL syntax:*/
   LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index 1561ade78af..a53e6bcf9a5 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -186,25 +186,9 @@ bool mysql_create_view(THD *thd,
   bool res= FALSE;
   DBUG_ENTER("mysql_create_view");
 
-  if (lex->proc_list.first ||
-      lex->result)
-  {
-    my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), (lex->result ?
-                                             "INTO" :
-                                             "PROCEDURE"));
-    res= TRUE;
-    goto err;
-  }
-  if (lex->derived_tables ||
-      lex->variables_used || lex->param_list.elements)
-  {
-    int err= (lex->derived_tables ?
-              ER_VIEW_SELECT_DERIVED :
-              ER_VIEW_SELECT_VARIABLE);
-    my_message(err, ER(err), MYF(0));
-    res= TRUE;
-    goto err;
-  }
+  /* This is ensured in the parser. */
+  DBUG_ASSERT(!lex->proc_list.first && !lex->result &&
+              !lex->param_list.elements && !lex->derived_tables);
 
   if (mode != VIEW_CREATE_NEW)
     sp_cache_invalidate();
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index deac9cb5c40..523a359e3dd 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -721,7 +721,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <item>
 	literal text_literal insert_ident order_ident
 	simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr
-	bool_term bool_factor bool_test bool_pri 
+	variable variable_aux bool_term bool_factor bool_test bool_pri 
 	predicate bit_expr bit_term bit_factor value_expr term factor
 	table_wild simple_expr udf_expr
 	expr_or_default set_expr_or_default interval_expr
@@ -4281,32 +4281,7 @@ simple_expr:
 	  }
 	| literal
 	| param_marker
-	| '@' ident_or_text SET_VAR expr
-	  {
-	    $$= new Item_func_set_user_var($2,$4);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' ident_or_text
-	  {
-	    $$= new Item_func_get_user_var($2);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' '@' opt_var_ident_type ident_or_text opt_component
-	  {
-
-            if ($4.str && $5.str && check_reserved_words(&$4))
-            {
-              yyerror(ER(ER_SYNTAX_ERROR));
-              YYABORT;
-            }
-	    if (!($$= get_system_var(YYTHD, $3, $4, $5)))
-	      YYABORT;
-	    Lex->variables_used= 1;
-	  }
+	| variable
 	| sum_expr
 	| simple_expr OR_OR_SYM simple_expr
 	  { $$= new Item_func_concat($1, $3); }
@@ -5006,6 +4981,46 @@ sum_expr:
 	    $5->empty();
 	  };
 
+variable:
+          '@'
+          {
+            if (! Lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+          }
+          variable_aux
+          {
+            $$= $3;
+          }
+          ;
+
+variable_aux:
+          ident_or_text SET_VAR expr
+          {
+            $$= new Item_func_set_user_var($1, $3);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | ident_or_text
+          {
+            $$= new Item_func_get_user_var($1);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | '@' opt_var_ident_type ident_or_text opt_component
+          {
+            if ($3.str && $4.str && check_reserved_words(&$3))
+            {
+              yyerror(ER(ER_SYNTAX_ERROR));
+              YYABORT;
+            }
+            if (!($$= get_system_var(YYTHD, $2, $3, $4)))
+              YYABORT;
+          }
+        ;
+
 opt_distinct:
     /* empty */ { $$ = 0; }
     |DISTINCT   { $$ = 1; };
@@ -5428,6 +5443,13 @@ select_derived_init:
           SELECT_SYM
           {
             LEX *lex= Lex;
+
+            if (! lex->parsing_options.allows_derived)
+            {
+              my_error(ER_VIEW_SELECT_DERIVED, MYF(0));
+              YYABORT;
+            }
+
             SELECT_LEX *sel= lex->current_select;
             TABLE_LIST *embedding;
             if (!sel->embedding || sel->end_nested_join(lex->thd))
@@ -5787,6 +5809,13 @@ procedure_clause:
 	| PROCEDURE ident			/* Procedure name */
 	  {
 	    LEX *lex=Lex;
+
+            if (! lex->parsing_options.allows_select_procedure)
+            {
+              my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "PROCEDURE");
+              YYABORT;
+            }
+
 	    if (&lex->select_lex != lex->current_select)
 	    {
 	      my_error(ER_WRONG_USAGE, MYF(0), "PROCEDURE", "subquery");
@@ -5886,28 +5915,40 @@ select_var_ident:
            ;
 
 into:
-        INTO OUTFILE TEXT_STRING_filesystem
+        INTO
+	{
+          if (! Lex->parsing_options.allows_select_into)
+          {
+            my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "INTO");
+            YYABORT;
+          }
+	}
+        into_destination
+        ;
+
+into_destination:
+        OUTFILE TEXT_STRING_filesystem
 	{
           LEX *lex= Lex;
           lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-          if (!(lex->exchange= new sql_exchange($3.str, 0)) ||
+          if (!(lex->exchange= new sql_exchange($2.str, 0)) ||
               !(lex->result= new select_export(lex->exchange)))
             YYABORT;
 	}
 	opt_field_term opt_line_term
-	| INTO DUMPFILE TEXT_STRING_filesystem
+	| DUMPFILE TEXT_STRING_filesystem
 	{
 	  LEX *lex=Lex;
 	  if (!lex->describe)
 	  {
 	    lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-	    if (!(lex->exchange= new sql_exchange($3.str,1)))
+	    if (!(lex->exchange= new sql_exchange($2.str,1)))
 	      YYABORT;
 	    if (!(lex->result= new select_dump(lex->exchange)))
 	      YYABORT;
 	  }
 	}
-        | INTO select_var_list_init
+        | select_var_list_init
 	{
 	  Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
 	}
@@ -7067,8 +7108,13 @@ param_marker:
         {
           THD *thd=YYTHD;
 	  LEX *lex= thd->lex;
-          Item_param *item= new Item_param((uint) (lex->tok_start -
-                                                   (uchar *) thd->query));
+          Item_param *item;
+          if (! lex->parsing_options.allows_variable)
+          {
+            my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+            YYABORT;
+          }
+          item= new Item_param((uint) (lex->tok_start - (uchar *) thd->query));
           if (!($$= item) || lex->param_list.push_back(item))
           {
             my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
@@ -7188,6 +7234,12 @@ simple_ident:
 	  if (spc && (spv = spc->find_variable(&$1)))
 	  {
             /* We're compiling a stored procedure and found a variable */
+            if (! lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+
             Item_splocal *splocal;
             splocal= new Item_splocal($1, spv->offset, spv->type,
                                       lex->tok_start_prev - 
@@ -7197,7 +7249,6 @@ simple_ident:
               splocal->m_sp= lex->sphead;
 #endif
 	    $$ = (Item*) splocal;
-            lex->variables_used= 1;
 	    lex->safe_to_cache_query=0;
 	  }
 	  else
@@ -9038,6 +9089,24 @@ view_list:
 	;
 
 view_select:
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= FALSE;
+          lex->parsing_options.allows_select_into= FALSE;
+          lex->parsing_options.allows_select_procedure= FALSE;
+          lex->parsing_options.allows_derived= FALSE;
+        }        
+        view_select_aux
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= TRUE;
+          lex->parsing_options.allows_select_into= TRUE;
+          lex->parsing_options.allows_select_procedure= TRUE;
+          lex->parsing_options.allows_derived= TRUE;
+        }
+        ;
+
+view_select_aux:
 	SELECT_SYM remember_name select_init2
 	{
           THD *thd=YYTHD;
-- 
cgit v1.2.1


From 788c31022ee2240780a794db7e360f78aa1b39ee Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Thu, 12 Oct 2006 18:30:59 +0400
Subject: Fix after manual merge.

mysql-test/r/sp-error.result:
  After merge fix.
mysql-test/t/sp-error.test:
  Fix delimiter restoration.
---
 mysql-test/r/sp-error.result |  8 +++----
 mysql-test/t/sp-error.test   | 57 +++++++++++++++++++++++---------------------
 2 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/mysql-test/r/sp-error.result b/mysql-test/r/sp-error.result
index cde4f7d5f3a..d955b69bde2 100644
--- a/mysql-test/r/sp-error.result
+++ b/mysql-test/r/sp-error.result
@@ -1258,9 +1258,9 @@ show authors;
 return 42;
 end|
 ERROR 0A000: Not allowed to return a result set from a function
-drop function if exists bug20701|
-create function bug20701() returns varchar(25) binary return "test"|
+drop function if exists bug20701;
+create function bug20701() returns varchar(25) binary return "test";
 ERROR 42000: This version of MySQL doesn't yet support 'return value collation'
-create function bug20701() returns varchar(25) return "test"|
-drop function bug20701|
+create function bug20701() returns varchar(25) return "test";
+drop function bug20701;
 End of 5.1 tests
diff --git a/mysql-test/t/sp-error.test b/mysql-test/t/sp-error.test
index bd89b1b7344..8754d9ca82d 100644
--- a/mysql-test/t/sp-error.test
+++ b/mysql-test/t/sp-error.test
@@ -1769,27 +1769,6 @@ BEGIN
 END;
 
 
-#
-# End of 5.0 tests
-#
---echo End of 5.0 tests
-
-#
-# Bug#16164 "Easter egg": check that SHOW AUTHORS is disabled in
-# stored functions/triggers
-#
---disable_warnings
-drop function if exists bug16164;
---enable_warnings
-delimiter |;
---error ER_SP_NO_RETSET
-create function bug16164() returns int
-begin
-  show authors;
-  return 42;
-end|
-
-
 #
 # BUG#20953: create proc with a create view that uses local
 # vars/params should fail to create
@@ -1831,11 +1810,33 @@ PREPARE stmt FROM "CREATE VIEW v AS SELECT ?";
 DROP TABLE t1;
 
 
+#
+# End of 5.0 tests
+#
+--echo End of 5.0 tests
+
+#
+# Bug#16164 "Easter egg": check that SHOW AUTHORS is disabled in
+# stored functions/triggers
+#
+--disable_warnings
+drop function if exists bug16164;
+--enable_warnings
+delimiter |;
+--error ER_SP_NO_RETSET
+create function bug16164() returns int
+begin
+  show authors;
+  return 42;
+end|
+delimiter ;|
+
+
 #
 # BUG#20701: BINARY keyword should be forbidden in stored routines
 #
 --disable_warnings
-drop function if exists bug20701|
+drop function if exists bug20701;
 --enable_warnings
 #
 # This was disabled in 5.1.12. See bug #20701
@@ -1843,17 +1844,19 @@ drop function if exists bug20701|
 # be removed.
 #
 --error ER_NOT_SUPPORTED_YET
-create function bug20701() returns varchar(25) binary return "test"|
-create function bug20701() returns varchar(25) return "test"|
-drop function bug20701|
+create function bug20701() returns varchar(25) binary return "test";
+create function bug20701() returns varchar(25) return "test";
+drop function bug20701;
+
+
 --echo End of 5.1 tests
 
 #
 # BUG#NNNN: New bug synopsis
 #
 #--disable_warnings
-#drop procedure if exists bugNNNN|
-#drop function if exists bugNNNN|
+#drop procedure if exists bugNNNN;
+#drop function if exists bugNNNN;
 #--enable_warnings
 #create procedure bugNNNN...
 #create function bugNNNN...
-- 
cgit v1.2.1


From ef2d2165d1062f0a4d60ca3947de64fd9b6638d0 Mon Sep 17 00:00:00 2001
From: unknown <kroki/tomash@moonlight.intranet>
Date: Thu, 19 Oct 2006 14:43:52 +0400
Subject: BUG#21856: Prepared Statements: crash if bad create

When statement to be prepared contained CREATE PROCEDURE, CREATE FUNCTION
or CREATE TRIGGER statements with a syntax error in it, the preparation
would fail with syntax error message, but the memory could be corrupted.

The problem occurred because we switch memroot when parse stored
routine or trigger definitions, and on parse error we restored the
original memroot only after performing some memory operations.  In more
detail:
 - prepared statement would activate its own memory root to parse
   the definition of the stored procedure.
 - SP would reset this memory root with its own memory root to
   parse SP statements
 - a syntax error would happen
 - prepared statement would restore the original memory root
 - stored procedure would restore what it thinks was the original
   memory root, but actually was the statement memory root.
That led to double free - in destruction of the statement and in
a next call to mysql_parse().

The solution is to restore memroot right after the failed parsing.


mysql-test/r/ps.result:
  Add result for bug#21856: Prepared Statements: crash if bad create.
mysql-test/t/ps.test:
  Add test case for bug#21856: Prepared Statements: crash if bad create.
sql/sql_parse.cc:
  On parse error if thd->lex->sphead is set we have to free sp_head object
  to restore statement memroot, if it was switched during parsing.

  The change here is for safety, currently query_cache_abort() and
  lex->unit.cleanup() calls do not use current memroot.
sql/sql_prepare.cc:
  On parse error if thd->lex->sphead is set we have to free sp_head object
  to restore statement memroot, if it was switched during parsing.
---
 mysql-test/r/ps.result |  1 +
 mysql-test/t/ps.test   | 20 ++++++++++++++++++++
 sql/sql_parse.cc       |  9 +++++++--
 sql/sql_prepare.cc     | 11 +++++++++++
 4 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/ps.result b/mysql-test/r/ps.result
index 080187cfa7b..c895ef54e55 100644
--- a/mysql-test/r/ps.result
+++ b/mysql-test/r/ps.result
@@ -1311,4 +1311,5 @@ EXECUTE stmt USING @a;
 i	j	i	i	j
 DEALLOCATE PREPARE stmt;
 DROP TABLE IF EXISTS t1, t2, t3;
+DROP PROCEDURE IF EXISTS p1;
 End of 5.0 tests.
diff --git a/mysql-test/t/ps.test b/mysql-test/t/ps.test
index 5b2e37ecc94..fd74c52f3d5 100644
--- a/mysql-test/t/ps.test
+++ b/mysql-test/t/ps.test
@@ -1358,4 +1358,24 @@ DEALLOCATE PREPARE stmt;
 DROP TABLE IF EXISTS t1, t2, t3;
 
 
+#
+# BUG#21856: Prepared Statments: crash if bad create
+#
+--disable_warnings
+DROP PROCEDURE IF EXISTS p1;
+--enable_warnings
+
+let $iterations= 100;
+--disable_query_log
+--disable_result_log
+while ($iterations > 0)
+{
+  --error ER_PARSE_ERROR
+  PREPARE stmt FROM "CREATE PROCEDURE p1()";
+  dec $iterations;
+}
+--enable_query_log
+--enable_result_log
+
+
 --echo End of 5.0 tests.
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 2acbf18f1e6..f75bc5f073c 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -5852,14 +5852,19 @@ void mysql_parse(THD *thd, char *inBuf, uint length)
       DBUG_ASSERT(thd->net.report_error);
       DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
 			 thd->is_fatal_error));
-      query_cache_abort(&thd->net);
-      lex->unit.cleanup();
+
+      /*
+        The first thing we do after parse error is freeing sp_head to
+        ensure that we have restored original memroot.
+      */
       if (thd->lex->sphead)
       {
 	/* Clean up after failed stored procedure/function */
 	delete thd->lex->sphead;
 	thd->lex->sphead= NULL;
       }
+      query_cache_abort(&thd->net);
+      lex->unit.cleanup();
     }
     thd->proc_info="freeing items";
     thd->end_statement();
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index 32f0ca6859d..fcbf495463a 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -2773,6 +2773,16 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
 
   error= MYSQLparse((void *)thd) || thd->is_fatal_error ||
       thd->net.report_error || init_param_array(this);
+
+  /*
+    The first thing we do after parse error is freeing sp_head to
+    ensure that we have restored original memroot.
+  */
+  if (error && lex->sphead)
+  {
+    delete lex->sphead;
+    lex->sphead= NULL;
+  }
   /*
     While doing context analysis of the query (in check_prepared_statement)
     we allocate a lot of additional memory: for open tables, JOINs, derived
@@ -2798,6 +2808,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
   if (error == 0)
     error= check_prepared_statement(this, name.str != 0);
 
+  /* Free sp_head if check_prepared_statement() failed. */
   if (error && lex->sphead)
   {
     delete lex->sphead;
-- 
cgit v1.2.1


From 1a793de9e40179845b98454e9f1333464ef54e62 Mon Sep 17 00:00:00 2001
From: unknown <dlenev@mockturtle.local>
Date: Fri, 20 Oct 2006 15:47:52 +0400
Subject: Fix for bug#15228 "'invalid access to non-static data member'
 warnings in sql_trigger.cc and sql_view.cc".

According to the current version of C++ standard offsetof() macro
can't be used for non-POD types. So warnings were emitted when we
tried to use this macro for TABLE_LIST and Table_triggers_list
classes. Note that despite of these warnings it was probably safe
thing to do.

This fix tries to circumvent this limitation by implementing
custom version of offsetof() macro to be used with these
classes. This hack should go away once we will refactor
File_parser class.

Alternative approaches such as disabling this warning for
sql_trigger.cc/sql_view.cc or for the whole server were
considered less explicit. Also I was unable to find a way
to disable particular warning for particular _part_ of
file in GCC.


sql/parse_file.h:
  Introduced auxillary macro which can be used instead of offsetof()
  to get offsets of members in class for non-POD types without getting
  warnings (assuming that all instances of the class has same offsets
  for same members).
sql/sql_trigger.cc:
  Use my_offsetof() macro instead of standard offsetof() macro with
  Table_triggers_list class in order to avoid warnings (offsetof()
  cannot be used for non-POD types according to the standard).
sql/sql_view.cc:
  Use my_offsetof() macro instead of standard offsetof() macro with
  TABLE_LIST class in order to avoid warnings (offsetof() cannot
  be used for non-POD types according to the standard).
---
 sql/parse_file.h   | 16 ++++++++++++++++
 sql/sql_trigger.cc |  8 ++++----
 sql/sql_view.cc    | 24 ++++++++++++------------
 3 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/sql/parse_file.h b/sql/parse_file.h
index 33871588e11..5fb65b4c7ec 100644
--- a/sql/parse_file.h
+++ b/sql/parse_file.h
@@ -107,4 +107,20 @@ public:
 					bool bad_format_errors);
 };
 
+
+/*
+  Custom version of standard offsetof() macro which can be used to get
+  offsets of members in class for non-POD types (according to the current
+  version of C++ standard offsetof() macro can't be used in such cases and
+  attempt to do so causes warnings to be emitted, OTOH in many cases it is
+  still OK to assume that all instances of the class has the same offsets
+  for the same members).
+
+  This is temporary solution which should be removed once File_parser class
+  and related routines are refactored.
+*/
+
+#define my_offsetof(TYPE, MEMBER) \
+        ((size_t)((char *)&(((TYPE *)0x10)->MEMBER) - (char*)0x10))
+
 #endif /* _PARSE_FILE_H_ */
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index 6bb50d602c3..c6d85934820 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -36,17 +36,17 @@ static File_option triggers_file_parameters[]=
 {
   {
     {(char *) STRING_WITH_LEN("triggers") },
-    offsetof(class Table_triggers_list, definitions_list),
+    my_offsetof(class Table_triggers_list, definitions_list),
     FILE_OPTIONS_STRLIST
   },
   {
     {(char *) STRING_WITH_LEN("sql_modes") },
-    offsetof(class Table_triggers_list, definition_modes_list),
+    my_offsetof(class Table_triggers_list, definition_modes_list),
     FILE_OPTIONS_ULLLIST
   },
   {
     {(char *) STRING_WITH_LEN("definers") },
-    offsetof(class Table_triggers_list, definers_list),
+    my_offsetof(class Table_triggers_list, definers_list),
     FILE_OPTIONS_STRLIST
   },
   { { 0, 0 }, 0, FILE_OPTIONS_STRING }
@@ -55,7 +55,7 @@ static File_option triggers_file_parameters[]=
 File_option sql_modes_parameters=
 {
   {(char*) STRING_WITH_LEN("sql_modes") },
-  offsetof(class Table_triggers_list, definition_modes_list),
+  my_offsetof(class Table_triggers_list, definition_modes_list),
   FILE_OPTIONS_ULLLIST
 };
 
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index 4e2b48d9faf..12fa8cfc06a 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -582,40 +582,40 @@ static const int num_view_backups= 3;
 */
 static File_option view_parameters[]=
 {{{(char*) STRING_WITH_LEN("query")},
-  offsetof(TABLE_LIST, query),
+  my_offsetof(TABLE_LIST, query),
   FILE_OPTIONS_ESTRING},
  {{(char*) STRING_WITH_LEN("md5")},
-  offsetof(TABLE_LIST, md5),
+  my_offsetof(TABLE_LIST, md5),
   FILE_OPTIONS_STRING},
  {{(char*) STRING_WITH_LEN("updatable")},
-  offsetof(TABLE_LIST, updatable_view),
+  my_offsetof(TABLE_LIST, updatable_view),
   FILE_OPTIONS_ULONGLONG},
  {{(char*) STRING_WITH_LEN("algorithm")},
-  offsetof(TABLE_LIST, algorithm),
+  my_offsetof(TABLE_LIST, algorithm),
   FILE_OPTIONS_ULONGLONG},
  {{(char*) STRING_WITH_LEN("definer_user")},
-  offsetof(TABLE_LIST, definer.user),
+  my_offsetof(TABLE_LIST, definer.user),
   FILE_OPTIONS_STRING},
  {{(char*) STRING_WITH_LEN("definer_host")},
-  offsetof(TABLE_LIST, definer.host),
+  my_offsetof(TABLE_LIST, definer.host),
   FILE_OPTIONS_STRING},
  {{(char*) STRING_WITH_LEN("suid")},
-  offsetof(TABLE_LIST, view_suid),
+  my_offsetof(TABLE_LIST, view_suid),
   FILE_OPTIONS_ULONGLONG},
  {{(char*) STRING_WITH_LEN("with_check_option")},
-  offsetof(TABLE_LIST, with_check),
+  my_offsetof(TABLE_LIST, with_check),
   FILE_OPTIONS_ULONGLONG},
  {{(char*) STRING_WITH_LEN("revision")},
-  offsetof(TABLE_LIST, revision),
+  my_offsetof(TABLE_LIST, revision),
   FILE_OPTIONS_REV},
  {{(char*) STRING_WITH_LEN("timestamp")},
-  offsetof(TABLE_LIST, timestamp),
+  my_offsetof(TABLE_LIST, timestamp),
   FILE_OPTIONS_TIMESTAMP},
  {{(char*)STRING_WITH_LEN("create-version")},
-  offsetof(TABLE_LIST, file_version),
+  my_offsetof(TABLE_LIST, file_version),
   FILE_OPTIONS_ULONGLONG},
  {{(char*) STRING_WITH_LEN("source")},
-  offsetof(TABLE_LIST, source),
+  my_offsetof(TABLE_LIST, source),
   FILE_OPTIONS_ESTRING},
  {{NullS, 0},			0,
   FILE_OPTIONS_STRING}
-- 
cgit v1.2.1