Merge mysql.com:/usr/local/mysql/tmp_merge

into  mysql.com:/usr/local/mysql/merge-5.1


mysql-test/lib/mtr_process.pl:
  Auto merged
mysql-test/mysql-test-run.pl:
  Auto merged
mysql-test/r/sp-error.result:
  Auto merged
mysql-test/r/sp.result:
  Auto merged
mysql-test/r/trigger-grant.result:
  Auto merged
mysql-test/r/trigger.result:
  Auto merged
mysql-test/t/sp.test:
  Auto merged
mysql-test/t/trigger-grant.test:
  Auto merged
mysql-test/t/trigger.test:
  Auto merged
server-tools/instance-manager/options.h:
  Auto merged
sql/field_conv.cc:
  Auto merged
sql/item.cc:
  Auto merged
sql/item.h:
  Auto merged
sql/item_func.h:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/share/errmsg.txt:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
server-tools/instance-manager/options.cc:
  Manual merge
sql/item_func.cc:
  Manual merge
sql/mysql_priv.h:
  Manual merge
sql/sp_head.cc:
  Manual merge
sql/sql_table.cc:
  Manual merge

13 files changed, 438 insertions, 251 deletions

diff --git a/sql/field_conv.cc b/sql/field_conv.cc
index f718a3d778c..3eab782d167 100644
--- a/sql/field_conv.cc
+++ b/sql/field_conv.cc
@@ -641,7 +641,8 @@ void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*)
 
 void field_conv(Field *to,Field *from)
 {
-  if (to->real_type() == from->real_type())
+  if (to->real_type() == from->real_type() &&
+      !(to->type() == FIELD_TYPE_BLOB && to->table->copy_blobs))
   {
     if (to->pack_length() == from->pack_length() &&
         !(to->flags & UNSIGNED_FLAG && !(from->flags & UNSIGNED_FLAG)) &&
diff --git a/sql/item.cc b/sql/item.cc
index 72aaba4cfaf..32890ec3596 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -961,6 +961,12 @@ void Item_splocal::print(String *str)
 }
 
 
+bool Item_splocal::set_value(THD *thd, sp_rcontext *ctx, Item **it)
+{
+  return ctx->set_variable(thd, get_var_idx(), it);
+}
+
+
 /*****************************************************************************
   Item_case_expr methods
 *****************************************************************************/
@@ -5407,6 +5413,25 @@ bool Item_trigger_field::eq(const Item *item, bool binary_cmp) const
 }
 
 
+void Item_trigger_field::set_required_privilege(const bool rw)
+{
+  /*
+    Require SELECT and UPDATE privilege if this field will be read and
+    set, and only UPDATE privilege for setting the field.
+  */
+  want_privilege= (rw ? SELECT_ACL | UPDATE_ACL : UPDATE_ACL);
+}
+
+
+bool Item_trigger_field::set_value(THD *thd, sp_rcontext */*ctx*/, Item **it)
+{
+  Item *item= sp_prepare_func_item(thd, it);
+
+  return (!item || (!fixed && fix_fields(thd, 0)) ||
+          (item->save_in_field(field, 0) < 0));
+}
+
+
 bool Item_trigger_field::fix_fields(THD *thd, Item **items)
 {
   /*
@@ -5429,8 +5454,7 @@ bool Item_trigger_field::fix_fields(THD *thd, Item **items)
 
     if (table_grants)
     {
-      table_grants->want_privilege=
-        access_type == AT_READ ? SELECT_ACL : UPDATE_ACL;
+      table_grants->want_privilege= want_privilege;
 
       if (check_grant_column(thd, table_grants, triggers->table->s->db.str,
                              triggers->table->s->table_name.str, field_name,
@@ -5462,6 +5486,7 @@ void Item_trigger_field::print(String *str)
 
 void Item_trigger_field::cleanup()
 {
+  want_privilege= original_privilege;
   /*
     Since special nature of Item_trigger_field we should not do most of
     things from Item_field::cleanup() or Item_ident::cleanup() here.
diff --git a/sql/item.h b/sql/item.h
index f73017563dd..8d740c51cad 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -401,6 +401,42 @@ typedef enum monotonicity_info
 
 /*************************************************************************/
 
+class sp_rcontext;
+
+
+class Settable_routine_parameter
+{
+public:
+  /*
+    Set required privileges for accessing the parameter.
+
+    SYNOPSIS
+      set_required_privilege()
+        rw        if 'rw' is true then we are going to read and set the
+                  parameter, so SELECT and UPDATE privileges might be
+                  required, otherwise we only reading it and SELECT
+                  privilege might be required.
+  */
+  virtual void set_required_privilege(bool rw) {};
+
+  /*
+    Set parameter value.
+
+    SYNOPSIS
+      set_value()
+        thd       thread handle
+        ctx       context to which parameter belongs (if it is local
+                  variable).
+        it        item which represents new value
+
+    RETURN
+      FALSE if parameter value has been set,
+      TRUE if error has occured.
+  */
+  virtual bool set_value(THD *thd, sp_rcontext *ctx, Item **it)= 0;
+};
+
+
 typedef bool (Item::*Item_processor)(byte *arg);
 typedef Item* (Item::*Item_transformer) (byte *arg);
 typedef void (*Cond_traverser) (const Item *item, void *arg);
@@ -784,6 +820,15 @@ public:
   }
 
   virtual bool is_splocal() { return 0; } /* Needed for error checking */
+
+  /*
+    Return Settable_routine_parameter interface of the Item.  Return 0
+    if this Item is not Settable_routine_parameter.
+  */
+  virtual Settable_routine_parameter *get_settable_routine_parameter()
+  {
+    return 0;
+  }
 };
 
 
@@ -882,7 +927,8 @@ inline bool Item_sp_variable::send(Protocol *protocol, String *str)
   runtime.
 *****************************************************************************/
 
-class Item_splocal :public Item_sp_variable
+class Item_splocal :public Item_sp_variable,
+                    private Settable_routine_parameter
 {
   uint m_var_idx;
 
@@ -920,6 +966,15 @@ public:
 
   inline enum Type type() const;
   inline Item_result result_type() const;
+
+private:
+  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
+
+public:
+  Settable_routine_parameter *get_settable_routine_parameter()
+  {
+    return this;
+  }
 };
 
 /*****************************************************************************
@@ -2146,14 +2201,13 @@ class Table_triggers_list;
         two Field instances representing either OLD or NEW version of this
         field.
 */
-class Item_trigger_field : public Item_field
+class Item_trigger_field : public Item_field,
+                           private Settable_routine_parameter
 {
 public:
   /* Is this item represents row from NEW or OLD row ? */
   enum row_version_type {OLD_ROW, NEW_ROW};
   row_version_type row_version;
-  /* Is this item used for reading or updating the value? */
-  enum access_types { AT_READ = 0x1, AT_UPDATE = 0x2 };
   /* Next in list of all Item_trigger_field's in trigger */
   Item_trigger_field *next_trg_field;
   /* Index of the field in the TABLE::field array */
@@ -2164,11 +2218,11 @@ public:
   Item_trigger_field(Name_resolution_context *context_arg,
                      row_version_type row_ver_arg,
                      const char *field_name_arg,
-                     access_types access_type_arg)
+                     ulong priv, const bool ro)
     :Item_field(context_arg,
                (const char *)NULL, (const char *)NULL, field_name_arg),
-     row_version(row_ver_arg), field_idx((uint)-1),
-     access_type(access_type_arg), table_grants(NULL)
+     row_version(row_ver_arg), field_idx((uint)-1), original_privilege(priv),
+     want_privilege(priv), table_grants(NULL), read_only (ro)
   {}
   void setup_field(THD *thd, TABLE *table, GRANT_INFO *table_grant_info);
   enum Type type() const { return TRIGGER_FIELD_ITEM; }
@@ -2179,8 +2233,39 @@ public:
   void cleanup();
 
 private:
-  access_types access_type;
+  void set_required_privilege(const bool rw);
+  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
+
+public:
+  Settable_routine_parameter *get_settable_routine_parameter()
+  {
+    return (read_only ? 0 : this);
+  }
+
+  bool set_value(THD *thd, Item **it)
+  {
+    return set_value(thd, NULL, it);
+  }
+
+private:
+  /*
+    'want_privilege' holds privileges required to perform operation on
+    this trigger field (SELECT_ACL if we are going to read it and
+    UPDATE_ACL if we are going to update it).  It is initialized at
+    parse time but can be updated later if this trigger field is used
+    as OUT or INOUT parameter of stored routine (in this case
+    set_required_privilege() is called to appropriately update
+    want_privilege and cleanup() is responsible for restoring of
+    original want_privilege once parameter's value is updated).
+  */
+  ulong original_privilege;
+  ulong want_privilege;
   GRANT_INFO *table_grants;
+  /*
+    Trigger field is read-only unless it belongs to the NEW row in a
+    BEFORE INSERT of BEFORE UPDATE trigger.
+  */
+  bool read_only;
 };
 
 
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 82e07ebdefe..fc4cb4ba988 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -4122,6 +4122,18 @@ bool Item_func_get_user_var::eq(const Item *item, bool binary_cmp) const
 }
 
 
+bool Item_func_get_user_var::set_value(THD *thd,
+                                       sp_rcontext */*ctx*/, Item **it)
+{
+  Item_func_set_user_var *suv= new Item_func_set_user_var(get_name(), *it);
+  /*
+    Item_func_set_user_var is not fixed after construction, call
+    fix_fields().
+  */
+  return (!suv || suv->fix_fields(thd, it) || suv->check() || suv->update());
+}
+
+
 bool Item_user_var_as_out_param::fix_fields(THD *thd, Item **ref)
 {
   DBUG_ASSERT(fixed == 0);
@@ -4754,6 +4766,7 @@ Item_func_sp::sp_result_field(void) const
     dummy_table->alias= empty_name;
     dummy_table->maybe_null= maybe_null;
     dummy_table->in_use= current_thd;
+    dummy_table->copy_blobs= TRUE;
     dummy_table->s->table_cache_key.str = empty_name;
     dummy_table->s->table_name.str= empty_name;
     dummy_table->s->db.str= empty_name;
diff --git a/sql/item_func.h b/sql/item_func.h
index a91d93be8c6..1d8a1bd5e22 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -1179,7 +1179,8 @@ public:
 };
 
 
-class Item_func_get_user_var :public Item_func
+class Item_func_get_user_var :public Item_func,
+                              private Settable_routine_parameter
 {
   user_var_entry *var_entry;
 
@@ -1206,6 +1207,15 @@ public:
   table_map used_tables() const
   { return const_item() ? 0 : RAND_TABLE_BIT; }
   bool eq(const Item *item, bool binary_cmp) const;
+
+private:
+  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
+
+public:
+  Settable_routine_parameter *get_settable_routine_parameter()
+  {
+    return this;
+  }
 };
 
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 127aa6c5acd..627ffae53fc 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -861,13 +861,6 @@ bool mysql_create_table(THD *thd,const char *db, const char *table_name,
                         List<create_field> &fields, List<Key> &keys,
                         bool tmp_table, uint select_field_count);
 
-TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
-			       TABLE_LIST *create_table,
-			       List<create_field> *extra_fields,
-			       List<Key> *keys,
-			       List<Item> *items,
-                               MYSQL_LOCK **lock,
-                               TABLEOP_HOOKS *hooks);
 bool mysql_alter_table(THD *thd, char *new_db, char *new_name,
                        HA_CREATE_INFO *create_info,
                        TABLE_LIST *table_list,
@@ -1649,10 +1642,11 @@ extern struct st_VioSSLFd * ssl_acceptor_fd;
 
 MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **table, uint count,
                               uint flags, bool *need_reopen);
-/* mysql_lock_tables() flags bits */
+/* mysql_lock_tables() and open_table() flags bits */
 #define MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK      0x0001
 #define MYSQL_LOCK_IGNORE_FLUSH                 0x0002
 #define MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN        0x0004
+#define MYSQL_OPEN_IGNORE_LOCKED_TABLES         0x0008
 
 void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock);
 void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock);
diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt
index a2bc77714bb..1d1cc5b5056 100644
--- a/sql/share/errmsg.txt
+++ b/sql/share/errmsg.txt
@@ -5472,7 +5472,7 @@ ER_SP_DUP_HANDLER 42000
 	eng "Duplicate handler declared in the same block"
 	ger "Doppelter Handler im selben Block deklariert"
 ER_SP_NOT_VAR_ARG 42000
-	eng "OUT or INOUT argument %d for routine %s is not a variable"
+	eng "OUT or INOUT argument %d for routine %s is not a variable or NEW pseudo-variable in BEFORE trigger"
 	ger "OUT- oder INOUT-Argument %d für Routine %s ist keine Variable"
 ER_SP_NO_RETSET 0A000
 	eng "Not allowed to return a result set from a %s"
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 1a9f4caf974..de56e261bd3 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -953,6 +953,7 @@ sp_head::execute(THD *thd)
   bool err_status= FALSE;
   uint ip= 0;
   ulong save_sql_mode;
+  bool save_abort_on_warning;
   Query_arena *old_arena;
   /* per-instruction arena */
   MEM_ROOT execute_mem_root;
@@ -1013,6 +1014,10 @@ sp_head::execute(THD *thd)
   thd->derived_tables= 0;
   save_sql_mode= thd->variables.sql_mode;
   thd->variables.sql_mode= m_sql_mode;
+  save_abort_on_warning= thd->abort_on_warning;
+  thd->abort_on_warning=
+    (m_sql_mode & (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES));
+
   /*
     It is also more efficient to save/restore current thd->lex once when
     do it in each instruction
@@ -1145,6 +1150,7 @@ sp_head::execute(THD *thd)
   DBUG_ASSERT(!thd->derived_tables);
   thd->derived_tables= old_derived_tables;
   thd->variables.sql_mode= save_sql_mode;
+  thd->abort_on_warning= save_abort_on_warning;
 
   thd->stmt_arena= old_arena;
   state= EXECUTED;
@@ -1221,18 +1227,22 @@ bool
 sp_head::execute_function(THD *thd, Item **argp, uint argcount,
                           Field *return_value_fld)
 {
-  Item_cache **param_values;
   ulonglong binlog_save_options;
   bool need_binlog_call;
-  uint params;
+  uint arg_no;
   sp_rcontext *octx = thd->spcont;
   sp_rcontext *nctx = NULL;
+  char buf[STRING_BUFFER_USUAL_SIZE];
+  String binlog_buf(buf, sizeof(buf), &my_charset_bin);
   bool err_status= FALSE;
+  MEM_ROOT call_mem_root;
+  Query_arena call_arena(&call_mem_root, Query_arena::INITIALIZED_FOR_SP);
+  Query_arena backup_arena;
+
   DBUG_ENTER("sp_head::execute_function");
   DBUG_PRINT("info", ("function %s", m_name.str));
 
   LINT_INIT(binlog_save_options);
-  params= m_pcont->context_var_count();
 
   /*
     Check that the function is called with all specified arguments.
@@ -1240,74 +1250,97 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     If it is not, use my_error() to report an error, or it will not terminate
     the invoking query properly.
   */
-
-  if (argcount != params)
+  if (argcount != m_pcont->context_var_count())
   {
     /*
       Need to use my_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);
+             "FUNCTION", m_qname.str, m_pcont->context_var_count(), argcount);
     DBUG_RETURN(TRUE);
   }
-
-  /* Allocate param_values to be used for dumping the call into binlog. */
-
-  if (!(param_values= (Item_cache**)thd->alloc(sizeof(Item_cache*)*argcount)))
-    DBUG_RETURN(TRUE);
-
-  // QQ Should have some error checking here? (types, etc...)
+  /*
+    Prepare arena and memroot for objects which lifetime is whole
+    duration of function call (sp_rcontext, it's tables and items,
+    sp_cursor and Item_cache holders for case expressions).
+    We can't use caller's arena/memroot for those objects because
+    in this case some fixed amount of memory will be consumed for
+    each function/trigger invocation and so statements which involve
+    lot of them will hog memory.
+    TODO: we should create sp_rcontext once per command and reuse
+    it on subsequent executions of a function/trigger.
+  */
+  init_sql_alloc(&call_mem_root, MEM_ROOT_BLOCK_SIZE, 0);
+  thd->set_n_backup_active_arena(&call_arena, &backup_arena);
 
   if (!(nctx= new sp_rcontext(m_pcont, return_value_fld, octx)) ||
       nctx->init(thd))
   {
-    delete nctx; /* Delete nctx if it was init() that failed. */
-    DBUG_RETURN(TRUE);
+    thd->restore_active_arena(&call_arena, &backup_arena);
+    err_status= TRUE;
+    goto err_with_cleanup;
   }
 
+  /*
+    We have to switch temporarily back to callers arena/memroot.
+    Function arguments belong to the caller and so the may reference
+    memory which they will allocate during calculation long after
+    this function call will be finished (e.g. in Item::cleanup()).
+  */
+  thd->restore_active_arena(&call_arena, &backup_arena);
+
 #ifndef DBUG_OFF
   nctx->sp= this;
 #endif
 
   /* Pass arguments. */
-
+  for (arg_no= 0; arg_no < argcount; arg_no++)
   {
-    uint i;
-    
-    for (i= 0 ; i < argcount ; i++)
-    {
-      if (!argp[i]->fixed && argp[i]->fix_fields(thd, &argp[i]))
-      {
-        err_status= TRUE;
-        break;
-      }
-
-      param_values[i]= Item_cache::get_cache(argp[i]->result_type());
-      param_values[i]->store(argp[i]);
-
-      if (nctx->set_variable(thd, i, (struct Item **)&(param_values[i])))
-      {
-        err_status= TRUE;
-        break;
-      }
-    }
-  }
+    /* Arguments must be fixed in Item_func_sp::fix_fields */
+    DBUG_ASSERT(argp[arg_no]->fixed);
 
-  if (err_status)
-  {
-    delete nctx;
-    DBUG_RETURN(TRUE);
+    if ((err_status= nctx->set_variable(thd, arg_no, &(argp[arg_no]))))
+      goto err_with_cleanup;
   }
 
-  thd->spcont= nctx;
-
   /*
     If row-based binlogging, we don't need to binlog the function's call, let
     each substatement be binlogged its way.
   */
   need_binlog_call= mysql_bin_log.is_open() &&
     (thd->options & OPTION_BIN_LOG) && !thd->current_stmt_binlog_row_based;
+
+  /*
+    Remember the original arguments for unrolled replication of functions
+    before they are changed by execution.
+  */
+  if (need_binlog_call)
+  {
+    binlog_buf.length(0);
+    binlog_buf.append(STRING_WITH_LEN("SELECT "));
+    append_identifier(thd, &binlog_buf, m_name.str, m_name.length);
+    binlog_buf.append('(');
+    for (arg_no= 0; arg_no < argcount; arg_no++)
+    {
+      String str_value_holder;
+      String *str_value;
+
+      if (arg_no)
+        binlog_buf.append(',');
+
+      str_value= sp_get_item_value(nctx->get_item(arg_no),
+                                   &str_value_holder);
+
+      if (str_value)
+        binlog_buf.append(*str_value);
+      else
+        binlog_buf.append(STRING_WITH_LEN("NULL"));
+    }
+    binlog_buf.append(')');
+  }
+  thd->spcont= nctx;
+
   if (need_binlog_call)
   {
     reset_dynamic(&thd->user_var_events);
@@ -1316,38 +1349,27 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     thd->options&= ~OPTION_BIN_LOG;
   }
 
+  /*
+    Switch to call arena/mem_root so objects like sp_cursor or
+    Item_cache holders for case expressions can be allocated on it.
+
+    TODO: In future we should associate call arena/mem_root with
+          sp_rcontext and allocate all these objects (and sp_rcontext
+          itself) on it directly rather than juggle with arenas.
+  */
+  thd->set_n_backup_active_arena(&call_arena, &backup_arena);
+
   err_status= execute(thd);
 
+  thd->restore_active_arena(&call_arena, &backup_arena);
+
   if (need_binlog_call)
   {
     mysql_bin_log.stop_union_events(thd);
     thd->options= binlog_save_options;
     if (thd->binlog_evt_union.unioned_events)
     {
-      char buf[256];
-      String bufstr(buf, sizeof(buf), &my_charset_bin);
-      bufstr.length(0);
-      bufstr.append(STRING_WITH_LEN("SELECT "));
-      append_identifier(thd, &bufstr, m_name.str, m_name.length);
-      bufstr.append('(');
-      for (uint i=0; i < argcount; i++)
-      {
-        String str_value_holder;
-        String *str_value;
-
-        if (i)
-          bufstr.append(',');
-        
-        str_value= sp_get_item_value(param_values[i], &str_value_holder);
-
-        if (str_value)
-          bufstr.append(*str_value);
-        else
-          bufstr.append(STRING_WITH_LEN("NULL"));
-      }
-      bufstr.append(')');
-      
-      Query_log_event qinfo(thd, bufstr.ptr(), bufstr.length(),
+      Query_log_event qinfo(thd, binlog_buf.ptr(), binlog_buf.length(),
                             thd->binlog_evt_union.unioned_events_trans, FALSE);
       if (mysql_bin_log.write(&qinfo) &&
           thd->binlog_evt_union.unioned_events_trans)
@@ -1371,27 +1393,19 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     }
   }
 
+
   nctx->pop_all_cursors();	// To avoid memory leaks after an error
+
+err_with_cleanup:
   delete nctx;
+  call_arena.free_items();
+  free_root(&call_mem_root, MYF(0));
   thd->spcont= octx;
 
   DBUG_RETURN(err_status);
 }
 
 
-static Item_func_get_user_var *item_is_user_var(Item *it)
-{
-  if (it->type() == Item::FUNC_ITEM)
-  {
-    Item_func *fi= static_cast<Item_func*>(it);
-
-    if (fi->functype() == Item_func::GUSERVAR_FUNC)
-      return static_cast<Item_func_get_user_var*>(fi);
-  }
-  return NULL;
-}
-
-
 /*
   Execute a procedure. 
   SYNOPSIS
@@ -1469,22 +1483,28 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
     for (uint i= 0 ; i < params ; i++)
     {
       Item *arg_item= it_args++;
-      sp_variable_t *spvar= m_pcont->find_variable(i);
 
       if (!arg_item)
         break;
 
+      sp_variable_t *spvar= m_pcont->find_variable(i);
+
       if (!spvar)
         continue;
 
       if (spvar->mode != sp_param_in)
       {
-        if (!arg_item->is_splocal() && !item_is_user_var(arg_item))
+        Settable_routine_parameter *srp=
+          arg_item->get_settable_routine_parameter();
+
+        if (!srp)
         {
           my_error(ER_SP_NOT_VAR_ARG, MYF(0), i+1, m_qname.str);
           err_status= TRUE;
           break;
         }
+
+        srp->set_required_privilege(spvar->mode == sp_param_inout);
       }
 
       if (spvar->mode == sp_param_out)
@@ -1568,36 +1588,16 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
       if (spvar->mode == sp_param_in)
         continue;
 
-      if (arg_item->is_splocal())
-      {
-        if (octx->set_variable(thd,
-                               ((Item_splocal*) arg_item)->get_var_idx(),
-                               nctx->get_item_addr(i)))
-        {
-          err_status= TRUE;
-          break;
-        }
-      }
-      else
+      Settable_routine_parameter *srp=
+        arg_item->get_settable_routine_parameter();
+
+      DBUG_ASSERT(srp);
+
+      if (srp->set_value(thd, octx, nctx->get_item_addr(i)))
       {
-        Item_func_get_user_var *guv= item_is_user_var(arg_item);
-
-	if (guv)
-	{
-	  Item **item= nctx->get_item_addr(i);
-	  Item_func_set_user_var *suv;
-
-	  suv= new Item_func_set_user_var(guv->get_name(), *item);
-	  /*
-            Item_func_set_user_var is not fixed after construction,
-            call fix_fields().
-	  */
-          if ((err_status= test(!suv || suv->fix_fields(thd, item) ||
-                                suv->check() || suv->update())))
-            break;
-	}
+        err_status= TRUE;
+        break;
       }
-
     }
   }
 
@@ -2439,12 +2439,7 @@ sp_instr_set_trigger_field::execute(THD *thd, uint *nextp)
 int
 sp_instr_set_trigger_field::exec_core(THD *thd, uint *nextp)
 {
-  int res= 0;
-  Item *it= sp_prepare_func_item(thd, &value);
-  if (!it ||
-      !trigger_field->fixed && trigger_field->fix_fields(thd, 0) ||
-      (it->save_in_field(trigger_field->field, 0) < 0))
-    res= -1;
+  const int res= (trigger_field->set_value(thd, &value) ? -1 : 0);
   *nextp = m_ip+1;
   return res;
 }
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 8ea53747b40..802385a0f07 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1793,6 +1793,8 @@ bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
                           MYSQL_LOCK_IGNORE_FLUSH - Open table even if
                           someone has done a flush or namelock on it.
                           No version number checking is done.
+                          MYSQL_OPEN_IGNORE_LOCKED_TABLES - Open table
+                          ignoring set of locked tables and prelocked mode.
 
   IMPLEMENTATION
     Uses a cache of open tables to find a table not in use.
@@ -1852,7 +1854,8 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
     }
   }
 
-  if (thd->locked_tables || thd->prelocked_mode)
+  if (!(flags & MYSQL_OPEN_IGNORE_LOCKED_TABLES) &&
+      (thd->locked_tables || thd->prelocked_mode))
   {						// Using table locks
     TABLE *best_table= 0;
     int best_distance= INT_MIN;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 946c0536897..ddee8394365 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -2518,6 +2518,153 @@ bool select_insert::send_eof()
   CREATE TABLE (SELECT) ...
 ***************************************************************************/
 
+/*
+  Create table from lists of fields and items (or open existing table
+  with same name).
+
+  SYNOPSIS
+    create_table_from_items()
+      thd          in     Thread object
+      create_info  in     Create information (like MAX_ROWS, ENGINE or
+                          temporary table flag)
+      create_table in     Pointer to TABLE_LIST object providing database
+                          and name for table to be created or to be open
+      extra_fields in/out Initial list of fields for table to be created
+      keys         in     List of keys for table to be created
+      items        in     List of items which should be used to produce rest
+                          of fields for the table (corresponding fields will
+                          be added to the end of 'extra_fields' list)
+      lock         out    Pointer to the MYSQL_LOCK object for table created
+                          (open) will be returned in this parameter. Since
+                          this table is not included in THD::lock caller is
+                          responsible for explicitly unlocking this table.
+
+  NOTES
+    If 'create_info->options' bitmask has HA_LEX_CREATE_IF_NOT_EXISTS
+    flag and table with name provided already exists then this function will
+    simply open existing table.
+    Also note that create, open and lock sequence in this function is not
+    atomic and thus contains gap for deadlock and can cause other troubles.
+    Since this function contains some logic specific to CREATE TABLE ... SELECT
+    it should be changed before it can be used in other contexts.
+
+  RETURN VALUES
+    non-zero  Pointer to TABLE object for table created or opened
+    0         Error
+*/
+
+static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
+                                      TABLE_LIST *create_table,
+                                      List<create_field> *extra_fields,
+                                      List<Key> *keys, List<Item> *items,
+                                      MYSQL_LOCK **lock)
+{
+  TABLE tmp_table;		// Used during 'create_field()'
+  TABLE *table= 0;
+  uint select_field_count= items->elements;
+  /* Add selected items to field list */
+  List_iterator_fast<Item> it(*items);
+  Item *item;
+  Field *tmp_field;
+  bool not_used;
+  DBUG_ENTER("create_table_from_items");
+
+  tmp_table.alias= 0;
+  tmp_table.timestamp_field= 0;
+  tmp_table.s= &tmp_table.share_not_to_be_used;
+  tmp_table.s->db_create_options=0;
+  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
+  tmp_table.s->db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM ||
+                                       create_info->db_type == DB_TYPE_HEAP);
+  tmp_table.null_row=tmp_table.maybe_null=0;
+
+  while ((item=it++))
+  {
+    create_field *cr_field;
+    Field *field;
+    if (item->type() == Item::FUNC_ITEM)
+      field=item->tmp_table_field(&tmp_table);
+    else
+      field=create_tmp_field(thd, &tmp_table, item, item->type(),
+                             (Item ***) 0, &tmp_field, 0, 0, 0, 0, 0);
+    if (!field ||
+	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
+					   ((Item_field *)item)->field :
+					   (Field*) 0))))
+      DBUG_RETURN(0);
+    if (item->maybe_null)
+      cr_field->flags &= ~NOT_NULL_FLAG;
+    extra_fields->push_back(cr_field);
+  }
+  /*
+    create and lock table
+
+    We don't log the statement, it will be logged later.
+
+    If this is a HEAP table, the automatic DELETE FROM which is written to the
+    binlog when a HEAP table is opened for the first time since startup, must
+    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
+    don't want to delete from it) 2) it would be written before the CREATE
+    TABLE, which is a wrong order. So we keep binary logging disabled when we
+    open_table().
+    NOTE: By locking table which we just have created (or for which we just have
+    have found that it already exists) separately from other tables used by the
+    statement we create potential window for deadlock.
+    TODO: create and open should be done atomic !
+  */
+  {
+    tmp_disable_binlog(thd);
+    if (!mysql_create_table(thd, create_table->db, create_table->table_name,
+                            create_info, *extra_fields, *keys, 0,
+                            select_field_count))
+    {
+      /*
+        If we are here in prelocked mode we either create temporary table
+        or prelocked mode is caused by the SELECT part of this statement.
+      */
+      DBUG_ASSERT(!thd->prelocked_mode ||
+                  create_info->options & HA_LEX_CREATE_TMP_TABLE ||
+                  thd->lex->requires_prelocking());
+
+      /*
+        NOTE: We don't want to ignore set of locked tables here if we are
+              under explicit LOCK TABLES since it will open gap for deadlock
+              too wide (and also is not backward compatible).
+      */
+      if (! (table= open_table(thd, create_table, thd->mem_root, (bool*) 0,
+                               (MYSQL_LOCK_IGNORE_FLUSH |
+                                ((thd->prelocked_mode == PRELOCKED) ?
+                                 MYSQL_OPEN_IGNORE_LOCKED_TABLES:0)))))
+        quick_rm_table(create_info->db_type, create_table->db,
+                       table_case_name(create_info, create_table->table_name));
+    }
+    reenable_binlog(thd);
+    if (!table)                                   // open failed
+      DBUG_RETURN(0);
+  }
+
+  /*
+    FIXME: What happens if trigger manages to be created while we are
+           obtaining this lock ? May be it is sensible just to disable
+           trigger execution in this case ? Or will MYSQL_LOCK_IGNORE_FLUSH
+           save us from that ?
+  */
+  table->reginfo.lock_type=TL_WRITE;
+  if (! ((*lock)= mysql_lock_tables(thd, &table, 1,
+                                    MYSQL_LOCK_IGNORE_FLUSH, &not_used)))
+  {
+    VOID(pthread_mutex_lock(&LOCK_open));
+    hash_delete(&open_cache,(byte*) table);
+    VOID(pthread_mutex_unlock(&LOCK_open));
+    quick_rm_table(create_info->db_type, create_table->db,
+		   table_case_name(create_info, create_table->table_name));
+    DBUG_RETURN(0);
+  }
+  table->file->extra(HA_EXTRA_WRITE_CACHE);
+  DBUG_RETURN(table);
+}
+
+
 int
 select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 {
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index b70b2d8608e..33b3118de1a 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -5894,6 +5894,7 @@ void mysql_parse(THD *thd, char *inBuf, uint length)
     }
     else
     {
+      DBUG_ASSERT(thd->net.report_error);
       DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
 			 thd->is_fatal_error));
       query_cache_abort(&thd->net);
@@ -7426,7 +7427,7 @@ bool create_table_precheck(THD *thd, TABLE_LIST *tables,
 			       lex->create_info.merge_list.first))
     goto err;
   if (grant_option && want_priv != CREATE_TMP_ACL &&
-      check_grant(thd, want_priv, create_table, 0, UINT_MAX, 0))
+      check_grant(thd, want_priv, create_table, 0, 1, 0))
     goto err;
 
   if (select_lex->item_list.elements)
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 37506d11867..f530af33e48 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -3426,111 +3426,6 @@ make_unique_key_name(const char *field_name,KEY *start,KEY *end)
 
 
 /****************************************************************************
-** Create table from a list of fields and items
-****************************************************************************/
-
-TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
-			       TABLE_LIST *create_table,
-			       List<create_field> *extra_fields,
-			       List<Key> *keys,
-			       List<Item> *items,
-			       MYSQL_LOCK **lock,
-                               TABLEOP_HOOKS *hooks)
-{
-  TABLE tmp_table;		// Used during 'create_field()'
-  TABLE_SHARE share;
-  TABLE *table= 0;
-  uint select_field_count= items->elements;
-  /* Add selected items to field list */
-  List_iterator_fast<Item> it(*items);
-  Item *item;
-  Field *tmp_field;
-  bool not_used;
-  DBUG_ENTER("create_table_from_items");
-
-  tmp_table.alias= 0;
-  tmp_table.timestamp_field= 0;
-  tmp_table.s= &share;
-  init_tmp_table_share(&share, "", 0, "", "");
-
-  tmp_table.s->db_create_options=0;
-  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
-  tmp_table.s->db_low_byte_first= 
-        test(create_info->db_type == &myisam_hton ||
-             create_info->db_type == &heap_hton);
-  tmp_table.null_row=tmp_table.maybe_null=0;
-
-  while ((item=it++))
-  {
-    create_field *cr_field;
-    Field *field;
-    if (item->type() == Item::FUNC_ITEM)
-      field=item->tmp_table_field(&tmp_table);
-    else
-      field=create_tmp_field(thd, &tmp_table, item, item->type(),
-                             (Item ***) 0, &tmp_field, 0, 0, 0, 0, 0);
-    if (!field ||
-	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
-					   ((Item_field *)item)->field :
-					   (Field*) 0))))
-      DBUG_RETURN(0);
-    if (item->maybe_null)
-      cr_field->flags &= ~NOT_NULL_FLAG;
-    extra_fields->push_back(cr_field);
-  }
-  /*
-    create and lock table
-
-    We don't log the statement, it will be logged later.
-
-    If this is a HEAP table, the automatic DELETE FROM which is written to the
-    binlog when a HEAP table is opened for the first time since startup, must
-    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
-    don't want to delete from it) 2) it would be written before the CREATE
-    TABLE, which is a wrong order. So we keep binary logging disabled when we
-    open_table().
-    TODO: create and open should be done atomic !
-  */
-  {
-    tmp_disable_binlog(thd);
-    if (!mysql_create_table(thd, create_table->db, create_table->table_name,
-                            create_info, *extra_fields, *keys, 0,
-                            select_field_count))
-    {
-      if (! (table= open_table(thd, create_table, thd->mem_root, (bool*) 0,
-                               MYSQL_LOCK_IGNORE_FLUSH)))
-        quick_rm_table(create_info->db_type, create_table->db,
-                       table_case_name(create_info, create_table->table_name));
-    }
-    reenable_binlog(thd);
-    if (!table)                                   // open failed
-      DBUG_RETURN(0);
-  }
-
-  /*
-    FIXME: What happens if trigger manages to be created while we are
-           obtaining this lock ? May be it is sensible just to disable
-           trigger execution in this case ? Or will MYSQL_LOCK_IGNORE_FLUSH
-           save us from that ?
-  */
-  table->reginfo.lock_type=TL_WRITE;
-  hooks->prelock(&table, 1);                    // Call prelock hooks
-  if (! ((*lock)= mysql_lock_tables(thd, &table, 1,
-                                    MYSQL_LOCK_IGNORE_FLUSH, &not_used)))
-  {
-    VOID(pthread_mutex_lock(&LOCK_open));
-    hash_delete(&open_cache,(byte*) table);
-    VOID(pthread_mutex_unlock(&LOCK_open));
-    quick_rm_table(create_info->db_type, create_table->db,
-		   table_case_name(create_info, create_table->table_name));
-    DBUG_RETURN(0);
-  }
-  table->file->extra(HA_EXTRA_WRITE_CACHE);
-  DBUG_RETURN(table);
-}
-
-
-/****************************************************************************
 ** Alter a table definition
 ****************************************************************************/
 
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 3d3bd3e799d..fb84d5e4459 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -7496,7 +7496,11 @@ select_var_ident:
 	     if (lex->result) 
 	       ((select_dumpvar *)lex->result)->var_list.push_back( new my_var($2,0,0,(enum_field_types)0));
 	     else
-	       YYABORT;
+               /*
+                 The parser won't create select_result instance only
+	         if it's an EXPLAIN.
+               */
+               DBUG_ASSERT(lex->describe);
 	   }
            | ident_or_text
            {
@@ -7508,10 +7512,8 @@ select_var_ident:
 	       my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
 	       YYABORT;
 	     }
-	     if (! lex->result)
-	       YYABORT;
-	     else
-	     {
+	     if (lex->result)
+             {
                my_var *var;
 	       ((select_dumpvar *)lex->result)->
                  var_list.push_back(var= new my_var($1,1,t->offset,t->type));
@@ -7519,6 +7521,14 @@ select_var_ident:
 	       if (var)
 		 var->sp= lex->sphead;
 #endif
+             }
+	     else
+	     {
+               /*
+                 The parser won't create select_result instance only
+	         if it's an EXPLAIN.
+               */
+               DBUG_ASSERT(lex->describe);
 	     }
 	   }
            ;
@@ -9014,12 +9024,18 @@ simple_ident_q:
               YYABORT;
             }
 
+            DBUG_ASSERT(!new_row ||
+                        (lex->trg_chistics.event == TRG_EVENT_INSERT ||
+                         lex->trg_chistics.event == TRG_EVENT_UPDATE));
+            const bool read_only=
+              !(new_row && lex->trg_chistics.action_time == TRG_ACTION_BEFORE);
             if (!(trg_fld= new Item_trigger_field(Lex->current_context(),
                                                   new_row ?
                                                   Item_trigger_field::NEW_ROW:
                                                   Item_trigger_field::OLD_ROW,
                                                   $3.str,
-                                                  Item_trigger_field::AT_READ)))
+                                                  SELECT_ACL,
+                                                  read_only)))
               YYABORT;
 
             /*
@@ -9700,11 +9716,13 @@ sys_option_value:
               it= new Item_null();
             }
 
+            DBUG_ASSERT(lex->trg_chistics.action_time == TRG_ACTION_BEFORE &&
+                        (lex->trg_chistics.event == TRG_EVENT_INSERT ||
+                         lex->trg_chistics.event == TRG_EVENT_UPDATE));
             if (!(trg_fld= new Item_trigger_field(Lex->current_context(),
                                                   Item_trigger_field::NEW_ROW,
                                                   $2.base_name.str,
-                                                  Item_trigger_field::AT_UPDATE)
-                                                  ) ||
+                                                  UPDATE_ACL, FALSE)) ||
                 !(sp_fld= new sp_instr_set_trigger_field(lex->sphead->
                           	                         instructions(),
                                 	                 lex->spcont,