Merge bk-internal.mysql.com:/home/bk/mysql-5.0

into  mysql.com:/home/my/mysql-5.0


sql/ha_ndbcluster.cc:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_union.cc:
  Manual merge (trivial)

22 files changed, 251 insertions, 204 deletions

diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc
index 793029ab4c7..105e4e26534 100644
--- a/sql/ha_berkeley.cc
+++ b/sql/ha_berkeley.cc
@@ -958,8 +958,6 @@ int ha_berkeley::write_row(byte * record)
   {
     DB_TXN *sub_trans = transaction;
     /* Don't use sub transactions in temporary tables */
-    ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ?
-                        table->in_use->options : 0);
     for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
     {
       key_map changed_keys(0);
@@ -1070,7 +1068,7 @@ int ha_berkeley::key_cmp(uint keynr, const byte * old_row,
 int ha_berkeley::update_primary_key(DB_TXN *trans, bool primary_key_changed,
 				    const byte * old_row, DBT *old_key,
 				    const byte * new_row, DBT *new_key,
-				    ulong thd_options, bool local_using_ignore)
+                                    bool local_using_ignore)
 {
   DBT row;
   int error;
@@ -1119,8 +1117,7 @@ int ha_berkeley::update_primary_key(DB_TXN *trans, bool primary_key_changed,
 int ha_berkeley::restore_keys(DB_TXN *trans, key_map *changed_keys,
 			      uint primary_key,
 			      const byte *old_row, DBT *old_key,
-			      const byte *new_row, DBT *new_key,
-			      ulong thd_options)
+			      const byte *new_row, DBT *new_key)
 {
   int error;
   DBT tmp_key;
@@ -1130,7 +1127,7 @@ int ha_berkeley::restore_keys(DB_TXN *trans, key_map *changed_keys,
   /* Restore the old primary key, and the old row, but don't ignore
      duplicate key failure */
   if ((error=update_primary_key(trans, TRUE, new_row, new_key,
-				old_row, old_key, thd_options, FALSE)))
+				old_row, old_key, FALSE)))
     goto err; /* purecov: inspected */
 
   /* Remove the new key, and put back the old key
@@ -1167,8 +1164,6 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row)
   DBT prim_key, key, old_prim_key;
   int error;
   DB_TXN *sub_trans;
-  ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ?
-                      table->in_use->options : 0);
   bool primary_key_changed;
   DBUG_ENTER("update_row");
   LINT_INIT(error);
@@ -1204,7 +1199,7 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row)
     if (!(error=update_primary_key(sub_trans, primary_key_changed,
 				   old_row, &old_prim_key,
 				   new_row, &prim_key,
-				   thd_options, using_ignore)))
+				   using_ignore)))
     {
       // Update all other keys
       for (uint keynr=0 ; keynr < table->s->keys ; keynr++)
@@ -1239,8 +1234,7 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row)
 	int new_error = 0;
         if (!changed_keys.is_clear_all())
 	  new_error=restore_keys(transaction, &changed_keys, primary_key,
-				 old_row, &old_prim_key, new_row, &prim_key,
-				 thd_options);
+				 old_row, &old_prim_key, new_row, &prim_key);
 	if (new_error)
 	{
           /* This shouldn't happen */
@@ -1342,8 +1336,6 @@ int ha_berkeley::delete_row(const byte * record)
   int error;
   DBT row, prim_key;
   key_map keys= table->s->keys_in_use;
-  ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ?
-                      table->in_use->options : 0);
   DBUG_ENTER("delete_row");
   statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
 
diff --git a/sql/ha_berkeley.h b/sql/ha_berkeley.h
index aa92908ecde..282641e3f25 100644
--- a/sql/ha_berkeley.h
+++ b/sql/ha_berkeley.h
@@ -74,13 +74,12 @@ class ha_berkeley: public handler
 		  DBT *prim_key, key_map *keys);
   int restore_keys(DB_TXN *trans, key_map *changed_keys, uint primary_key,
 		   const byte *old_row, DBT *old_key,
-		   const byte *new_row, DBT *new_key,
-		   ulong thd_options);
+		   const byte *new_row, DBT *new_key);
   int key_cmp(uint keynr, const byte * old_row, const byte * new_row);
   int update_primary_key(DB_TXN *trans, bool primary_key_changed,
 			 const byte * old_row, DBT *old_key,
 			 const byte * new_row, DBT *prim_key,
-			 ulong thd_options, bool local_using_ignore);
+			 bool local_using_ignore);
   int read_row(int error, char *buf, uint keynr, DBT *row, DBT *key, bool);
   DBT *get_pos(DBT *to, byte *pos);
 
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 7637b08c8ca..96d380d5ebb 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -6997,6 +6997,8 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
       break;
     Ndb_item *a= cond->next->ndb_item;
     Ndb_item *b, *field, *value= NULL;
+    LINT_INIT(field);
+
     switch (cond->ndb_item->argument_count()) {
     case 1:
       field= 
diff --git a/sql/init.cc b/sql/init.cc
index 4beb8db0c6f..e53eeab8902 100644
--- a/sql/init.cc
+++ b/sql/init.cc
@@ -39,12 +39,11 @@ void unireg_init(ulong options)
 #endif
 
   VOID(strmov(reg_ext,".frm"));
-  specialflag=SPECIAL_SAME_DB_NAME;
+  specialflag=SPECIAL_SAME_DB_NAME | options;  /* Set options from argv */
   /* Make a tab of powers of 10 */
   for (i=0,nr=1.0; i < array_elements(log_10) ; i++)
   {					/* It's used by filesort... */
     log_10[i]= nr ; nr*= 10.0;
   }
-  specialflag|=options;			/* Set options from argv */
   DBUG_VOID_RETURN;
 }
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 2d80a19aa55..e86d4f0d8ba 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -2291,8 +2291,7 @@ bool Item_sum_count_distinct::setup(THD *thd)
   DBUG_ASSERT(table == 0);
   if (!(table= create_tmp_table(thd, tmp_table_param, list, (ORDER*) 0, 1,
 				0,
-				(select_lex->options | thd->options) & 
-                                ~TMP_TABLE_FORCE_MYISAM,
+				(select_lex->options | thd->options),
 				HA_POS_ERROR, (char*)"")))
     return TRUE;
   table->file->extra(HA_EXTRA_NO_ROWS);		// Don't update rows
@@ -3074,8 +3073,7 @@ bool Item_func_group_concat::setup(THD *thd)
   */
   if (!(table= create_tmp_table(thd, tmp_table_param, all_fields,
                                 (ORDER*) 0, 0, TRUE,
-                                (select_lex->options | thd->options) & 
-                                ~TMP_TABLE_FORCE_MYISAM,
+                                (select_lex->options | thd->options),
                                 HA_POS_ERROR, (char*) "")))
     DBUG_RETURN(TRUE);
   table->file->extra(HA_EXTRA_NO_ROWS);
diff --git a/sql/lock.cc b/sql/lock.cc
index 568ca2b68af..941d7baa76e 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -849,10 +849,6 @@ static void print_lock_error(int error, const char *table)
   So in this exceptional case the COMMIT should not be blocked by the FLUSH
   TABLES WITH READ LOCK.
 
-  TODO in MySQL 5.x: make_global_read_lock_block_commit() should be
-  killable. Normally CPU does not spend a long time in this function (COMMITs
-  are quite fast), but it would still be nice.
-
 ****************************************************************************/
 
 volatile uint global_read_lock=0;
@@ -1003,7 +999,7 @@ bool make_global_read_lock_block_commit(THD *thd)
     pthread_cond_wait(&COND_refresh, &LOCK_global_read_lock);
   DBUG_EXECUTE_IF("make_global_read_lock_block_commit_loop",
                   protect_against_global_read_lock--;);
-  if (error= thd->killed)
+  if ((error= test(thd->killed)))
     global_read_lock_blocks_commit--; // undo what we did
   else
     thd->global_read_lock= MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT;
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index dae564a15c0..3dfd47d15c4 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -256,13 +256,6 @@ extern CHARSET_INFO *national_charset_info, *table_alias_charset;
 #define OPTION_WARNINGS         (1L << 13)      // THD, user
 #define OPTION_AUTO_IS_NULL     (1L << 14)      // THD, user, binlog
 #define OPTION_FOUND_COMMENT    (1L << 15)      // SELECT, intern, parser
-/* 
-  Force the used temporary table to be a MyISAM table (because we will use
-  fulltext functions when reading from it. This uses the same constant as
-  OPTION_FOUND_COMMENT because we've run out of bits and these two values 
-  are not used together.
-*/
-#define TMP_TABLE_FORCE_MYISAM          (1L << 15)
 #define OPTION_SAFE_UPDATES     (1L << 16)      // THD, user
 #define OPTION_BUFFER_RESULT    (1L << 17)      // SELECT, user
 #define OPTION_BIN_LOG          (1L << 18)      // THD, user
@@ -291,6 +284,11 @@ extern CHARSET_INFO *national_charset_info, *table_alias_charset;
 #define OPTION_SETUP_TABLES_DONE        (1L << 30) // intern
 /* If not set then the thread will ignore all warnings with level notes. */
 #define OPTION_SQL_NOTES                (1L << 31) // THD, user
+/* 
+  Force the used temporary table to be a MyISAM table (because we will use
+  fulltext functions when reading from it.
+*/
+#define TMP_TABLE_FORCE_MYISAM          (LL(1) << 32)
 
 /*
   Maximum length of time zone name that we support
@@ -726,7 +724,7 @@ int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields,
 		 enum enum_duplicates handle_duplicates, bool ignore);
 bool mysql_multi_update(THD *thd, TABLE_LIST *table_list,
                         List<Item> *fields, List<Item> *values,
-                        COND *conds, ulong options,
+                        COND *conds, ulonglong options,
                         enum enum_duplicates handle_duplicates, bool ignore,
                         SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex);
 bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list, TABLE *table,
@@ -742,7 +740,7 @@ int check_that_all_fields_are_given_values(THD *thd, TABLE *entry,
                                            TABLE_LIST *table_list);
 bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds);
 bool mysql_delete(THD *thd, TABLE_LIST *table, COND *conds, SQL_LIST *order,
-                  ha_rows rows, ulong options);
+                  ha_rows rows, ulonglong options);
 bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok);
 bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create);
 TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update);
@@ -1107,6 +1105,7 @@ extern char log_error_file[FN_REFLEN], *opt_tc_log_file;
 extern double log_10[32];
 extern ulonglong log_10_int[20];
 extern ulonglong keybuff_size;
+extern ulonglong thd_startup_options;
 extern ulong refresh_version,flush_version, thread_id;
 extern ulong binlog_cache_use, binlog_cache_disk_use;
 extern ulong aborted_threads,aborted_connects;
@@ -1116,7 +1115,7 @@ extern ulong delayed_insert_threads, delayed_insert_writes;
 extern ulong delayed_rows_in_use,delayed_insert_errors;
 extern ulong slave_open_temp_tables;
 extern ulong query_cache_size, query_cache_min_res_unit;
-extern ulong thd_startup_options, slow_launch_threads, slow_launch_time;
+extern ulong slow_launch_threads, slow_launch_time;
 extern ulong table_cache_size;
 extern ulong max_connections,max_connect_errors, connect_timeout;
 extern ulong slave_net_timeout, slave_trans_retries;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 4dddac6b2d1..7204c6e1572 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -387,8 +387,8 @@ uint delay_key_write_options, protocol_version;
 uint lower_case_table_names;
 uint tc_heuristic_recover= 0;
 uint volatile thread_count, thread_running;
-ulong back_log, connect_timeout, concurrency;
-ulong server_id, thd_startup_options;
+ulonglong thd_startup_options;
+ulong back_log, connect_timeout, concurrency, server_id;
 ulong table_cache_size, thread_stack, what_to_log;
 ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
 ulong open_files_limit, max_binlog_size, max_relay_log_size;
@@ -1908,7 +1908,8 @@ static void check_data_home(const char *path)
 static void sig_reload(int signo)
 {
  // Flush everything
-  reload_acl_and_cache((THD*) 0,REFRESH_LOG, (TABLE_LIST*) 0, NULL);
+  bool not_used;
+  reload_acl_and_cache((THD*) 0,REFRESH_LOG, (TABLE_LIST*) 0, &not_used);
   signal(signo, SIG_ACK);
 }
 
@@ -2267,12 +2268,13 @@ static void *signal_hand(void *arg __attribute__((unused)))
     case SIGHUP:
       if (!abort_loop)
       {
+        bool not_used;
 	mysql_print_status();		// Print some debug info
 	reload_acl_and_cache((THD*) 0,
 			     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
 			      REFRESH_GRANT |
 			      REFRESH_THREADS | REFRESH_HOSTS),
-			     (TABLE_LIST*) 0, NULL); // Flush logs
+			     (TABLE_LIST*) 0, &not_used); // Flush logs
       }
       break;
 #ifdef USE_ONE_SIGNAL_HAND
diff --git a/sql/sp_cache.cc b/sql/sp_cache.cc
index 68e8dbb3252..495f969eeac 100644
--- a/sql/sp_cache.cc
+++ b/sql/sp_cache.cc
@@ -22,7 +22,7 @@
 #include "sp_head.h"
 
 static pthread_mutex_t Cversion_lock;
-static ulong Cversion = 0;
+static ulong volatile Cversion= 0;
 
 
 /*
@@ -86,9 +86,11 @@ void sp_cache_init()
 
 /*
   Clear the cache *cp and set *cp to NULL.
+
   SYNOPSIS
     sp_cache_clear()
-      cp  Pointer to cache to clear
+    cp  Pointer to cache to clear
+
   NOTE
     This function doesn't invalidate other caches.
 */
@@ -96,6 +98,7 @@ void sp_cache_init()
 void sp_cache_clear(sp_cache **cp)
 {
   sp_cache *c= *cp;
+
   if (c)
   {
     delete c;
@@ -109,8 +112,8 @@ void sp_cache_clear(sp_cache **cp)
 
   SYNOPSIS
     sp_cache_insert()
-      cp  The cache to put routine into
-      sp  Routine to insert.
+     cp  The cache to put routine into
+     sp  Routine to insert.
       
   TODO: Perhaps it will be more straightforward if in case we returned an 
         error from this function when we couldn't allocate sp_cache. (right
@@ -120,22 +123,19 @@ void sp_cache_clear(sp_cache **cp)
 
 void sp_cache_insert(sp_cache **cp, sp_head *sp)
 {
-  sp_cache *c= *cp;
+  sp_cache *c;
+  ulong v;
 
-  if (!c && (c= new sp_cache()))
-  {
-    pthread_mutex_lock(&Cversion_lock); // LOCK
-    c->version= Cversion;
-    pthread_mutex_unlock(&Cversion_lock); // UNLOCK
-  }
-  if (c)
+  if (!(c= *cp))
   {
-    DBUG_PRINT("info",("sp_cache: inserting: %*s", sp->m_qname.length,
-                       sp->m_qname.str));
-    c->insert(sp);
-    if (*cp == NULL)
-      *cp= c;
+    if (!(c= new sp_cache()))
+      return;                                   // End of memory error
+    c->version= Cversion;      // No need to lock when reading long variable
   }
+  DBUG_PRINT("info",("sp_cache: inserting: %*s", sp->m_qname.length,
+                     sp->m_qname.str));
+  c->insert(sp);
+  *cp= c;                                       // Update *cp if it was NULL
 }
 
 
@@ -158,7 +158,7 @@ void sp_cache_insert(sp_cache **cp, sp_head *sp)
 sp_head *sp_cache_lookup(sp_cache **cp, sp_name *name)
 {
   sp_cache *c= *cp;
-  if (!c)
+  if (! c)
     return NULL;
   return c->lookup(name->m_qname.str, name->m_qname.length);
 }
@@ -178,9 +178,7 @@ sp_head *sp_cache_lookup(sp_cache **cp, sp_name *name)
 void sp_cache_invalidate()
 {
   DBUG_PRINT("info",("sp_cache: invalidating"));
-  pthread_mutex_lock(&Cversion_lock); // LOCK
-  Cversion++;
-  pthread_mutex_unlock(&Cversion_lock); // UNLOCK
+  thread_safe_increment(Cversion, &Cversion_lock);
 }
 
 
@@ -202,9 +200,7 @@ void sp_cache_flush_obsolete(sp_cache **cp)
   if (c)
   {
     ulong v;
-    pthread_mutex_lock(&Cversion_lock); // LOCK
-    v= Cversion;
-    pthread_mutex_unlock(&Cversion_lock); // UNLOCK
+    v= Cversion;                 // No need to lock when reading long variable
     if (c->version < v)
     {
       DBUG_PRINT("info",("sp_cache: deleting all functions"));
@@ -215,20 +211,20 @@ void sp_cache_flush_obsolete(sp_cache **cp)
   }
 }
 
+
 /*************************************************************************
   Internal functions 
  *************************************************************************/
 
-static byte *
-hash_get_key_for_sp_head(const byte *ptr, uint *plen,
+static byte *hash_get_key_for_sp_head(const byte *ptr, uint *plen,
 			       my_bool first)
 {
   sp_head *sp= (sp_head *)ptr;
-
   *plen= sp->m_qname.length;
   return (byte*) sp->m_qname.str;
 }
 
+
 static void
 hash_free_sp_head(void *p)
 {
@@ -236,16 +232,19 @@ hash_free_sp_head(void *p)
   delete sp;
 }
 
+
 sp_cache::sp_cache()
 {
   init();
 }
 
+
 sp_cache::~sp_cache()
 {
   hash_free(&m_hashtable);
 }
 
+
 void
 sp_cache::init()
 {
@@ -254,6 +253,7 @@ sp_cache::init()
   version= 0;
 }
 
+
 void
 sp_cache::cleanup()
 {
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index eb671b5bcd0..d0cd968f4fb 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -678,12 +678,14 @@ sp_head::execute(THD *thd)
       cleanup_items(i->free_list);
     i->state= Query_arena::EXECUTED;
 
-    // Check if an exception has occurred and a handler has been found
-    // Note: We havo to check even if ret==0, since warnings (and some
-    //       errors don't return a non-zero value.
-    //       We also have to check even if thd->killed != 0, since some
-    //       errors return with this even when a handler has been found
-    //       (e.g. "bad data").
+    /*
+      Check if an exception has occurred and a handler has been found
+      Note: We havo to check even if ret==0, since warnings (and some
+      errors don't return a non-zero value.
+      We also have to check even if thd->killed != 0, since some
+      errors return with this even when a handler has been found
+      (e.g. "bad data").
+    */
     if (ctx)
     {
       uint hf;
@@ -759,8 +761,10 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount, Item **resp)
 
   if (argcount != params)
   {
-    // Need to use my_printf_error here, or it will not terminate the
-    // invoking query properly.
+    /*
+      Need to use my_printf_error here, or it will not terminate the
+      invoking query properly.
+    */
     my_error(ER_SP_WRONG_NO_OF_ARGS, MYF(0),
              "FUNCTION", m_qname.str, params, argcount);
     DBUG_RETURN(-1);
@@ -784,9 +788,11 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount, Item **resp)
       DBUG_RETURN(-1);
     }
   }
-  // The rest of the frame are local variables which are all IN.
-  // Default all variables to null (those with default clauses will
-  // be set by an set instruction).
+  /*
+    The rest of the frame are local variables which are all IN.
+    Default all variables to null (those with default clauses will
+    be set by an set instruction).
+  */
   {
     Item_null *nit= NULL;	// Re-use this, and only create if needed
     for (; i < csize ; i++)
@@ -803,9 +809,11 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount, Item **resp)
 
   ret= execute(thd);
 
-  // Partially restore context now.
-  // We still need the call mem root and free list for processing
-  // of the result.
+  /*
+    Partially restore context now.
+    We still need the call mem root and free list for processing
+    of the result.
+  */
   thd->restore_backup_item_arena(&call_arena, &backup_arena);
 
   if (m_type == TYPE_ENUM_FUNCTION && ret == 0)
@@ -932,9 +940,11 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
       close_thread_tables(thd, 0, 0);
 
     DBUG_PRINT("info",(" %.*s: eval args done", m_name.length, m_name.str));
-    // The rest of the frame are local variables which are all IN.
-    // Default all variables to null (those with default clauses will
-    // be set by an set instruction).
+    /*
+      The rest of the frame are local variables which are all IN.
+      Default all variables to null (those with default clauses will
+      be set by an set instruction).
+    */
     for (; i < csize ; i++)
     {
       if (! nit)
@@ -956,8 +966,10 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
     List_iterator<Item> li(*args);
     Item *it;
 
-    // Copy back all OUT or INOUT values to the previous frame, or
-    // set global user variables
+    /*
+      Copy back all OUT or INOUT values to the previous frame, or
+      set global user variables
+    */
     for (uint i = 0 ; (it= li++) && i < params ; i++)
     {
       sp_pvar_t *pvar= m_pcont->find_pvar(i);
@@ -987,8 +999,10 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
 	    octx->set_item(offset, copy);
 	  if (orig && copy == orig)
 	  {
-	    // A reused item slot, where the constructor put it in the
-	    // free_list, so we have to restore the list.
+	    /*
+              A reused item slot, where the constructor put it in the
+              free_list, so we have to restore the list.
+            */
 	    thd->free_list= o_free_list;
 	    copy->next= o_item_next;
 	  }
@@ -1420,8 +1434,6 @@ sp_head::opt_mark(uint ip)
     ip= i->opt_mark(this);
 }
 
-// ------------------------------------------------------------------
-
 
 /*
   Prepare LEX and thread for execution of instruction, if requested open
@@ -1513,6 +1525,7 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
 
   thd->proc_info="closing tables";
   close_thread_tables(thd);
+  thd->proc_info= 0;
 
   if (m_lex->query_tables_own_last)
   {
@@ -1549,9 +1562,10 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
 }
 
 
-//
-// sp_instr
-//
+/*
+  sp_instr class functions
+*/
+
 int sp_instr::exec_core(THD *thd, uint *nextp)
 {
   DBUG_ASSERT(0);
@@ -1559,9 +1573,10 @@ int sp_instr::exec_core(THD *thd, uint *nextp)
 }
 
 
-//
-// sp_instr_stmt
-//
+/*
+  sp_instr_stmt class functions
+*/
+
 int
 sp_instr_stmt::execute(THD *thd, uint *nextp)
 {
@@ -1606,9 +1621,11 @@ sp_instr_stmt::exec_core(THD *thd, uint *nextp)
   return res;
 }
 
-//
-// sp_instr_set
-//
+
+/*
+  sp_instr_set class functions
+*/
+
 int
 sp_instr_set::execute(THD *thd, uint *nextp)
 {
@@ -1618,6 +1635,7 @@ sp_instr_set::execute(THD *thd, uint *nextp)
   DBUG_RETURN(m_lex_keeper.reset_lex_and_exec_core(thd, nextp, TRUE, this));
 }
 
+
 int
 sp_instr_set::exec_core(THD *thd, uint *nextp)
 {
@@ -1638,9 +1656,10 @@ sp_instr_set::print(String *str)
 }
 
 
-//
-// sp_instr_set_trigger_field
-//
+/*
+  sp_instr_set_trigger_field class functions
+*/
+
 int
 sp_instr_set_trigger_field::execute(THD *thd, uint *nextp)
 {
@@ -1671,9 +1690,11 @@ sp_instr_set_trigger_field::print(String *str)
   value->print(str);
 }
 
-//
-// sp_instr_jump
-//
+
+/*
+ sp_instr_jump class functions
+*/
+
 int
 sp_instr_jump::execute(THD *thd, uint *nextp)
 {
@@ -1732,9 +1753,10 @@ sp_instr_jump::opt_move(uint dst, List<sp_instr> *bp)
   m_ip= dst;
 }
 
-//
-// sp_instr_jump_if
-//
+
+/*
+  sp_instr_jump_if class functions
+*/
 
 int
 sp_instr_jump_if::execute(THD *thd, uint *nextp)
@@ -1790,9 +1812,11 @@ sp_instr_jump_if::opt_mark(sp_head *sp)
   return m_ip+1;
 }
 
-//
-// sp_instr_jump_if_not
-//
+
+/*
+  sp_instr_jump_if_not class functions
+*/
+
 int
 sp_instr_jump_if_not::execute(THD *thd, uint *nextp)
 {
@@ -1823,6 +1847,7 @@ sp_instr_jump_if_not::exec_core(THD *thd, uint *nextp)
   return res;
 }
 
+
 void
 sp_instr_jump_if_not::print(String *str)
 {
@@ -1833,6 +1858,7 @@ sp_instr_jump_if_not::print(String *str)
   m_expr->print(str);
 }
 
+
 uint
 sp_instr_jump_if_not::opt_mark(sp_head *sp)
 {
@@ -1848,9 +1874,10 @@ sp_instr_jump_if_not::opt_mark(sp_head *sp)
   return m_ip+1;
 }
 
-//
-// sp_instr_freturn
-//
+
+/*
+  sp_instr_freturn class functions
+*/
 
 int
 sp_instr_freturn::execute(THD *thd, uint *nextp)
@@ -1889,9 +1916,10 @@ sp_instr_freturn::print(String *str)
   m_value->print(str);
 }
 
-//
-// sp_instr_hpush_jump
-//
+/*
+  sp_instr_hpush_jump class functions
+*/
+
 int
 sp_instr_hpush_jump::execute(THD *thd, uint *nextp)
 {
@@ -1935,9 +1963,11 @@ sp_instr_hpush_jump::opt_mark(sp_head *sp)
   return m_ip+1;
 }
 
-//
-// sp_instr_hpop
-//
+
+/*
+  sp_instr_hpop class functions
+*/
+
 int
 sp_instr_hpop::execute(THD *thd, uint *nextp)
 {
@@ -1962,9 +1992,10 @@ sp_instr_hpop::backpatch(uint dest, sp_pcontext *dst_ctx)
 }
 
 
-//
-// sp_instr_hreturn
-//
+/*
+  sp_instr_hreturn class functions
+*/
+
 int
 sp_instr_hreturn::execute(THD *thd, uint *nextp)
 {
@@ -1980,6 +2011,7 @@ sp_instr_hreturn::execute(THD *thd, uint *nextp)
   DBUG_RETURN(0);
 }
 
+
 void
 sp_instr_hreturn::print(String *str)
 {
@@ -1990,6 +2022,7 @@ sp_instr_hreturn::print(String *str)
     str->qs_append(m_dest);
 }
 
+
 uint
 sp_instr_hreturn::opt_mark(sp_head *sp)
 {
@@ -2003,9 +2036,10 @@ sp_instr_hreturn::opt_mark(sp_head *sp)
 }
 
 
-//
-// sp_instr_cpush
-//
+/*
+  sp_instr_cpush class functions
+*/
+
 int
 sp_instr_cpush::execute(THD *thd, uint *nextp)
 {
@@ -2015,15 +2049,18 @@ sp_instr_cpush::execute(THD *thd, uint *nextp)
   DBUG_RETURN(0);
 }
 
+
 void
 sp_instr_cpush::print(String *str)
 {
   str->append("cpush");
 }
 
-//
-// sp_instr_cpop
-//
+
+/*
+  sp_instr_cpop class functions
+*/
+
 int
 sp_instr_cpop::execute(THD *thd, uint *nextp)
 {
@@ -2033,6 +2070,7 @@ sp_instr_cpop::execute(THD *thd, uint *nextp)
   DBUG_RETURN(0);
 }
 
+
 void
 sp_instr_cpop::print(String *str)
 {
@@ -2047,9 +2085,11 @@ sp_instr_cpop::backpatch(uint dest, sp_pcontext *dst_ctx)
   m_count= m_ctx->diff_cursors(dst_ctx);
 }
 
-//
-// sp_instr_copen
-//
+
+/*
+  sp_instr_copen class functions
+*/
+
 int
 sp_instr_copen::execute(THD *thd, uint *nextp)
 {
@@ -2117,9 +2157,11 @@ sp_instr_copen::print(String *str)
   str->qs_append(m_cursor);
 }
 
-//
-// sp_instr_cclose
-//
+
+/*
+  sp_instr_cclose class functions
+*/
+
 int
 sp_instr_cclose::execute(THD *thd, uint *nextp)
 {
@@ -2135,6 +2177,7 @@ sp_instr_cclose::execute(THD *thd, uint *nextp)
   DBUG_RETURN(res);
 }
 
+
 void
 sp_instr_cclose::print(String *str)
 {
@@ -2143,9 +2186,11 @@ sp_instr_cclose::print(String *str)
   str->qs_append(m_cursor);
 }
 
-//
-// sp_instr_cfetch
-//
+
+/*
+  sp_instr_cfetch class functions
+*/
+
 int
 sp_instr_cfetch::execute(THD *thd, uint *nextp)
 {
@@ -2161,6 +2206,7 @@ sp_instr_cfetch::execute(THD *thd, uint *nextp)
   DBUG_RETURN(res);
 }
 
+
 void
 sp_instr_cfetch::print(String *str)
 {
@@ -2178,9 +2224,11 @@ sp_instr_cfetch::print(String *str)
   }
 }
 
-//
-// sp_instr_error
-//
+
+/*
+  sp_instr_error class functions
+*/
+
 int
 sp_instr_error::execute(THD *thd, uint *nextp)
 {
@@ -2191,6 +2239,7 @@ sp_instr_error::execute(THD *thd, uint *nextp)
   DBUG_RETURN(-1);
 }
 
+
 void
 sp_instr_error::print(String *str)
 {
@@ -2199,12 +2248,12 @@ sp_instr_error::print(String *str)
   str->qs_append(m_errcode);
 }
 
-/* ------------------------------------------------------------------ */
 
+/* ------------------------------------------------------------------ */
 
-//
-// Security context swapping
-//
+/*
+  Security context swapping
+*/
 
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
 void
@@ -2453,11 +2502,12 @@ sp_head::add_used_tables_to_table_list(THD *thd,
   DBUG_RETURN(result);
 }
 
+
 /*
- * Simple function for adding an explicetly named (systems) table to
- * the global table list, e.g. "mysql", "proc".
- *
- */
+  Simple function for adding an explicetly named (systems) table to
+  the global table list, e.g. "mysql", "proc".
+*/
+
 TABLE_LIST *
 sp_add_to_query_tables(THD *thd, LEX *lex,
 		       const char *db, const char *name,
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index b7b1fb7ff13..954bd89f968 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1921,8 +1921,7 @@ int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
           has added its base tables after itself, adjust the boundary pointer
           accordingly.
         */
-        if (query_tables_last_own &&
-            query_tables_last_own == &(tables->next_global) &&
+        if (query_tables_last_own == &(tables->next_global) &&
             tables->view->query_tables)
           query_tables_last_own= tables->view->query_tables_last;
         
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 5d3361d6c51..0b8205dfdb3 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1246,7 +1246,8 @@ public:
     update auto-updatable fields (like auto_increment and timestamp).
   */
   query_id_t query_id, warn_id;
-  ulong	     options, thread_id, col_access;
+  ulonglong  options;
+  ulong      thread_id, col_access;
 
   /* Statement id is thread-wide. This counter is used to generate ids */
   ulong      statement_id_counter;
@@ -1498,7 +1499,7 @@ public:
 
 
 #define tmp_disable_binlog(A)       \
-  {ulong tmp_disable_binlog__save_options= (A)->options; \
+  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
   (A)->options&= ~OPTION_BIN_LOG
 
 #define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index b6183bf5acb..6c35653291d 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -30,7 +30,7 @@
 #include "sql_trigger.h"
 
 bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
-                  SQL_LIST *order, ha_rows limit, ulong options)
+                  SQL_LIST *order, ha_rows limit, ulonglong options)
 {
   int		error;
   TABLE		*table;
@@ -807,7 +807,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
       ha_enable_transaction(thd, FALSE);
       mysql_init_select(thd->lex);
       error= mysql_delete(thd, table_list, (COND*) 0, (SQL_LIST*) 0,
-			  HA_POS_ERROR, 0);
+			  HA_POS_ERROR, LL(0));
       ha_enable_transaction(thd, TRUE);
       thd->options= save_options;
       DBUG_RETURN(error);
diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc
index afcf7dbd93f..fc9d15e94c4 100644
--- a/sql/sql_derived.cc
+++ b/sql/sql_derived.cc
@@ -142,8 +142,7 @@ int mysql_derived_prepare(THD *thd, LEX *lex, TABLE_LIST *orig_table_list)
 				  unit->types, (ORDER*) 0,
 				  FALSE, 1,
 				  (first_select->options | thd->options |
-				   TMP_TABLE_ALL_COLUMNS) &
-                                   ~TMP_TABLE_FORCE_MYISAM,
+				   TMP_TABLE_ALL_COLUMNS),
 				  HA_POS_ERROR,
 				  orig_table_list->alias)))
     {
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index e8c65ba5100..977885e64f2 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -305,7 +305,7 @@ protected:
     *link_next, **link_prev;          /* list of whole SELECT_LEX */
 public:
 
-  ulong options;
+  ulonglong options;
   /*
     result of this query can't be cached, bit field, can be :
       UNCACHEABLE_DEPENDENT
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index fefe670432c..bbd1f81b7f3 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1863,17 +1863,18 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
     }
 #endif
   case COM_REFRESH:
-    {
-      statistic_increment(thd->status_var.com_stat[SQLCOM_FLUSH],
-			  &LOCK_status);
-      ulong options= (ulong) (uchar) packet[0];
-      if (check_global_access(thd,RELOAD_ACL))
-	break;
-      mysql_log.write(thd,command,NullS);
-      if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, NULL))
-        send_ok(thd);
+  {
+    bool not_used;
+    statistic_increment(thd->status_var.com_stat[SQLCOM_FLUSH],
+                        &LOCK_status);
+    ulong options= (ulong) (uchar) packet[0];
+    if (check_global_access(thd,RELOAD_ACL))
       break;
-    }
+    mysql_log.write(thd,command,NullS);
+    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
+      send_ok(thd);
+    break;
+  }
 #ifndef EMBEDDED_LIBRARY
   case COM_SHUTDOWN:
   {
@@ -2942,8 +2943,8 @@ end_with_restore_list:
   */
   if (thd->locked_tables || thd->active_transaction())
   {
-    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION),
-               MYF(0));
+    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
+               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
     goto error;
   }
   {
@@ -3822,13 +3823,13 @@ end_with_restore_list:
     lex->no_write_to_binlog= 1;
   case SQLCOM_FLUSH:
   {
+    bool write_to_binlog;
     if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
       goto error;
     /*
       reload_acl_and_cache() will tell us if we are allowed to write to the
       binlog or not.
     */
-    bool write_to_binlog;
     if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
     {
       /*
@@ -6379,13 +6380,13 @@ void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
     tables              Tables to flush (if any)
     write_to_binlog     Depending on 'options', it may be very bad to write the
                         query to the binlog (e.g. FLUSH SLAVE); this is a
-                        pointer where, if it is not NULL, reload_acl_and_cache()
-                        will put 0 if it thinks we really should not write to
-                        the binlog. Otherwise it will put 1.
+                        pointer where reload_acl_and_cache() will put 0 if
+                        it thinks we really should not write to the binlog.
+                        Otherwise it will put 1.
 
   RETURN
     0	 ok
-    !=0  error
+    !=0  error.  thd->killed or thd->net.report_error is set
 */
 
 bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
@@ -6480,10 +6481,10 @@ bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
       */
       tmp_write_to_binlog= 0;
       if (lock_global_read_lock(thd))
-	return 1;
+	return 1;                               // Killed
       result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                  tables);
-      if (make_global_read_lock_block_commit(thd))
+      if (make_global_read_lock_block_commit(thd)) // Killed
       {
         /* Don't leave things in a half-locked state */
         unlock_global_read_lock(thd);
@@ -6505,7 +6506,10 @@ bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
   {
     tmp_write_to_binlog= 0;
     if (reset_master(thd))
+    {
       result=1;
+      thd->fatal_error();                       // Ensure client get error
+    }
   }
 #endif
 #ifdef OPENSSL
@@ -6527,8 +6531,7 @@ bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
 #endif
  if (options & REFRESH_USER_RESOURCES)
    reset_mqh((LEX_USER *) NULL);
- if (write_to_binlog)
-   *write_to_binlog= tmp_write_to_binlog;
+ *write_to_binlog= tmp_write_to_binlog;
  return result;
 }
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 630406dba07..bcc2b59e89d 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1016,7 +1016,7 @@ JOIN::optimize()
 			    group_list : (ORDER*) 0),
 			   group_list ? 0 : select_distinct,
 			   group_list && simple_group,
-			   select_options & ~TMP_TABLE_FORCE_MYISAM,
+			   select_options,
 			   (order == 0 || skip_sort_order) ? select_limit :
 			   HA_POS_ERROR,
 			   (char *) "")))
@@ -1287,7 +1287,15 @@ JOIN::exec()
   if (need_tmp)
   {
     if (tmp_join)
+    {
+      /*
+        We are in a non cacheable sub query. Get the saved join structure
+        after optimization.
+        (curr_join may have been modified during last exection and we need
+        to reset it)
+      */
       curr_join= tmp_join;
+    }
     curr_tmp_table= exec_tmp_table1;
 
     /* Copy data to the temporary table */
@@ -1397,8 +1405,7 @@ JOIN::exec()
 						(ORDER*) 0,
 						curr_join->select_distinct && 
 						!curr_join->group_list,
-						1, curr_join->select_options
-                                                & ~TMP_TABLE_FORCE_MYISAM,
+						1, curr_join->select_options,
 						HA_POS_ERROR,
 						(char *) "")))
 	  DBUG_VOID_RETURN;
@@ -8128,7 +8135,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
 TABLE *
 create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
 		 ORDER *group, bool distinct, bool save_sum_fields,
-		 ulong select_options, ha_rows rows_limit,
+		 ulonglong select_options, ha_rows rows_limit,
 		 char *table_alias)
 {
   TABLE *table;
@@ -8382,7 +8389,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   /* If result table is small; use a heap */
   if (blob_count || using_unique_constraint ||
       (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
-      OPTION_BIG_TABLES ||(select_options & TMP_TABLE_FORCE_MYISAM))
+      OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))
   {
     table->file=get_new_handler(table,table->s->db_type= DB_TYPE_MYISAM);
     if (group &&
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 3b9a3093682..78fa88801be 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -202,7 +202,7 @@ class JOIN :public Sql_alloc
   Item	    *having;
   Item      *tmp_having; // To store having when processed temporary table
   Item      *having_history; // Store having for explain
-  uint	    select_options;
+  ulonglong  select_options;
   select_result *result;
   TMP_TABLE_PARAM tmp_table_param;
   MYSQL_LOCK *lock;
@@ -258,14 +258,14 @@ class JOIN :public Sql_alloc
   bool union_part; // this subselect is part of union 
   bool optimized; // flag to avoid double optimization in EXPLAIN
 
-  JOIN(THD *thd_arg, List<Item> &fields_arg, ulong select_options_arg,
+  JOIN(THD *thd_arg, List<Item> &fields_arg, ulonglong select_options_arg,
        select_result *result_arg)
     :fields_list(fields_arg)
   {
     init(thd_arg, fields_arg, select_options_arg, result_arg);
   }
   
-  void init(THD *thd_arg, List<Item> &fields_arg, ulong select_options_arg,
+  void init(THD *thd_arg, List<Item> &fields_arg, ulonglong select_options_arg,
        select_result *result_arg)
   {
     join_tab= join_tab_save= 0;
@@ -437,7 +437,7 @@ void TEST_join(JOIN *join);
 bool store_val_in_field(Field *field,Item *val);
 TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
 			ORDER *group, bool distinct, bool save_sum_fields,
-			ulong select_options, ha_rows rows_limit,
+			ulonglong select_options, ha_rows rows_limit,
 			char* alias);
 TABLE *create_virtual_tmp_table(THD *thd, List<create_field> &field_list);
 void free_tmp_table(THD *thd, TABLE *entry);
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 1c0519475b4..c558d5de7bf 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -3332,8 +3332,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
   if (!(table= create_tmp_table(thd, tmp_table_param,
                                 field_list, (ORDER*) 0, 0, 0, 
                                 (select_lex->options | thd->options |
-                                 TMP_TABLE_ALL_COLUMNS) &
-                                ~TMP_TABLE_FORCE_MYISAM,
+                                 TMP_TABLE_ALL_COLUMNS),
                                 HA_POS_ERROR, table_list->alias)))
     DBUG_RETURN(0);
   table_list->schema_table_param= tmp_table_param;
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index c2888bee4c6..72c96e81682 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -289,7 +289,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
     List_iterator_fast<Item> tp(types);
     Query_arena *arena= thd->current_arena;
     Item *type;
-    ulong create_options;
+    ulonglong create_options;
 
     while ((type= tp++))
     {
@@ -302,7 +302,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
     }
     
     create_options= (first_select_in_union()->options | thd_arg->options |
-                     TMP_TABLE_ALL_COLUMNS) & ~TMP_TABLE_FORCE_MYISAM;
+                     TMP_TABLE_ALL_COLUMNS);
     /*
       Force the temporary table to be a MyISAM table if we're going to use
       fullext functions (MATCH ... AGAINST .. IN BOOLEAN MODE) when reading
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index aa39140f9b1..1a9ef2fff62 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -811,7 +811,7 @@ bool mysql_multi_update(THD *thd,
                         List<Item> *fields,
                         List<Item> *values,
                         COND *conds,
-                        ulong options,
+                        ulonglong options,
                         enum enum_duplicates handle_duplicates, bool ignore,
                         SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex)
 {
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 849987a267c..1d9413d2cf7 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -7752,7 +7752,8 @@ sys_option_value:
             /* We are in trigger and assigning value to field of new row */
             Item *it;
             Item_trigger_field *trg_fld;
-            sp_instr_set_trigger_field *i;
+            sp_instr_set_trigger_field *sp_fld;
+	    LINT_INIT(sp_fld);
             if ($1)
             {
               yyerror(ER(ER_SYNTAX_ERROR));
@@ -7770,10 +7771,11 @@ sys_option_value:
                                                   context,
                                                   Item_trigger_field::NEW_ROW,
                                                   $2.base_name.str)) ||
-                !(i= new sp_instr_set_trigger_field(lex->sphead->
-                                                    instructions(),
-                                                    lex->spcont, trg_fld,
-                                                    it, lex)))
+                !(sp_fld= new sp_instr_set_trigger_field(lex->sphead->
+                          	                         instructions(),
+                                	                 lex->spcont,
+							 trg_fld,
+                                        	         it, lex)))
               YYABORT;
 
             /*
@@ -7783,7 +7785,7 @@ sys_option_value:
             lex->trg_table_fields.link_in_list((byte *)trg_fld,
                                     (byte **)&trg_fld->next_trg_field);
 
-            lex->sphead->add_instr(i);
+            lex->sphead->add_instr(sp_fld);
           }
           else if ($2.var)
           { /* System variable */
@@ -7797,7 +7799,7 @@ sys_option_value:
             /* An SP local variable */
             sp_pcontext *ctx= lex->spcont;
             sp_pvar_t *spv;
-            sp_instr_set *i;
+            sp_instr_set *sp_set;
             Item *it;
             if ($1)
             {
@@ -7813,9 +7815,9 @@ sys_option_value:
               it= spv->dflt;
             else
               it= new Item_null();
-            i= new sp_instr_set(lex->sphead->instructions(), ctx,
-                                spv->offset, it, spv->type, lex, TRUE);
-            lex->sphead->add_instr(i);
+            sp_set= new sp_instr_set(lex->sphead->instructions(), ctx,
+                                     spv->offset, it, spv->type, lex, TRUE);
+            lex->sphead->add_instr(sp_set);
             spv->isset= TRUE;
           }
         }