System Versioning 1.0 pre3

Merge branch '10.3' into trunk

86 files changed, 6552 insertions, 1690 deletions

diff --git a/sql/filesort.cc b/sql/filesort.cc
index 3c33f06d6cf..b762773b11e 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -826,11 +826,11 @@ static ha_rows find_all_keys(THD *thd, Sort_param *param, SQL_SELECT *select,
         MY_BITMAP *tmp_write_set= sort_form->write_set;
         MY_BITMAP *tmp_vcol_set= sort_form->vcol_set;
 
-        if (select->cond->with_subselect)
+        if (select->cond->with_subquery())
           sort_form->column_bitmaps_set(save_read_set, save_write_set,
                                         save_vcol_set);
         write_record= (select->skip_record(thd) > 0);
-        if (select->cond->with_subselect)
+        if (select->cond->with_subquery())
           sort_form->column_bitmaps_set(tmp_read_set,
                                         tmp_write_set,
                                         tmp_vcol_set);
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 8d019ba69f3..454ff573624 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -35,7 +35,7 @@
   Partitioning lays the foundation for more manageable databases that are
   extremely large. It does also lay the foundation for more parallelism
   in the execution of queries. This functionality will grow with later
-  versions of MySQL.
+  versions of MySQL/MariaDB.
 
   The partition is setup to use table locks. It implements an partition "SHARE"
   that is inserted into a hash by table name. You can use this to store
@@ -58,6 +58,7 @@
 #include "sql_plugin.h"
 #include "sql_show.h"                        // append_identifier
 #include "sql_admin.h"                       // SQL_ADMIN_MSG_TEXT_SIZE
+#include "sql_select.h"
 
 #include "debug_sync.h"
 
@@ -73,9 +74,7 @@
                                        HA_REC_NOT_IN_SEQ | \
                                        HA_CAN_REPAIR)
 #define PARTITION_DISABLED_TABLE_FLAGS (HA_CAN_GEOMETRY | \
-                                        HA_CAN_FULLTEXT | \
                                         HA_DUPLICATE_POS | \
-                                        HA_CAN_SQL_HANDLER | \
                                         HA_CAN_INSERT_DELAYED | \
                                         HA_READ_BEFORE_WRITE_REMOVAL |\
                                         HA_CAN_TABLES_WITHOUT_ROLLBACK)
@@ -92,9 +91,6 @@ static handler *partition_create_handler(handlerton *hton,
 static uint partition_flags();
 static uint alter_table_flags(uint flags);
 
-extern "C" int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2);
-extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2);
-
 /*
   If frm_error() is called then we will use this to to find out what file
   extensions exist for the storage engine. This is also used by the default
@@ -126,7 +122,6 @@ static void init_partition_psi_keys(void)
 
 static int partition_initialize(void *p)
 {
-
   handlerton *partition_hton;
   partition_hton= (handlerton *)p;
 
@@ -182,7 +177,7 @@ bool Partition_share::init(uint num_parts)
     New partition object
 */
 
-static handler *partition_create_handler(handlerton *hton, 
+static handler *partition_create_handler(handlerton *hton,
                                          TABLE_SHARE *share,
                                          MEM_ROOT *mem_root)
 {
@@ -225,8 +220,6 @@ static uint alter_table_flags(uint flags __attribute__((unused)))
           HA_FAST_CHANGE_PARTITION);
 }
 
-const uint32 ha_partition::NO_CURRENT_PART_ID= NOT_A_PARTITION_ID;
-
 /*
   Constructor method
 
@@ -242,12 +235,19 @@ ha_partition::ha_partition(handlerton *hton, TABLE_SHARE *share)
   :handler(hton, share)
 {
   DBUG_ENTER("ha_partition::ha_partition(table)");
-  init_alloc_root(&m_mem_root, 512, 512, MYF(0));
-  init_handler_variables();
+  ha_partition_init();
   DBUG_VOID_RETURN;
 }
 
 
+/* Initialize all partition variables */
+
+void ha_partition::ha_partition_init()
+{
+  init_alloc_root(&m_mem_root, 512, 512, MYF(0));
+  init_handler_variables();
+}
+
 /*
   Constructor method
 
@@ -264,8 +264,7 @@ ha_partition::ha_partition(handlerton *hton, partition_info *part_info)
 {
   DBUG_ENTER("ha_partition::ha_partition(part_info)");
   DBUG_ASSERT(part_info);
-  init_alloc_root(&m_mem_root, 512, 512, MYF(0));
-  init_handler_variables();
+  ha_partition_init();
   m_part_info= part_info;
   m_create_handler= TRUE;
   m_is_sub_partitioned= m_part_info->is_sub_partitioned();
@@ -291,8 +290,7 @@ ha_partition::ha_partition(handlerton *hton, TABLE_SHARE *share,
   :handler(hton, share)
 {
   DBUG_ENTER("ha_partition::ha_partition(clone)");
-  init_alloc_root(&m_mem_root, 512, 512, MYF(0));
-  init_handler_variables();
+  ha_partition_init();
   m_part_info= part_info_arg;
   m_create_handler= TRUE;
   m_is_sub_partitioned= m_part_info->is_sub_partitioned();
@@ -355,6 +353,7 @@ void ha_partition::init_handler_variables()
   m_curr_key_info[0]= NULL;
   m_curr_key_info[1]= NULL;
   m_part_func_monotonicity_info= NON_MONOTONIC;
+  m_key_not_found= FALSE;
   auto_increment_lock= FALSE;
   auto_increment_safe_stmt_log_lock= FALSE;
   /*
@@ -370,6 +369,27 @@ void ha_partition::init_handler_variables()
   m_new_partitions_share_refs.empty();
   m_part_ids_sorted_by_num_of_records= NULL;
 
+  m_range_info= NULL;
+  m_mrr_full_buffer_size= 0;
+  m_mrr_new_full_buffer_size= 0;
+  m_mrr_full_buffer= NULL;
+  m_mrr_range_first= NULL;
+
+  m_pre_calling= FALSE;
+  m_pre_call_use_parallel= FALSE;
+
+  ft_first= ft_current=  NULL;
+  bulk_access_executing= FALSE;                 // For future
+
+  /*
+    Clear bitmaps to allow on one to call my_bitmap_free() on them at any time
+  */
+  my_bitmap_clear(&m_bulk_insert_started);
+  my_bitmap_clear(&m_locked_partitions);
+  my_bitmap_clear(&m_partitions_to_reset);
+  my_bitmap_clear(&m_key_not_found_partitions);
+  my_bitmap_clear(&m_mrr_used_partitions);
+
 #ifdef DONT_HAVE_TO_BE_INITALIZED
   m_start_key.flag= 0;
   m_ordered= TRUE;
@@ -378,9 +398,9 @@ void ha_partition::init_handler_variables()
 
 
 const char *ha_partition::table_type() const
-{ 
+{
   // we can do this since we only support a single engine type
-  return m_file[0]->table_type(); 
+  return m_file[0]->table_type();
 }
 
 
@@ -681,6 +701,7 @@ int ha_partition::create(const char *name, TABLE *table_arg,
   partition_element *part_elem;
   handler **file, **abort_file;
   DBUG_ENTER("ha_partition::create");
+  DBUG_PRINT("enter", ("name: '%s'", name));
 
   DBUG_ASSERT(!fn_frm_ext(name));
 
@@ -694,7 +715,6 @@ int ha_partition::create(const char *name, TABLE *table_arg,
   if (get_from_handler_file(name, ha_thd()->mem_root, false))
     DBUG_RETURN(TRUE);
   DBUG_ASSERT(m_file_buffer);
-  DBUG_PRINT("enter", ("name: (%s)", name));
   name_buffer_ptr= m_name_buffer_ptr;
   file= m_file;
   /*
@@ -957,7 +977,7 @@ int ha_partition::rename_partitions(const char *path)
        When state is PART_IS_CHANGED it means that we have created a new
        TEMP partition that is to be renamed to normal partition name and
        we are to delete the old partition with currently the normal name.
-       
+
        We perform this operation by
        1) Delete old partition with normal partition name
        2) Signal this in table log entry
@@ -1192,7 +1212,7 @@ int ha_partition::preload_keys(THD *thd, HA_CHECK_OPT *check_opt)
   DBUG_RETURN(handle_opt_partitions(thd, check_opt, PRELOAD_KEYS_PARTS));
 }
 
- 
+
 /*
   Handle optimize/analyze/check/repair of one partition
 
@@ -1214,7 +1234,7 @@ int ha_partition::handle_opt_part(THD *thd, HA_CHECK_OPT *check_opt,
   int error;
   handler *file= m_file[part_id];
   DBUG_ENTER("handle_opt_part");
-  DBUG_PRINT("enter", ("flag = %u", flag));
+  DBUG_PRINT("enter", ("flag: %u", flag));
 
   if (flag == OPTIMIZE_PARTS)
     error= file->ha_optimize(thd, check_opt);
@@ -1258,7 +1278,7 @@ int ha_partition::handle_opt_part(THD *thd, HA_CHECK_OPT *check_opt,
 
 
 /*
-   print a message row formatted for ANALYZE/CHECK/OPTIMIZE/REPAIR TABLE 
+   print a message row formatted for ANALYZE/CHECK/OPTIMIZE/REPAIR TABLE
    (modelled after mi_check_print_msg)
    TODO: move this into the handler, or rewrite mysql_admin_table.
 */
@@ -1287,7 +1307,7 @@ bool print_admin_msg(THD* thd, uint len,
   va_end(args);
   if (msg_length >= (len - 1))
     goto err;
-  msgbuf[len - 1] = 0; // healthy paranoia
+  msgbuf[len - 1]= 0; // healthy paranoia
 
 
   if (!thd->vio_ok())
@@ -1381,7 +1401,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
 	      print_admin_msg(thd, MYSQL_ERRMSG_SIZE, "error",
                               table_share->db.str, table->alias,
                               opt_op_name[flag],
-                              "Subpartition %s returned error", 
+                              "Subpartition %s returned error",
                               sub_elem->partition_name);
             }
             /* reset part_state for the remaining partitions */
@@ -1407,7 +1427,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
           {
 	    print_admin_msg(thd, MYSQL_ERRMSG_SIZE, "error",
                             table_share->db.str, table->alias,
-                            opt_op_name[flag], "Partition %s returned error", 
+                            opt_op_name[flag], "Partition %s returned error",
                             part_elem->partition_name);
           }
           /* reset part_state for the remaining partitions */
@@ -1449,7 +1469,7 @@ bool ha_partition::check_and_repair(THD *thd)
   } while (*(++file));
   DBUG_RETURN(FALSE);
 }
- 
+
 
 /**
   @breif Check if the table can be automatically repaired
@@ -1489,7 +1509,7 @@ bool ha_partition::is_crashed() const
   } while (*(++file));
   DBUG_RETURN(FALSE);
 }
- 
+
 
 /*
   Prepare by creating a new partition
@@ -1534,7 +1554,8 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
   if ((error= set_up_table_before_create(tbl, part_name, create_info, p_elem)))
     goto error_create;
 
-  tbl->s->connect_string = p_elem->connect_string;
+  if (!(file->ht->flags & HTON_CAN_READ_CONNECT_STRING_IN_PARTITION))
+    tbl->s->connect_string= p_elem->connect_string;
   if ((error= file->ha_create(part_name, tbl, create_info)))
   {
     /*
@@ -1869,7 +1890,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
      in the  partitions.
   */
 
-  uint disable_non_uniq_indexes = indexes_are_disabled();
+  uint disable_non_uniq_indexes= indexes_are_disabled();
 
   i= 0;
   part_count= 0;
@@ -2108,10 +2129,11 @@ void ha_partition::update_create_info(HA_CREATE_INFO *create_info)
     DATA DIRECTORY and INDEX DIRECTORY are never applied to the whole
     partitioned table, only its parts.
   */
-  my_bool from_alter = (create_info->data_file_name == (const char*) -1);
-  create_info->data_file_name= create_info->index_file_name = NULL;
+  my_bool from_alter= (create_info->data_file_name == (const char*) -1);
+  create_info->data_file_name= create_info->index_file_name= NULL;
 
-  create_info->connect_string= null_clex_str;
+  if (!(m_file[0]->ht->flags & HTON_CAN_READ_CONNECT_STRING_IN_PARTITION))
+    create_info->connect_string= null_clex_str;
 
   /*
     We do not need to update the individual partition DATA DIRECTORY settings
@@ -2129,8 +2151,8 @@ void ha_partition::update_create_info(HA_CREATE_INFO *create_info)
   List_iterator<partition_element> part_it(m_part_info->partitions);
   partition_element *part_elem, *sub_elem;
   uint num_subparts= m_part_info->num_subparts;
-  uint num_parts = num_subparts ? m_file_tot_parts / num_subparts
-                                : m_file_tot_parts;
+  uint num_parts= (num_subparts ? m_file_tot_parts / num_subparts :
+                   m_file_tot_parts);
   HA_CREATE_INFO dummy_info;
   memset(&dummy_info, 0, sizeof(dummy_info));
 
@@ -2181,16 +2203,16 @@ void ha_partition::update_create_info(HA_CREATE_INFO *create_info)
         DBUG_ASSERT(part < m_file_tot_parts && m_file[part]);
         if (ha_legacy_type(m_file[part]->ht) == DB_TYPE_INNODB)
         {
-          dummy_info.data_file_name= dummy_info.index_file_name = NULL;
+          dummy_info.data_file_name= dummy_info.index_file_name= NULL;
           m_file[part]->update_create_info(&dummy_info);
 
           if (dummy_info.data_file_name || sub_elem->data_file_name)
           {
-            sub_elem->data_file_name = (char*) dummy_info.data_file_name;
+            sub_elem->data_file_name= (char*) dummy_info.data_file_name;
           }
           if (dummy_info.index_file_name || sub_elem->index_file_name)
           {
-            sub_elem->index_file_name = (char*) dummy_info.index_file_name;
+            sub_elem->index_file_name= (char*) dummy_info.index_file_name;
           }
         }
       }
@@ -2204,11 +2226,11 @@ void ha_partition::update_create_info(HA_CREATE_INFO *create_info)
         m_file[i]->update_create_info(&dummy_info);
         if (dummy_info.data_file_name || part_elem->data_file_name)
         {
-          part_elem->data_file_name = (char*) dummy_info.data_file_name;
+          part_elem->data_file_name= (char*) dummy_info.data_file_name;
         }
         if (dummy_info.index_file_name || part_elem->index_file_name)
         {
-          part_elem->index_file_name = (char*) dummy_info.index_file_name;
+          part_elem->index_file_name= (char*) dummy_info.index_file_name;
         }
       }
     }
@@ -2265,7 +2287,7 @@ void ha_partition::change_table_ptr(TABLE *table_arg, TABLE_SHARE *share)
     comment                       Original comment
 
   RETURN VALUE
-    new comment 
+    new comment
 
   DESCRIPTION
     No comment changes so far
@@ -2392,7 +2414,7 @@ uint ha_partition::count_query_cache_dependant_tables(uint8 *tables_type)
   /* Here we rely on the fact that all tables are of the same type */
   uint8 type= m_file[0]->table_cache_type();
   (*tables_type)|= type;
-  DBUG_PRINT("info", ("cnt: %u", (uint)m_tot_parts));
+  DBUG_PRINT("enter", ("cnt: %u", (uint) m_tot_parts));
   /*
     We need save underlying tables only for HA_CACHE_TBL_ASKTRANSACT:
     HA_CACHE_TBL_NONTRANSACT - because all changes goes through partition table
@@ -2547,7 +2569,7 @@ register_query_cache_dependant_tables(THD *thd,
   @return    status
     @retval  TRUE  Error
     @retval  FALSE Success
-   
+
   @details
     Set up
     1) Comment on partition
@@ -2557,7 +2579,7 @@ register_query_cache_dependant_tables(THD *thd,
 */
 
 int ha_partition::set_up_table_before_create(TABLE *tbl,
-                    const char *partition_name_with_path, 
+                    const char *partition_name_with_path,
                     HA_CREATE_INFO *info,
                     partition_element *part_elem)
 {
@@ -2652,8 +2674,7 @@ bool ha_partition::create_handler_file(const char *name)
   DBUG_ENTER("create_handler_file");
 
   num_parts= m_part_info->partitions.elements;
-  DBUG_PRINT("info", ("table name = %s, num_parts = %u", name,
-                      num_parts));
+  DBUG_PRINT("enter", ("table name: %s  num_parts: %u", name, num_parts));
   tot_name_len= 0;
   for (i= 0; i < num_parts; i++)
   {
@@ -2772,7 +2793,7 @@ bool ha_partition::create_handler_file(const char *name)
     {
       uchar buffer[4];
       part_elem= part_it++;
-      uint length = part_elem->connect_string.length;
+      uint length= part_elem->connect_string.length;
       int4store(buffer, length);
       if (my_write(file, buffer, 4, MYF(MY_WME | MY_NABP)) ||
           my_write(file, (uchar *) part_elem->connect_string.str, length,
@@ -2970,7 +2991,7 @@ bool ha_partition::read_par_file(const char *name)
   if (chksum)
     goto err2;
   m_tot_parts= uint4korr((file_buffer) + PAR_NUM_PARTS_OFFSET);
-  DBUG_PRINT("info", ("No of parts = %u", m_tot_parts));
+  DBUG_PRINT("info", ("No of parts: %u", m_tot_parts));
   tot_partition_words= (m_tot_parts + PAR_WORD_SIZE - 1) / PAR_WORD_SIZE;
 
   tot_name_len_offset= file_buffer + PAR_ENGINES_OFFSET +
@@ -3076,7 +3097,7 @@ bool ha_partition::setup_engine_array(MEM_ROOT *mem_root)
   }
 
   my_afree(engine_array);
-    
+
   if (create_handlers(mem_root))
   {
     clear_handler_file();
@@ -3358,63 +3379,53 @@ void ha_partition::free_partition_bitmaps()
   my_bitmap_free(&m_locked_partitions);
   my_bitmap_free(&m_partitions_to_reset);
   my_bitmap_free(&m_key_not_found_partitions);
+  my_bitmap_free(&m_mrr_used_partitions);
 }
 
 
 /**
   Helper function for initializing all internal bitmaps.
+
+  Note:
+  All bitmaps, including partially allocated, are freed in
+  free_partion_bitmaps()
 */
 
 bool ha_partition::init_partition_bitmaps()
 {
   DBUG_ENTER("ha_partition::init_partition_bitmaps");
+
   /* Initialize the bitmap we use to minimize ha_start_bulk_insert calls */
   if (my_bitmap_init(&m_bulk_insert_started, NULL, m_tot_parts + 1, FALSE))
     DBUG_RETURN(true);
-  bitmap_clear_all(&m_bulk_insert_started);
 
   /* Initialize the bitmap we use to keep track of locked partitions */
   if (my_bitmap_init(&m_locked_partitions, NULL, m_tot_parts, FALSE))
-  {
-    my_bitmap_free(&m_bulk_insert_started);
     DBUG_RETURN(true);
-  }
-  bitmap_clear_all(&m_locked_partitions);
 
   /*
     Initialize the bitmap we use to keep track of partitions which may have
     something to reset in ha_reset().
   */
   if (my_bitmap_init(&m_partitions_to_reset, NULL, m_tot_parts, FALSE))
-  {
-    my_bitmap_free(&m_bulk_insert_started);
-    my_bitmap_free(&m_locked_partitions);
     DBUG_RETURN(true);
-  }
-  bitmap_clear_all(&m_partitions_to_reset);
 
   /*
     Initialize the bitmap we use to keep track of partitions which returned
     HA_ERR_KEY_NOT_FOUND from index_read_map.
   */
   if (my_bitmap_init(&m_key_not_found_partitions, NULL, m_tot_parts, FALSE))
-  {
-    my_bitmap_free(&m_bulk_insert_started);
-    my_bitmap_free(&m_locked_partitions);
-    my_bitmap_free(&m_partitions_to_reset);
     DBUG_RETURN(true);
-  }
-  bitmap_clear_all(&m_key_not_found_partitions);
-  m_key_not_found= false;
+
+  if (bitmap_init(&m_mrr_used_partitions, NULL, m_tot_parts, TRUE))
+    DBUG_RETURN(true);
+
   /* Initialize the bitmap for read/lock_partitions */
   if (!m_is_clone_of)
   {
     DBUG_ASSERT(!m_clone_mem_root);
     if (m_part_info->set_partition_bitmaps(NULL))
-    {
-      free_partition_bitmaps();
       DBUG_RETURN(true);
-    }
   }
   DBUG_RETURN(false);
 }
@@ -3479,9 +3490,29 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
   }
 
   if (init_partition_bitmaps())
-    DBUG_RETURN(error);
-
-  DBUG_ASSERT(m_part_info);
+    goto err_alloc;
+
+  /* Allocate memory used with MMR */
+  if (!(m_range_info= (void **)
+        my_multi_malloc(MYF(MY_WME),
+                        &m_range_info, sizeof(range_id_t) * m_tot_parts,
+                        &m_stock_range_seq, sizeof(uint) * m_tot_parts,
+                        &m_mrr_buffer, sizeof(HANDLER_BUFFER) * m_tot_parts,
+                        &m_mrr_buffer_size, sizeof(uint) * m_tot_parts,
+                        &m_part_mrr_range_length, sizeof(uint) * m_tot_parts,
+                        &m_part_mrr_range_first,
+                        sizeof(PARTITION_PART_KEY_MULTI_RANGE *) * m_tot_parts,
+                        &m_part_mrr_range_current,
+                        sizeof(PARTITION_PART_KEY_MULTI_RANGE *) * m_tot_parts,
+                        &m_partition_part_key_multi_range_hld,
+                        sizeof(PARTITION_PART_KEY_MULTI_RANGE_HLD) *
+                        m_tot_parts,
+                        NullS)))
+    goto err_alloc;
+
+  bzero(m_mrr_buffer, m_tot_parts * sizeof(HANDLER_BUFFER));
+  bzero(m_part_mrr_range_first,
+        sizeof(PARTITION_PART_KEY_MULTI_RANGE *) * m_tot_parts);
 
   if (m_is_clone_of)
   {
@@ -3520,21 +3551,31 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
    file= m_file;
    do
    {
+      LEX_CSTRING save_connect_string= table->s->connect_string;
       if ((error= create_partition_name(name_buff, sizeof(name_buff), name,
                                 name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
         goto err_handler;
-      table->s->connect_string = m_connect_string[(uint)(file-m_file)];
-      if ((error= (*file)->ha_open(table, name_buff, mode,
-                                   test_if_locked | HA_OPEN_NO_PSI_CALL)))
+      if (!((*file)->ht->flags & HTON_CAN_READ_CONNECT_STRING_IN_PARTITION))
+        table->s->connect_string= m_connect_string[(uint)(file-m_file)];
+      error= (*file)->ha_open(table, name_buff, mode,
+                              test_if_locked | HA_OPEN_NO_PSI_CALL);
+      table->s->connect_string= save_connect_string;
+      if (error)
         goto err_handler;
-      bzero(&table->s->connect_string, sizeof(LEX_STRING));
       if (m_file == file)
         m_num_locks= (*file)->lock_count();
       DBUG_ASSERT(m_num_locks == (*file)->lock_count());
       name_buffer_ptr+= strlen(name_buffer_ptr) + 1;
     } while (*(++file));
   }
-  
+  /*
+    We want to know the upper bound for locks, to allocate enough memory.
+    There is no performance lost if we simply return in lock_count() the
+    maximum number locks needed, only some minor over allocation of memory
+    in get_lock_data().
+  */
+  m_num_locks*= m_tot_parts;
+
   file= m_file;
   ref_length= (*file)->ref_length;
   check_table_flags= (((*file)->ha_table_flags() &
@@ -3554,7 +3595,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
     {
       error= HA_ERR_INITIALIZATION;
       /* set file to last handler, so all of them are closed */
-      file = &m_file[m_tot_parts - 1];
+      file= &m_file[m_tot_parts - 1];
       goto err_handler;
     }
   }
@@ -3594,6 +3635,8 @@ err_handler:
     (*file)->ha_close();
 err_alloc:
   free_partition_bitmaps();
+  my_free(m_range_info);
+  m_range_info= 0;
 
   DBUG_RETURN(error);
 }
@@ -3671,7 +3714,7 @@ handler *ha_partition::clone(const char *name, MEM_ROOT *mem_root)
 
   /*
     Allocate new_handler->ref here because otherwise ha_open will allocate it
-    on this->table->mem_root and we will not be able to reclaim that memory 
+    on this->table->mem_root and we will not be able to reclaim that memory
     when the clone handler object is destroyed.
   */
   if (!(new_handler->ref= (uchar*) alloc_root(mem_root,
@@ -3713,12 +3756,59 @@ int ha_partition::close(void)
 {
   bool first= TRUE;
   handler **file;
+  uint i;
+  st_partition_ft_info *tmp_ft_info;
   DBUG_ENTER("ha_partition::close");
-
   DBUG_ASSERT(table->s == table_share);
+  DBUG_ASSERT(m_part_info);
+
   destroy_record_priority_queue();
   free_partition_bitmaps();
-  DBUG_ASSERT(m_part_info);
+
+  for (; ft_first ; ft_first= tmp_ft_info)
+  {
+    tmp_ft_info= ft_first->next;
+    my_free(ft_first);
+  }
+
+  /* Free active mrr_ranges */
+  for (i= 0; i < m_tot_parts; i++)
+  {
+    if (m_part_mrr_range_first[i])
+    {
+      PARTITION_PART_KEY_MULTI_RANGE *tmp_mrr_range_first=
+        m_part_mrr_range_first[i];
+      do
+      {
+        PARTITION_PART_KEY_MULTI_RANGE *tmp_mrr_range_current;
+        tmp_mrr_range_current= tmp_mrr_range_first;
+        tmp_mrr_range_first= tmp_mrr_range_first->next;
+        my_free(tmp_mrr_range_current);
+      } while (tmp_mrr_range_first);
+    }
+  }
+  if (m_mrr_range_first)
+  {
+    do
+    {
+      m_mrr_range_current= m_mrr_range_first;
+      m_mrr_range_first= m_mrr_range_first->next;
+      if (m_mrr_range_current->key[0])
+        my_free(m_mrr_range_current->key[0]);
+      if (m_mrr_range_current->key[1])
+        my_free(m_mrr_range_current->key[1]);
+      my_free(m_mrr_range_current);
+    } while (m_mrr_range_first);
+  }
+  my_free(m_range_info);
+  m_range_info= NULL;                           // Safety
+
+  if (m_mrr_full_buffer)
+  {
+    my_free(m_mrr_full_buffer);
+    m_mrr_full_buffer= NULL;
+    m_mrr_full_buffer_size= 0;
+  }
   file= m_file;
 
 repeat:
@@ -3780,7 +3870,7 @@ repeat:
 
 int ha_partition::external_lock(THD *thd, int lock_type)
 {
-  uint error;
+  int error;
   uint i, first_used_partition;
   MY_BITMAP *used_partitions;
   DBUG_ENTER("ha_partition::external_lock");
@@ -3798,7 +3888,7 @@ int ha_partition::external_lock(THD *thd, int lock_type)
        i < m_tot_parts;
        i= bitmap_get_next_set(used_partitions, i))
   {
-    DBUG_PRINT("info", ("external_lock(thd, %d) part %d", lock_type, i));
+    DBUG_PRINT("info", ("external_lock(thd, %d) part %u", lock_type, i));
     if ((error= m_file[i]->ha_external_lock(thd, lock_type)))
     {
       if (lock_type != F_UNLCK)
@@ -3914,7 +4004,7 @@ THR_LOCK_DATA **ha_partition::store_lock(THD *thd,
          i < m_tot_parts;
          i= bitmap_get_next_set(&m_part_info->lock_partitions, i))
     {
-      DBUG_PRINT("info", ("store lock %d iteration", i));
+      DBUG_PRINT("info", ("store lock %u iteration", i));
       to= m_file[i]->store_lock(thd, to, lock_type);
     }
   }
@@ -3975,25 +4065,14 @@ int ha_partition::start_stmt(THD *thd, thr_lock_type lock_type)
   @returns Number of locks returned in call to store_lock
 
   @desc
-    Returns the number of store locks needed in call to store lock.
-    We return number of partitions we will lock multiplied with number of
-    locks needed by each partition. Assists the above functions in allocating
-    sufficient space for lock structures.
+    Returns the maxinum possible number of store locks needed in call to
+    store lock.
 */
 
 uint ha_partition::lock_count() const
 {
   DBUG_ENTER("ha_partition::lock_count");
-  /*
-    The caller want to know the upper bound, to allocate enough memory.
-    There is no performance lost if we simply return maximum number locks
-    needed, only some minor over allocation of memory in get_lock_data().
-
-    Also notice that this may be called for another thread != table->in_use,
-    when mysql_lock_abort_for_thread() is called. So this is more safe, then
-    using number of partitions after pruning.
-  */
-  DBUG_RETURN(m_tot_parts * m_num_locks);
+  DBUG_RETURN(m_num_locks);
 }
 
 
@@ -4072,7 +4151,7 @@ void ha_partition::try_semi_consistent_read(bool yes)
 {
   uint i;
   DBUG_ENTER("ha_partition::try_semi_consistent_read");
-  
+
   i= bitmap_get_first_set(&(m_part_info->read_partitions));
   DBUG_ASSERT(i != MY_BIT_NONE);
   for (;
@@ -4137,7 +4216,7 @@ int ha_partition::write_row(uchar * buf)
   sql_mode_t saved_sql_mode= thd->variables.sql_mode;
   bool saved_auto_inc_field_not_null= table->auto_increment_field_not_null;
   DBUG_ENTER("ha_partition::write_row");
-  DBUG_ASSERT(buf == m_rec0);
+  DBUG_PRINT("enter", ("partition this: %p", this));
 
   /*
     If we have an auto_increment column and we are writing a changed row
@@ -4145,15 +4224,8 @@ int ha_partition::write_row(uchar * buf)
   */
   if (have_auto_increment)
   {
-    if (!part_share->auto_inc_initialized &&
-        !table_share->next_number_keypart)
-    {
-      /*
-        If auto_increment in table_share is not initialized, start by
-        initializing it.
-      */
-      info(HA_STATUS_AUTO);
-    }
+    if (!table_share->next_number_keypart)
+      update_next_auto_inc_val();
     error= update_auto_increment();
 
     /*
@@ -4197,7 +4269,7 @@ int ha_partition::write_row(uchar * buf)
     goto exit;
   }
   m_last_part= part_id;
-  DBUG_PRINT("info", ("Insert in partition %d", part_id));
+  DBUG_PRINT("info", ("Insert in partition %u", part_id));
   start_part_bulk_insert(thd, part_id);
 
   tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
@@ -4289,7 +4361,7 @@ int ha_partition::update_row(const uchar *old_data, const uchar *new_data)
   start_part_bulk_insert(thd, new_part_id);
   if (new_part_id == old_part_id)
   {
-    DBUG_PRINT("info", ("Update in partition %d", new_part_id));
+    DBUG_PRINT("info", ("Update in partition %u", (uint) new_part_id));
     tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
     error= m_file[new_part_id]->ha_update_row(old_data, new_data);
     reenable_binlog(thd);
@@ -4309,8 +4381,8 @@ int ha_partition::update_row(const uchar *old_data, const uchar *new_data)
       This gives the same behavior for partitioned vs non partitioned tables.
     */
     table->next_number_field= NULL;
-    DBUG_PRINT("info", ("Update from partition %d to partition %d",
-			old_part_id, new_part_id));
+    DBUG_PRINT("info", ("Update from partition %u to partition %u",
+			(uint) old_part_id, (uint) new_part_id));
     tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
     error= m_file[new_part_id]->ha_write_row((uchar*) new_data);
     reenable_binlog(thd);
@@ -4355,8 +4427,11 @@ exit:
       bitmap_is_set(table->write_set,
                     table->found_next_number_field->field_index))
   {
-    if (!part_share->auto_inc_initialized)
-      info(HA_STATUS_AUTO);
+    update_next_auto_inc_val();
+    /*
+      The following call is safe as part_share->auto_inc_initialized
+      (tested in the call) is guaranteed to be set for update statements.
+    */
     set_auto_increment_if_higher(table->found_next_number_field);
   }
   DBUG_RETURN(error);
@@ -4643,9 +4718,9 @@ void ha_partition::start_part_bulk_insert(THD *thd, uint part_id)
   DESCRIPTION
     If the estimated number of rows to insert is less than 10 (but not 0)
     the new buffer size is same as original buffer size.
-    In case of first partition of when partition function is monotonic 
+    In case of first partition of when partition function is monotonic
     new buffer size is same as the original buffer size.
-    For rest of the partition total buffer of 10*original_size is divided 
+    For rest of the partition total buffer of 10*original_size is divided
     equally if number of partition is more than 10 other wise each partition
     will be allowed to use original buffer size.
 */
@@ -4683,7 +4758,7 @@ long ha_partition::estimate_read_buffer_size(long original_size)
   If monotonic partitioning function was used
     guess that 50 % of the inserts goes to the first partition
   For all other cases, guess on equal distribution between the partitions
-*/ 
+*/
 ha_rows ha_partition::guess_bulk_insert_rows()
 {
   DBUG_ENTER("guess_bulk_insert_rows");
@@ -4692,7 +4767,7 @@ ha_rows ha_partition::guess_bulk_insert_rows()
     DBUG_RETURN(estimation_rows_to_insert);
 
   /* If first insert/partition and monotonic partition function, guess 50%.  */
-  if (!m_bulk_inserted_rows && 
+  if (!m_bulk_inserted_rows &&
       m_part_func_monotonicity_info != NON_MONOTONIC &&
       m_tot_parts > 1)
     DBUG_RETURN(estimation_rows_to_insert / 2);
@@ -4758,7 +4833,7 @@ int ha_partition::end_bulk_insert()
     >0          Error code
     0           Success
 
-  DESCRIPTION 
+  DESCRIPTION
     rnd_init() is called when the server wants the storage engine to do a
     table scan or when the server wants to access data through rnd_pos.
 
@@ -4794,7 +4869,10 @@ int ha_partition::rnd_init(bool scan)
     */
     if (bitmap_is_overlapping(&m_part_info->full_part_field_set,
                               table->write_set))
+    {
+      DBUG_PRINT("info", ("partition set full bitmap"));
       bitmap_set_all(table->read_set);
+    }
     else
     {
       /*
@@ -4803,6 +4881,7 @@ int ha_partition::rnd_init(bool scan)
         fields of the partition functions are read such that we can
         calculate the partition id to place updated and deleted records.
       */
+      DBUG_PRINT("info", ("partition set part_field bitmap"));
       bitmap_union(table->read_set, &m_part_info->full_part_field_set);
     }
   }
@@ -4811,9 +4890,9 @@ int ha_partition::rnd_init(bool scan)
   DBUG_PRINT("info", ("m_part_info->read_partitions: %p",
                       m_part_info->read_partitions.bitmap));
   part_id= bitmap_get_first_set(&(m_part_info->read_partitions));
-  DBUG_PRINT("info", ("m_part_spec.start_part %d", part_id));
+  DBUG_PRINT("info", ("m_part_spec.start_part: %u", (uint) part_id));
 
-  if (MY_BIT_NONE == part_id)
+  if (part_id == MY_BIT_NONE)
   {
     error= 0;
     goto err1;
@@ -4823,7 +4902,7 @@ int ha_partition::rnd_init(bool scan)
     We have a partition and we are scanning with rnd_next
     so we bump our cache
   */
-  DBUG_PRINT("info", ("rnd_init on partition %d", part_id));
+  DBUG_PRINT("info", ("rnd_init on partition: %u", (uint) part_id));
   if (scan)
   {
     /*
@@ -4832,26 +4911,29 @@ int ha_partition::rnd_init(bool scan)
     */
     rnd_end();
     late_extra_cache(part_id);
-    if ((error= m_file[part_id]->ha_rnd_init(scan)))
-      goto err;
+
+    m_index_scan_type= partition_no_index_scan;
   }
-  else
+
+  for (i= part_id;
+       i < m_tot_parts;
+       i= bitmap_get_next_set(&m_part_info->read_partitions, i))
   {
-    for (i= part_id;
-         i < m_tot_parts;
-         i= bitmap_get_next_set(&m_part_info->read_partitions, i))
-    {
-      if ((error= m_file[i]->ha_rnd_init(scan)))
-        goto err;
-    }
+    if ((error= m_file[i]->ha_rnd_init(scan)))
+      goto err;
   }
+
   m_scan_value= scan;
   m_part_spec.start_part= part_id;
   m_part_spec.end_part= m_tot_parts - 1;
-  DBUG_PRINT("info", ("m_scan_value=%d", m_scan_value));
+  m_rnd_init_and_first= TRUE;
+  DBUG_PRINT("info", ("m_scan_value: %u", m_scan_value));
   DBUG_RETURN(0);
 
 err:
+  if (scan)
+    late_extra_no_cache(part_id);
+
   /* Call rnd_end for all previously inited partitions. */
   for (;
        part_id < i;
@@ -4883,13 +4965,10 @@ int ha_partition::rnd_end()
   switch (m_scan_value) {
   case 2:                                       // Error
     break;
-  case 1:
-    if (NO_CURRENT_PART_ID != m_part_spec.start_part)         // Table scan
-    {
+  case 1:                                       // Table scan
+    if (m_part_spec.start_part != NO_CURRENT_PART_ID)
       late_extra_no_cache(m_part_spec.start_part);
-      m_file[m_part_spec.start_part]->ha_rnd_end();
-    }
-    break;
+    /* fall through */
   case 0:
     uint i;
     for (i= bitmap_get_first_set(&m_part_info->read_partitions);
@@ -4905,6 +4984,7 @@ int ha_partition::rnd_end()
   DBUG_RETURN(0);
 }
 
+
 /*
   read next row during full table scan (scan in random row order)
 
@@ -4929,14 +5009,15 @@ int ha_partition::rnd_end()
 int ha_partition::rnd_next(uchar *buf)
 {
   handler *file;
-  int result= HA_ERR_END_OF_FILE;
+  int result= HA_ERR_END_OF_FILE, error;
   uint part_id= m_part_spec.start_part;
   DBUG_ENTER("ha_partition::rnd_next");
+  DBUG_PRINT("enter", ("partition this: %p", this));
 
   /* upper level will increment this once again at end of call */
   decrement_statistics(&SSV::ha_read_rnd_next_count);
 
-  if (NO_CURRENT_PART_ID == part_id)
+  if (part_id == NO_CURRENT_PART_ID)
   {
     /*
       The original set of partitions to scan was empty and thus we report
@@ -4944,16 +5025,26 @@ int ha_partition::rnd_next(uchar *buf)
     */
     goto end;
   }
-  
+
   DBUG_ASSERT(m_scan_value == 1);
+
+  if (m_rnd_init_and_first)
+  {
+    m_rnd_init_and_first= FALSE;
+    error= handle_pre_scan(FALSE, check_parallel_search());
+    if (m_pre_calling || error)
+      DBUG_RETURN(error);
+  }
+
   file= m_file[part_id];
-  
+
   while (TRUE)
   {
     result= file->ha_rnd_next(buf);
     if (!result)
     {
       m_last_part= part_id;
+      DBUG_PRINT("info", ("partition m_last_part: %u", (uint) m_last_part));
       m_part_spec.start_part= part_id;
       table->status= 0;
       DBUG_RETURN(0);
@@ -4970,10 +5061,6 @@ int ha_partition::rnd_next(uchar *buf)
 
     /* End current partition */
     late_extra_no_cache(part_id);
-    DBUG_PRINT("info", ("rnd_end on partition %d", part_id));
-    if ((result= file->ha_rnd_end()))
-      break;
-    
     /* Shift to next partition */
     part_id= bitmap_get_next_set(&m_part_info->read_partitions, part_id);
     if (part_id >= m_tot_parts)
@@ -4982,11 +5069,9 @@ int ha_partition::rnd_next(uchar *buf)
       break;
     }
     m_last_part= part_id;
+    DBUG_PRINT("info", ("partition m_last_part: %u", (uint) m_last_part));
     m_part_spec.start_part= part_id;
     file= m_file[part_id];
-    DBUG_PRINT("info", ("rnd_init on partition %d", part_id));
-    if ((result= file->ha_rnd_init(1)))
-      break;
     late_extra_cache(part_id);
   }
 
@@ -5142,6 +5227,7 @@ bool ha_partition::init_record_priority_queue()
   {
     uint alloc_len;
     uint used_parts= bitmap_bits_set(&m_part_info->read_partitions);
+    DBUG_ASSERT(used_parts > 0);
     /* Allocate record buffer for each used partition. */
     m_priority_queue_rec_len= m_rec_length + PARTITION_BYTES_IN_POS;
     if (!m_using_extended_keys)
@@ -5171,20 +5257,15 @@ bool ha_partition::init_record_priority_queue()
       ptr+= m_priority_queue_rec_len;
     }
     m_start_key.key= (const uchar*)ptr;
-    
+
     /* Initialize priority queue, initialized to reading forward. */
     int (*cmp_func)(void *, uchar *, uchar *);
-    void *cmp_arg;
-    if (!m_using_extended_keys)
-    {
+    void *cmp_arg= (void*) this;
+    if (!m_using_extended_keys && !(table_flags() & HA_CMP_REF_IS_EXPENSIVE))
       cmp_func= cmp_key_rowid_part_id;
-      cmp_arg=  (void*)this;
-    }
     else
-    {
       cmp_func= cmp_key_part_id;
-      cmp_arg= (void*)m_curr_key_info;
-    }
+    DBUG_PRINT("info", ("partition queue_init(1) used_parts: %u", used_parts));
     if (init_queue(&m_queue, used_parts, 0, 0, cmp_func, cmp_arg, 0, 0))
     {
       my_free(m_ordered_rec_buffer);
@@ -5235,8 +5316,8 @@ int ha_partition::index_init(uint inx, bool sorted)
   int error= 0;
   uint i;
   DBUG_ENTER("ha_partition::index_init");
+  DBUG_PRINT("enter", ("partition this: %p  inx: %u  sorted: %u", this, inx, sorted));
 
-  DBUG_PRINT("info", ("inx %u sorted %u", inx, sorted));
   active_index= inx;
   m_part_spec.start_part= NO_CURRENT_PART_ID;
   m_start_key.length= 0;
@@ -5271,11 +5352,14 @@ int ha_partition::index_init(uint inx, bool sorted)
     But this is required for operations that may need to change data only.
   */
   if (get_lock_type() == F_WRLCK)
+  {
+    DBUG_PRINT("info", ("partition set part_field bitmap"));
     bitmap_union(table->read_set, &m_part_info->full_part_field_set);
+  }
   if (sorted)
   {
     /*
-      An ordered scan is requested. We must make sure all fields of the 
+      An ordered scan is requested. We must make sure all fields of the
       used index are in the read set, as partitioning requires them for
       sorting (see ha_partition::handle_ordered_index_scan).
 
@@ -5342,19 +5426,21 @@ err:
 int ha_partition::index_end()
 {
   int error= 0;
-  uint i;
+  handler **file;
   DBUG_ENTER("ha_partition::index_end");
 
   active_index= MAX_KEY;
   m_part_spec.start_part= NO_CURRENT_PART_ID;
-  for (i= bitmap_get_first_set(&m_part_info->read_partitions);
-       i < m_tot_parts;
-       i= bitmap_get_next_set(&m_part_info->read_partitions, i))
+  file= m_file;
+  do
   {
-    int tmp;
-    if ((tmp= m_file[i]->ha_index_end()))
-      error= tmp;
-  }
+    if ((*file)->inited == INDEX)
+    {
+      int tmp;
+      if ((tmp= (*file)->ha_index_end()))
+        error= tmp;
+    }
+  } while (*(++file));
   destroy_record_priority_queue();
   DBUG_RETURN(error);
 }
@@ -5403,34 +5489,26 @@ int ha_partition::index_read_map(uchar *buf, const uchar *key,
 /* Compare two part_no partition numbers */
 static int cmp_part_ids(uchar *ref1, uchar *ref2)
 {
-  /* The following was taken from ha_partition::cmp_ref */
-  my_ptrdiff_t diff1= ref2[1] - ref1[1];
-  my_ptrdiff_t diff2= ref2[0] - ref1[0];
-  if (!diff1 && !diff2)
-    return 0;
-
-  if (diff1 > 0)
-    return(-1);
-
-  if (diff1 < 0)
-    return(+1);
-
-  if (diff2 > 0)
-    return(-1);
-
-  return(+1);
+  uint32 diff2= uint2korr(ref2);
+  uint32 diff1= uint2korr(ref1);
+  if (diff2 > diff1)
+    return -1;
+  if (diff2 < diff1)
+    return 1;
+  return 0;
 }
 
 
 /*
   @brief
-    Provide ordering by (key_value, part_no). 
+    Provide ordering by (key_value, part_no).
 */
 
-extern "C" int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2)
+extern "C" int cmp_key_part_id(void *ptr, uchar *ref1, uchar *ref2)
 {
+  ha_partition *file= (ha_partition*)ptr;
   int res;
-  if ((res= key_rec_cmp(key_p, ref1 + PARTITION_BYTES_IN_POS, 
+  if ((res= key_rec_cmp(file->m_curr_key_info, ref1 + PARTITION_BYTES_IN_POS,
                         ref2 + PARTITION_BYTES_IN_POS)))
   {
     return res;
@@ -5440,7 +5518,7 @@ extern "C" int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2)
 
 /*
   @brief
-    Provide ordering by (key_value, underying_table_rowid, part_no). 
+    Provide ordering by (key_value, underying_table_rowid, part_no).
 */
 extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2)
 {
@@ -5465,26 +5543,26 @@ extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2)
   Common routine for a number of index_read variants
 
   @param buf             Buffer where the record should be returned.
-  @param have_start_key  TRUE <=> the left endpoint is available, i.e. 
+  @param have_start_key  TRUE <=> the left endpoint is available, i.e.
                          we're in index_read call or in read_range_first
                          call and the range has left endpoint.
                          FALSE <=> there is no left endpoint (we're in
                          read_range_first() call and the range has no left
                          endpoint).
- 
+
   @return Operation status
-    @retval 0      OK 
+    @retval 0      OK
     @retval HA_ERR_END_OF_FILE   Whole index scanned, without finding the record.
     @retval HA_ERR_KEY_NOT_FOUND Record not found, but index cursor positioned.
     @retval other  error code.
 
   @details
-    Start scanning the range (when invoked from read_range_first()) or doing 
+    Start scanning the range (when invoked from read_range_first()) or doing
     an index lookup (when invoked from index_read_XXX):
      - If possible, perform partition selection
      - Find the set of partitions we're going to use
      - Depending on whether we need ordering:
-        NO:  Get the first record from first used partition (see 
+        NO:  Get the first record from first used partition (see
              handle_unordered_scan_next_partition)
         YES: Fill the priority queue and get the record that is the first in
              the ordering
@@ -5502,7 +5580,7 @@ int ha_partition::common_index_read(uchar *buf, bool have_start_key)
 
   if (have_start_key)
   {
-    m_start_key.length= key_len= calculate_key_len(table, active_index, 
+    m_start_key.length= key_len= calculate_key_len(table, active_index,
                                                    m_start_key.key,
                                                    m_start_key.keypart_map);
     DBUG_PRINT("info", ("have_start_key map %lu find_flag %u len %u",
@@ -5514,7 +5592,7 @@ int ha_partition::common_index_read(uchar *buf, bool have_start_key)
     DBUG_RETURN(error);
   }
 
-  if (have_start_key && 
+  if (have_start_key &&
       (m_start_key.flag == HA_READ_PREFIX_LAST ||
        m_start_key.flag == HA_READ_PREFIX_LAST_OR_PREV ||
        m_start_key.flag == HA_READ_BEFORE_KEY))
@@ -5534,7 +5612,9 @@ int ha_partition::common_index_read(uchar *buf, bool have_start_key)
       The unordered index scan will use the partition set created.
     */
     DBUG_PRINT("info", ("doing unordered scan"));
-    error= handle_unordered_scan_next_partition(buf);
+    error= handle_pre_scan(FALSE, FALSE);
+    if (!error)
+      error= handle_unordered_scan_next_partition(buf);
   }
   else
   {
@@ -5582,7 +5662,7 @@ int ha_partition::index_first(uchar * buf)
 
 /*
   Start an index scan from rightmost record and return first record
-  
+
   SYNOPSIS
     index_last()
     buf                 Read row in MySQL Row Format
@@ -5615,7 +5695,7 @@ int ha_partition::index_last(uchar * buf)
 
   SYNOPSIS
     ha_partition::common_first_last()
-  
+
   see index_first for rest
 */
 
@@ -5627,7 +5707,11 @@ int ha_partition::common_first_last(uchar *buf)
     return error;
   if (!m_ordered_scan_ongoing &&
       m_index_scan_type != partition_index_last)
-    return handle_unordered_scan_next_partition(buf);
+  {
+    if ((error= handle_pre_scan(FALSE, check_parallel_search())))
+      return error;
+   return handle_unordered_scan_next_partition(buf);
+  }
   return handle_ordered_index_scan(buf, FALSE);
 }
 
@@ -5655,7 +5739,7 @@ int ha_partition::index_read_idx_map(uchar *buf, uint index,
 
     get_partition_set(table, buf, index, &m_start_key, &m_part_spec);
 
-    /* 
+    /*
       We have either found exactly 1 partition
       (in which case start_part == end_part)
       or no matching partitions (start_part > end_part)
@@ -5720,7 +5804,8 @@ int ha_partition::index_next(uchar * buf)
     and if direction changes, we must step back those partitions in
     the record queue so we don't return a value from the wrong direction.
   */
-  DBUG_ASSERT(m_index_scan_type != partition_index_last);
+  if (m_index_scan_type == partition_index_last)
+    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
   if (!m_ordered_scan_ongoing)
   {
     DBUG_RETURN(handle_unordered_next(buf, FALSE));
@@ -5753,7 +5838,8 @@ int ha_partition::index_next_same(uchar *buf, const uchar *key, uint keylen)
   decrement_statistics(&SSV::ha_read_next_count);
 
   DBUG_ASSERT(keylen == m_start_key.length);
-  DBUG_ASSERT(m_index_scan_type != partition_index_last);
+  if (m_index_scan_type == partition_index_last)
+    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
   if (!m_ordered_scan_ongoing)
     DBUG_RETURN(handle_unordered_next(buf, TRUE));
   DBUG_RETURN(handle_ordered_next(buf, TRUE));
@@ -5797,7 +5883,8 @@ int ha_partition::index_prev(uchar * buf)
   decrement_statistics(&SSV::ha_read_prev_count);
 
   /* TODO: read comment in index_next */
-  DBUG_ASSERT(m_index_scan_type != partition_index_first);
+  if (m_index_scan_type == partition_index_first)
+    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
   DBUG_RETURN(handle_ordered_prev(buf));
 }
 
@@ -5868,6 +5955,980 @@ int ha_partition::read_range_next()
   DBUG_RETURN(handle_unordered_next(table->record[0], eq_range));
 }
 
+/**
+   Create a copy of all keys used by multi_range_read()
+
+   @retval 0 ok
+   @retval HA_ERR_END_OF_FILE no keys in range
+   @retval other value: error
+
+   TODO to save memory:
+   - If (mrr_mode & HA_MRR_MATERIALIZED_KEYS) is set then the keys data is
+     stable and we don't have to copy the keys, only store a pointer to the
+     key.
+   - When allocating key data, store things in a MEM_ROOT buffer instead of
+     a malloc() per key. This will simplify and speed up the current code
+     and use less memory.
+*/
+
+int ha_partition::multi_range_key_create_key(RANGE_SEQ_IF *seq,
+                                             range_seq_t seq_it)
+{
+  uint i, length;
+  key_range *start_key, *end_key;
+  KEY_MULTI_RANGE *range;
+  DBUG_ENTER("ha_partition::multi_range_key_create_key");
+
+  bitmap_clear_all(&m_mrr_used_partitions);
+  m_mrr_range_length= 0;
+  bzero(m_part_mrr_range_length,
+        sizeof(*m_part_mrr_range_length) * m_tot_parts);
+  if (!m_mrr_range_first)
+  {
+    if (!(m_mrr_range_first= (PARTITION_KEY_MULTI_RANGE *)
+          my_multi_malloc(MYF(MY_WME),
+                          &m_mrr_range_current,
+                          sizeof(PARTITION_KEY_MULTI_RANGE),
+                          NullS)))
+      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+    m_mrr_range_first->id= 1;
+    m_mrr_range_first->key[0]= NULL;
+    m_mrr_range_first->key[1]= NULL;
+    m_mrr_range_first->next= NULL;
+  }
+  else
+    m_mrr_range_current= m_mrr_range_first;
+
+  for (i= 0; i < m_tot_parts; i++)
+  {
+    if (!m_part_mrr_range_first[i])
+    {
+      if (!(m_part_mrr_range_first[i]= (PARTITION_PART_KEY_MULTI_RANGE *)
+            my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+                            &m_part_mrr_range_current[i],
+                            sizeof(PARTITION_PART_KEY_MULTI_RANGE),
+                            NullS)))
+        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+    }
+    else
+    {
+      m_part_mrr_range_current[i]= m_part_mrr_range_first[i];
+      m_part_mrr_range_current[i]->partition_key_multi_range= NULL;
+    }
+  }
+  m_mrr_range_current->key_multi_range.start_key.key= NULL;
+  m_mrr_range_current->key_multi_range.end_key.key= NULL;
+
+  while (!seq->next(seq_it, &m_mrr_range_current->key_multi_range))
+  {
+    m_mrr_range_length++;
+    range= &m_mrr_range_current->key_multi_range;
+
+    /* Copy start key */
+    start_key= &range->start_key;
+    DBUG_PRINT("info",("partition range->range_flag: %u", range->range_flag));
+    DBUG_PRINT("info",("partition start_key->key: %p", start_key->key));
+    DBUG_PRINT("info",("partition start_key->length: %u", start_key->length));
+    DBUG_PRINT("info",("partition start_key->keypart_map: %lu",
+                       start_key->keypart_map));
+    DBUG_PRINT("info",("partition start_key->flag: %u", start_key->flag));
+
+    if (start_key->key)
+    {
+      length= start_key->length;
+      if (!m_mrr_range_current->key[0] ||
+          m_mrr_range_current->length[0] < length)
+      {
+        if (m_mrr_range_current->key[0])
+          my_free(m_mrr_range_current->key[0]);
+        if (!(m_mrr_range_current->key[0]=
+              (uchar *) my_malloc(length, MYF(MY_WME))))
+          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+        m_mrr_range_current->length[0]= length;
+      }
+      memcpy(m_mrr_range_current->key[0], start_key->key, length);
+      start_key->key= m_mrr_range_current->key[0];
+    }
+
+    /* Copy end key */
+    end_key= &range->end_key;
+    DBUG_PRINT("info",("partition end_key->key: %p", end_key->key));
+    DBUG_PRINT("info",("partition end_key->length: %u", end_key->length));
+    DBUG_PRINT("info",("partition end_key->keypart_map: %lu",
+                       end_key->keypart_map));
+    DBUG_PRINT("info",("partition end_key->flag: %u", end_key->flag));
+    if (end_key->key)
+    {
+      length= end_key->length;
+      if (!m_mrr_range_current->key[1] ||
+          m_mrr_range_current->length[1] < length)
+      {
+        if (m_mrr_range_current->key[1])
+          my_free(m_mrr_range_current->key[1]);
+        if (!(m_mrr_range_current->key[1]=
+              (uchar *) my_malloc(length, MYF(MY_WME))))
+          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+        m_mrr_range_current->length[1]= length;
+      }
+      memcpy(m_mrr_range_current->key[1], end_key->key, length);
+      end_key->key= m_mrr_range_current->key[1];
+    }
+
+    m_mrr_range_current->ptr= m_mrr_range_current->key_multi_range.ptr;
+    m_mrr_range_current->key_multi_range.ptr= m_mrr_range_current;
+
+    if (start_key->key && (start_key->flag & HA_READ_KEY_EXACT))
+      get_partition_set(table, table->record[0], active_index,
+                        start_key, &m_part_spec);
+    else
+    {
+      m_part_spec.start_part= 0;
+      m_part_spec.end_part= m_tot_parts - 1;
+    }
+
+    /* Copy key to those partitions that needs it */
+    for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+    {
+      if (bitmap_is_set(&(m_part_info->read_partitions), i))
+      {
+        bitmap_set_bit(&m_mrr_used_partitions, i);
+        m_part_mrr_range_length[i]++;
+        m_part_mrr_range_current[i]->partition_key_multi_range=
+          m_mrr_range_current;
+
+        if (!m_part_mrr_range_current[i]->next)
+        {
+          PARTITION_PART_KEY_MULTI_RANGE *tmp_part_mrr_range;
+          if (!(tmp_part_mrr_range= (PARTITION_PART_KEY_MULTI_RANGE *)
+                my_malloc(sizeof(PARTITION_PART_KEY_MULTI_RANGE),
+                          MYF(MY_WME | MY_ZEROFILL))))
+            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+          m_part_mrr_range_current[i]->next= tmp_part_mrr_range;
+          m_part_mrr_range_current[i]= tmp_part_mrr_range;
+        }
+        else
+        {
+          m_part_mrr_range_current[i]= m_part_mrr_range_current[i]->next;
+          m_part_mrr_range_current[i]->partition_key_multi_range= NULL;
+        }
+      }
+    }
+
+    if (!m_mrr_range_current->next)
+    {
+      /* Add end of range sentinel */
+      PARTITION_KEY_MULTI_RANGE *tmp_mrr_range;
+      if (!(tmp_mrr_range= (PARTITION_KEY_MULTI_RANGE *)
+            my_malloc(sizeof(PARTITION_KEY_MULTI_RANGE), MYF(MY_WME))))
+        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+      tmp_mrr_range->id= m_mrr_range_current->id + 1;
+      tmp_mrr_range->key[0]= NULL;
+      tmp_mrr_range->key[1]= NULL;
+      tmp_mrr_range->next= NULL;
+      m_mrr_range_current->next= tmp_mrr_range;
+    }
+    m_mrr_range_current= m_mrr_range_current->next;
+  }
+
+  if (!m_mrr_range_length)
+  {
+    DBUG_PRINT("Warning",("No keys to use for mrr"));
+    DBUG_RETURN(HA_ERR_END_OF_FILE);
+  }
+
+  /* set start and end part */
+  m_part_spec.start_part= bitmap_get_first_set(&m_mrr_used_partitions);
+
+  for (i= m_tot_parts; i-- > 0;)
+  {
+    if (bitmap_is_set(&m_mrr_used_partitions, i))
+    {
+      m_part_spec.end_part= i;
+      break;
+    }
+  }
+  for (i= 0; i < m_tot_parts; i++)
+  {
+    m_partition_part_key_multi_range_hld[i].partition= this;
+    m_partition_part_key_multi_range_hld[i].part_id= i;
+    m_partition_part_key_multi_range_hld[i].partition_part_key_multi_range=
+      m_part_mrr_range_first[i];
+  }
+  DBUG_PRINT("return",("OK"));
+  DBUG_RETURN(0);
+}
+
+
+static void partition_multi_range_key_get_key_info(void *init_params,
+                                                   uint *length,
+                                                   key_part_map *map)
+{
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *hld=
+    (PARTITION_PART_KEY_MULTI_RANGE_HLD *)init_params;
+  ha_partition *partition= hld->partition;
+  key_range *start_key= (&partition->m_mrr_range_first->
+                         key_multi_range.start_key);
+  DBUG_ENTER("partition_multi_range_key_get_key_info");
+  *length= start_key->length;
+  *map= start_key->keypart_map;
+  DBUG_VOID_RETURN;
+}
+
+
+static range_seq_t partition_multi_range_key_init(void *init_params,
+                                                  uint n_ranges,
+                                                  uint flags)
+{
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *hld=
+    (PARTITION_PART_KEY_MULTI_RANGE_HLD *)init_params;
+  ha_partition *partition= hld->partition;
+  uint i= hld->part_id;
+  DBUG_ENTER("partition_multi_range_key_init");
+  partition->m_mrr_range_init_flags= flags;
+  hld->partition_part_key_multi_range= partition->m_part_mrr_range_first[i];
+  DBUG_RETURN(init_params);
+}
+
+
+static bool partition_multi_range_key_next(range_seq_t seq,
+                                           KEY_MULTI_RANGE *range)
+{
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *hld=
+    (PARTITION_PART_KEY_MULTI_RANGE_HLD *)seq;
+  PARTITION_KEY_MULTI_RANGE *partition_key_multi_range=
+    hld->partition_part_key_multi_range->partition_key_multi_range;
+  DBUG_ENTER("partition_multi_range_key_next");
+  if (!partition_key_multi_range)
+    DBUG_RETURN(TRUE);
+  *range= partition_key_multi_range->key_multi_range;
+  hld->partition_part_key_multi_range=
+    hld->partition_part_key_multi_range->next;
+  DBUG_RETURN(FALSE);
+}
+
+
+static bool partition_multi_range_key_skip_record(range_seq_t seq,
+                                                  range_id_t range_info,
+                                                  uchar *rowid)
+{
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *hld=
+    (PARTITION_PART_KEY_MULTI_RANGE_HLD *)seq;
+  DBUG_ENTER("partition_multi_range_key_skip_record");
+  DBUG_RETURN(hld->partition->m_seq_if->skip_record(hld->partition->m_seq,
+                                                    range_info, rowid));
+}
+
+
+static bool partition_multi_range_key_skip_index_tuple(range_seq_t seq,
+                                                       range_id_t range_info)
+{
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *hld=
+    (PARTITION_PART_KEY_MULTI_RANGE_HLD *)seq;
+  DBUG_ENTER("partition_multi_range_key_skip_index_tuple");
+  DBUG_RETURN(hld->partition->m_seq_if->skip_index_tuple(hld->partition->m_seq,
+                                                         range_info));
+}
+
+ha_rows ha_partition::multi_range_read_info_const(uint keyno,
+                                                  RANGE_SEQ_IF *seq,
+                                                  void *seq_init_param,
+                                                  uint n_ranges, uint *bufsz,
+                                                  uint *mrr_mode,
+                                                  Cost_estimate *cost)
+{
+  int error;
+  uint i;
+  handler **file;
+  ha_rows rows= 0;
+  uint ret_mrr_mode= 0;
+  range_seq_t seq_it;
+  DBUG_ENTER("ha_partition::multi_range_read_info_const");
+  DBUG_PRINT("enter", ("partition this: %p", this));
+
+  m_mrr_new_full_buffer_size= 0;
+  seq_it= seq->init(seq_init_param, n_ranges, *mrr_mode);
+  if ((error= multi_range_key_create_key(seq, seq_it)))
+  {
+    if (error == HA_ERR_END_OF_FILE)            // No keys in range
+    {
+      rows= 0;
+      goto calc_cost;
+    }
+    /*
+      This error means that we can't do multi_range_read for the moment
+      (probably running out of memory) and we need to fallback to
+      normal reads
+    */
+    DBUG_RETURN(HA_POS_ERROR);
+  }
+  m_part_seq_if.get_key_info=
+    seq->get_key_info ? partition_multi_range_key_get_key_info : NULL;
+  m_part_seq_if.init= partition_multi_range_key_init;
+  m_part_seq_if.next= partition_multi_range_key_next;
+  m_part_seq_if.skip_record= (seq->skip_record ?
+                              partition_multi_range_key_skip_record : NULL);
+  m_part_seq_if.skip_index_tuple= (seq->skip_index_tuple ?
+                                   partition_multi_range_key_skip_index_tuple :
+                                   NULL);
+  file= m_file;
+  do
+  {
+    i= (uint)(file - m_file);
+    DBUG_PRINT("info",("partition part_id: %u", i));
+    if (bitmap_is_set(&m_mrr_used_partitions, i))
+    {
+      ha_rows tmp_rows;
+      uint tmp_mrr_mode;
+      m_mrr_buffer_size[i]= 0;
+      tmp_mrr_mode= *mrr_mode;
+      tmp_rows= (*file)->
+        multi_range_read_info_const(keyno, &m_part_seq_if,
+                                    &m_partition_part_key_multi_range_hld[i],
+                                    m_part_mrr_range_length[i],
+                                    &m_mrr_buffer_size[i],
+                                    &tmp_mrr_mode, cost);
+      if (tmp_rows == HA_POS_ERROR)
+        DBUG_RETURN(HA_POS_ERROR);
+      rows+= tmp_rows;
+      ret_mrr_mode|= tmp_mrr_mode;
+      m_mrr_new_full_buffer_size+= m_mrr_buffer_size[i];
+    }
+  } while (*(++file));
+  *mrr_mode= ret_mrr_mode;
+
+calc_cost:
+  cost->reset();
+  cost->avg_io_cost= 1;
+  if ((*mrr_mode & HA_MRR_INDEX_ONLY) && rows > 2)
+    cost->io_count= keyread_time(keyno, n_ranges, (uint) rows);
+  else
+    cost->io_count= read_time(keyno, n_ranges, rows);
+  cost->cpu_cost= (double) rows / TIME_FOR_COMPARE + 0.01;
+  DBUG_RETURN(rows);
+}
+
+
+ha_rows ha_partition::multi_range_read_info(uint keyno, uint n_ranges,
+                                            uint keys,
+                                            uint key_parts, uint *bufsz,
+                                            uint *mrr_mode,
+                                            Cost_estimate *cost)
+{
+  uint i;
+  handler **file;
+  ha_rows rows;
+  DBUG_ENTER("ha_partition::multi_range_read_info");
+  DBUG_PRINT("enter", ("partition this: %p", this));
+
+  m_mrr_new_full_buffer_size= 0;
+  file= m_file;
+  do
+  {
+    i= (uint)(file - m_file);
+    if (bitmap_is_set(&(m_part_info->read_partitions), (i)))
+    {
+      m_mrr_buffer_size[i]= 0;
+      if ((rows= (*file)->multi_range_read_info(keyno, n_ranges, keys,
+                                                key_parts,
+                                                &m_mrr_buffer_size[i],
+                                                mrr_mode, cost)))
+        DBUG_RETURN(rows);
+      m_mrr_new_full_buffer_size+= m_mrr_buffer_size[i];
+    }
+  } while (*(++file));
+
+  cost->reset();
+  cost->avg_io_cost= 1;
+  if (*mrr_mode & HA_MRR_INDEX_ONLY)
+    cost->io_count= keyread_time(keyno, n_ranges, (uint) rows);
+  else
+    cost->io_count= read_time(keyno, n_ranges, rows);
+  DBUG_RETURN(0);
+}
+
+
+int ha_partition::multi_range_read_init(RANGE_SEQ_IF *seq,
+                                        void *seq_init_param,
+                                        uint n_ranges, uint mrr_mode,
+                                        HANDLER_BUFFER *buf)
+{
+  int error;
+  uint i;
+  handler **file;
+  uchar *tmp_buffer;
+  DBUG_ENTER("ha_partition::multi_range_read_init");
+  DBUG_PRINT("enter", ("partition this: %p", this));
+
+  m_seq_if= seq;
+  m_seq= seq->init(seq_init_param, n_ranges, mrr_mode);
+  if ((error= multi_range_key_create_key(seq, m_seq)))
+    DBUG_RETURN(0);
+
+  m_part_seq_if.get_key_info= (seq->get_key_info ?
+                               partition_multi_range_key_get_key_info :
+                               NULL);
+  m_part_seq_if.init= partition_multi_range_key_init;
+  m_part_seq_if.next= partition_multi_range_key_next;
+  m_part_seq_if.skip_record= (seq->skip_record ?
+                              partition_multi_range_key_skip_record :
+                              NULL);
+  m_part_seq_if.skip_index_tuple= (seq->skip_index_tuple ?
+                                   partition_multi_range_key_skip_index_tuple :
+                                   NULL);
+
+  /* m_mrr_new_full_buffer_size was calculated in multi_range_read_info */
+  if (m_mrr_full_buffer_size < m_mrr_new_full_buffer_size)
+  {
+    if (m_mrr_full_buffer)
+      my_free(m_mrr_full_buffer);
+    if (!(m_mrr_full_buffer=
+          (uchar *) my_malloc(m_mrr_new_full_buffer_size, MYF(MY_WME))))
+    {
+      m_mrr_full_buffer_size= 0;
+      error= HA_ERR_OUT_OF_MEM;
+      goto error;
+    }
+    m_mrr_full_buffer_size= m_mrr_new_full_buffer_size;
+  }
+
+  tmp_buffer= m_mrr_full_buffer;
+  file= m_file;
+  do
+  {
+    i= (uint)(file - m_file);
+    DBUG_PRINT("info",("partition part_id: %u", i));
+    if (bitmap_is_set(&m_mrr_used_partitions, i))
+    {
+      if (m_mrr_new_full_buffer_size)
+      {
+        if (m_mrr_buffer_size[i])
+        {
+          m_mrr_buffer[i].buffer= tmp_buffer;
+          m_mrr_buffer[i].end_of_used_area= tmp_buffer;
+          tmp_buffer+= m_mrr_buffer_size[i];
+          m_mrr_buffer[i].buffer_end= tmp_buffer;
+        }
+      }
+      else
+        m_mrr_buffer[i]= *buf;
+
+      if ((error= (*file)->
+           multi_range_read_init(&m_part_seq_if,
+                                 &m_partition_part_key_multi_range_hld[i],
+                                 m_part_mrr_range_length[i],
+                                 mrr_mode,
+                                 &m_mrr_buffer[i])))
+        goto error;
+      m_stock_range_seq[i]= 0;
+    }
+  } while (*(++file));
+
+  m_multi_range_read_first= TRUE;
+  m_mrr_range_current= m_mrr_range_first;
+  m_index_scan_type= partition_read_multi_range;
+  m_mrr_mode= mrr_mode;
+  m_mrr_n_ranges= n_ranges;
+  DBUG_RETURN(0);
+
+error:
+  DBUG_RETURN(error);
+}
+
+
+int ha_partition::multi_range_read_next(range_id_t *range_info)
+{
+  int error;
+  DBUG_ENTER("ha_partition::multi_range_read_next");
+  DBUG_PRINT("enter", ("partition this: %p  partition m_mrr_mode: %u",
+                       this, m_mrr_mode));
+
+  if ((m_mrr_mode & HA_MRR_SORTED))
+  {
+    if (m_multi_range_read_first)
+    {
+      if ((error= handle_ordered_index_scan(table->record[0], FALSE)))
+        DBUG_RETURN(error);
+      if (!m_pre_calling)
+        m_multi_range_read_first= FALSE;
+    }
+    else if ((error= handle_ordered_next(table->record[0], eq_range)))
+      DBUG_RETURN(error);
+    *range_info= m_mrr_range_current->ptr;
+  }
+  else
+  {
+    if (m_multi_range_read_first)
+    {
+      if ((error= handle_unordered_scan_next_partition(table->record[0])))
+        DBUG_RETURN(error);
+      if (!m_pre_calling)
+        m_multi_range_read_first= FALSE;
+    }
+    else if ((error= handle_unordered_next(table->record[0], FALSE)))
+      DBUG_RETURN(error);
+
+    *range_info=
+      ((PARTITION_KEY_MULTI_RANGE *) m_range_info[m_last_part])->ptr;
+  }
+  DBUG_RETURN(0);
+}
+
+
+int ha_partition::multi_range_read_explain_info(uint mrr_mode, char *str,
+                                                size_t size)
+{
+  DBUG_ENTER("ha_partition::multi_range_read_explain_info");
+  DBUG_RETURN(m_file[0]->multi_range_read_explain_info(mrr_mode, str, size));
+}
+
+
+/**
+  Find and retrieve the Full Text Search relevance ranking for a search string
+  in a full text index.
+
+  @param  handler           Full Text Search handler
+  @param  record            Search string
+  @param  length            Length of the search string
+
+  @retval                   Relevance value
+*/
+
+float partition_ft_find_relevance(FT_INFO *handler,
+                                  uchar *record, uint length)
+{
+  st_partition_ft_info *info= (st_partition_ft_info *)handler;
+  uint m_last_part= ((ha_partition*) info->file)->last_part();
+  FT_INFO *m_handler= info->part_ft_info[m_last_part];
+  DBUG_ENTER("partition_ft_find_relevance");
+  if (!m_handler)
+    DBUG_RETURN((float)-1.0);
+  DBUG_RETURN(m_handler->please->find_relevance(m_handler, record, length));
+}
+
+
+/**
+  Retrieve the Full Text Search relevance ranking for the current
+  full text search.
+
+  @param  handler           Full Text Search handler
+
+  @retval                   Relevance value
+*/
+
+float partition_ft_get_relevance(FT_INFO *handler)
+{
+  st_partition_ft_info *info= (st_partition_ft_info *)handler;
+  uint m_last_part= ((ha_partition*) info->file)->last_part();
+  FT_INFO *m_handler= info->part_ft_info[m_last_part];
+  DBUG_ENTER("partition_ft_get_relevance");
+  if (!m_handler)
+    DBUG_RETURN((float)-1.0);
+  DBUG_RETURN(m_handler->please->get_relevance(m_handler));
+}
+
+
+/**
+  Free the memory for a full text search handler.
+
+  @param  handler           Full Text Search handler
+*/
+
+void partition_ft_close_search(FT_INFO *handler)
+{
+  st_partition_ft_info *info= (st_partition_ft_info *)handler;
+  info->file->ft_close_search(handler);
+}
+
+
+/**
+  Free the memory for a full text search handler.
+
+  @param  handler           Full Text Search handler
+*/
+
+void ha_partition::ft_close_search(FT_INFO *handler)
+{
+  uint i;
+  st_partition_ft_info *info= (st_partition_ft_info *)handler;
+  DBUG_ENTER("ha_partition::ft_close_search");
+
+  for (i= 0; i < m_tot_parts; i++)
+  {
+    FT_INFO *m_handler= info->part_ft_info[i];
+    DBUG_ASSERT(!m_handler ||
+                (m_handler->please && m_handler->please->close_search));
+    if (m_handler &&
+        m_handler->please &&
+        m_handler->please->close_search)
+      m_handler->please->close_search(m_handler);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/* Partition Full Text search function table */
+_ft_vft partition_ft_vft =
+{
+  NULL, // partition_ft_read_next
+  partition_ft_find_relevance,
+  partition_ft_close_search,
+  partition_ft_get_relevance,
+  NULL  // partition_ft_reinit_search
+};
+
+
+/**
+  Initialize a full text search.
+*/
+
+int ha_partition::ft_init()
+{
+  int error;
+  uint i= 0;
+  uint32 part_id;
+  DBUG_ENTER("ha_partition::ft_init");
+  DBUG_PRINT("info", ("partition this: %p", this));
+
+  /*
+    For operations that may need to change data, we may need to extend
+    read_set.
+  */
+  if (get_lock_type() == F_WRLCK)
+  {
+    /*
+      If write_set contains any of the fields used in partition and
+      subpartition expression, we need to set all bits in read_set because
+      the row may need to be inserted in a different [sub]partition. In
+      other words update_row() can be converted into write_row(), which
+      requires a complete record.
+    */
+    if (bitmap_is_overlapping(&m_part_info->full_part_field_set,
+                              table->write_set))
+      bitmap_set_all(table->read_set);
+    else
+    {
+      /*
+        Some handlers only read fields as specified by the bitmap for the
+        read set. For partitioned handlers we always require that the
+        fields of the partition functions are read such that we can
+        calculate the partition id to place updated and deleted records.
+      */
+      bitmap_union(table->read_set, &m_part_info->full_part_field_set);
+    }
+  }
+
+  /* Now we see what the index of our first important partition is */
+  DBUG_PRINT("info", ("m_part_info->read_partitions: %p",
+             (void *) m_part_info->read_partitions.bitmap));
+  part_id= bitmap_get_first_set(&(m_part_info->read_partitions));
+  DBUG_PRINT("info", ("m_part_spec.start_part %u", (uint) part_id));
+
+  if (part_id == MY_BIT_NONE)
+  {
+    error= 0;
+    goto err1;
+  }
+
+  DBUG_PRINT("info", ("ft_init on partition %u", (uint) part_id));
+  /*
+    ft_end() is needed for partitioning to reset internal data if scan
+    is already in use
+  */
+  if (m_pre_calling)
+  {
+    if ((error= pre_ft_end()))
+      goto err1;
+  }
+  else
+    ft_end();
+  m_index_scan_type= partition_ft_read;
+  for (i= part_id; i < m_tot_parts; i++)
+  {
+    if (bitmap_is_set(&(m_part_info->read_partitions), i))
+    {
+      error= m_pre_calling ? m_file[i]->pre_ft_init() : m_file[i]->ft_init();
+      if (error)
+        goto err2;
+    }
+  }
+  m_scan_value= 1;
+  m_part_spec.start_part= part_id;
+  m_part_spec.end_part= m_tot_parts - 1;
+  m_ft_init_and_first= TRUE;
+  DBUG_PRINT("info", ("m_scan_value: %u", m_scan_value));
+  DBUG_RETURN(0);
+
+err2:
+  late_extra_no_cache(part_id);
+  while ((int)--i >= (int)part_id)
+  {
+    if (bitmap_is_set(&(m_part_info->read_partitions), i))
+    {
+      if (m_pre_calling)
+        m_file[i]->pre_ft_end();
+      else
+        m_file[i]->ft_end();
+    }
+  }
+err1:
+  m_scan_value= 2;
+  m_part_spec.start_part= NO_CURRENT_PART_ID;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Initialize a full text search during a bulk access request.
+*/
+
+int ha_partition::pre_ft_init()
+{
+  bool save_m_pre_calling;
+  int error;
+  DBUG_ENTER("ha_partition::pre_ft_init");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  error= ft_init();
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Terminate a full text search.
+*/
+
+void ha_partition::ft_end()
+{
+  handler **file;
+  DBUG_ENTER("ha_partition::ft_end");
+  DBUG_PRINT("info", ("partition this: %p", this));
+
+  switch (m_scan_value) {
+  case 2:                                       // Error
+    break;
+  case 1:                                       // Table scan
+    if (NO_CURRENT_PART_ID != m_part_spec.start_part)
+      late_extra_no_cache(m_part_spec.start_part);
+    file= m_file;
+    do
+    {
+      if (bitmap_is_set(&(m_part_info->read_partitions), (uint)(file - m_file)))
+      {
+        if (m_pre_calling)
+          (*file)->pre_ft_end();
+        else
+          (*file)->ft_end();
+      }
+    } while (*(++file));
+    break;
+  }
+  m_scan_value= 2;
+  m_part_spec.start_part= NO_CURRENT_PART_ID;
+  ft_current= 0;
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Terminate a full text search during a bulk access request.
+*/
+
+int ha_partition::pre_ft_end()
+{
+  bool save_m_pre_calling;
+  DBUG_ENTER("ha_partition::pre_ft_end");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  ft_end();
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Initialize a full text search using the extended API.
+
+  @param  flags             Search flags
+  @param  inx               Key number
+  @param  key               Key value
+
+  @return FT_INFO structure if successful
+          NULL              otherwise
+*/
+
+FT_INFO *ha_partition::ft_init_ext(uint flags, uint inx, String *key)
+{
+  FT_INFO *ft_handler;
+  handler **file;
+  st_partition_ft_info *ft_target, **parent;
+  DBUG_ENTER("ha_partition::ft_init_ext");
+
+  if (ft_current)
+    parent= &ft_current->next;
+  else
+    parent= &ft_first;
+
+  if (!(ft_target= *parent))
+  {
+    FT_INFO **tmp_ft_info;
+    if (!(ft_target= (st_partition_ft_info *)
+          my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+                          &ft_target,
+                          sizeof(st_partition_ft_info),
+                          &tmp_ft_info,
+                          sizeof(FT_INFO *) * m_tot_parts,
+                          NullS)))
+    {
+      my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
+      DBUG_RETURN(NULL);
+    }
+    ft_target->part_ft_info= tmp_ft_info;
+    (*parent)= ft_target;
+  }
+
+  ft_current= ft_target;
+  file= m_file;
+  do
+  {
+    if (bitmap_is_set(&(m_part_info->read_partitions), (uint)(file - m_file)))
+    {
+      if ((ft_handler= (*file)->ft_init_ext(flags, inx, key)))
+        (*file)->ft_handler= ft_handler;
+      else
+        (*file)->ft_handler= NULL;
+      ft_target->part_ft_info[file - m_file]= ft_handler;
+    }
+    else
+    {
+      (*file)->ft_handler= NULL;
+      ft_target->part_ft_info[file - m_file]= NULL;
+    }
+  } while (*(++file));
+
+  ft_target->please= &partition_ft_vft;
+  ft_target->file= this;
+  DBUG_RETURN((FT_INFO*)ft_target);
+}
+
+
+/**
+  Return the next record from the FT result set during an ordered index
+  pre-scan
+
+  @param  use_parallel      Is it a parallel search
+
+  @return >0                Error code
+          0                 Success
+*/
+
+int ha_partition::pre_ft_read(bool use_parallel)
+{
+  bool save_m_pre_calling;
+  int error;
+  DBUG_ENTER("ha_partition::pre_ft_read");
+  DBUG_PRINT("info", ("partition this: %p", this));
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  m_pre_call_use_parallel= use_parallel;
+  error= ft_read(table->record[0]);
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Return the first or next record in a full text search.
+
+  @param  buf               Buffer where the record should be returned
+
+  @return >0                Error code
+          0                 Success
+*/
+
+int ha_partition::ft_read(uchar *buf)
+{
+  handler *file;
+  int result= HA_ERR_END_OF_FILE, error;
+  uint part_id= m_part_spec.start_part;
+  DBUG_ENTER("ha_partition::ft_read");
+  DBUG_PRINT("info", ("partition this: %p", this));
+  DBUG_PRINT("info", ("part_id: %u", part_id));
+
+  if (part_id == NO_CURRENT_PART_ID)
+  {
+    /*
+      The original set of partitions to scan was empty and thus we report
+      the result here.
+    */
+    DBUG_PRINT("info", ("NO_CURRENT_PART_ID"));
+    goto end;
+  }
+
+  DBUG_ASSERT(m_scan_value == 1);
+
+  if (m_ft_init_and_first)                      // First call to ft_read()
+  {
+    m_ft_init_and_first= FALSE;
+    if (!bulk_access_executing)
+    {
+      error= handle_pre_scan(FALSE, check_parallel_search());
+      if (m_pre_calling || error)
+        DBUG_RETURN(error);
+    }
+    late_extra_cache(part_id);
+  }
+
+  file= m_file[part_id];
+
+  while (TRUE)
+  {
+    if (!(result= file->ft_read(buf)))
+    {
+      /* Found row: remember position and return it. */
+      m_part_spec.start_part= m_last_part= part_id;
+      table->status= 0;
+      DBUG_RETURN(0);
+    }
+
+    /*
+      if we get here, then the current partition ft_next returned failure
+    */
+    if (result == HA_ERR_RECORD_DELETED)
+      continue;                               // Probably MyISAM
+
+    if (result != HA_ERR_END_OF_FILE)
+      goto end_dont_reset_start_part;         // Return error
+
+    /* End current partition */
+    late_extra_no_cache(part_id);
+    DBUG_PRINT("info", ("stopping using partition %u", (uint) part_id));
+
+    /* Shift to next partition */
+    while (++part_id < m_tot_parts &&
+           !bitmap_is_set(&(m_part_info->read_partitions), part_id))
+      ;
+    if (part_id >= m_tot_parts)
+    {
+      result= HA_ERR_END_OF_FILE;
+      break;
+    }
+    m_part_spec.start_part= m_last_part= part_id;
+    file= m_file[part_id];
+    DBUG_PRINT("info", ("now using partition %u", (uint) part_id));
+    late_extra_cache(part_id);
+  }
+
+end:
+  m_part_spec.start_part= NO_CURRENT_PART_ID;
+end_dont_reset_start_part:
+  table->status= STATUS_NOT_FOUND;
+  DBUG_RETURN(result);
+}
+
 
 /*
   Common routine to set up index scans
@@ -5878,7 +6939,7 @@ int ha_partition::read_range_next()
                      needs it to calculcate partitioning function
                      values)
 
-      idx_read_flag  TRUE <=> m_start_key has range start endpoint which 
+      idx_read_flag  TRUE <=> m_start_key has range start endpoint which
                      probably can be used to determine the set of partitions
                      to scan.
                      FALSE <=> there is no start endpoint.
@@ -5900,7 +6961,7 @@ int ha_partition::partition_scan_set_up(uchar * buf, bool idx_read_flag)
   DBUG_ENTER("ha_partition::partition_scan_set_up");
 
   if (idx_read_flag)
-    get_partition_set(table,buf,active_index,&m_start_key,&m_part_spec);
+    get_partition_set(table, buf, active_index, &m_start_key, &m_part_spec);
   else
   {
     m_part_spec.start_part= 0;
@@ -5921,8 +6982,8 @@ int ha_partition::partition_scan_set_up(uchar * buf, bool idx_read_flag)
       We discovered a single partition to scan, this never needs to be
       performed using the ordered index scan.
     */
-    DBUG_PRINT("info", ("index scan using the single partition %d",
-			m_part_spec.start_part));
+    DBUG_PRINT("info", ("index scan using the single partition %u",
+			(uint) m_part_spec.start_part));
     m_ordered_scan_ongoing= FALSE;
   }
   else
@@ -5949,6 +7010,206 @@ int ha_partition::partition_scan_set_up(uchar * buf, bool idx_read_flag)
   DBUG_RETURN(0);
 }
 
+/**
+  Check if we can search partitions in parallel
+
+  @retval TRUE  yes
+  @retval FALSE no
+*/
+
+bool ha_partition::check_parallel_search()
+{
+  TABLE_LIST *table_list= table->pos_in_table_list;
+  st_select_lex *select_lex;
+  JOIN *join;
+  DBUG_ENTER("ha_partition::check_parallel_search");
+  if (!table_list)
+    goto not_parallel;
+
+  while (table_list->parent_l)
+    table_list= table_list->parent_l;
+
+  select_lex= table_list->select_lex;
+  DBUG_PRINT("info",("partition select_lex: %p", select_lex));
+  if (!select_lex)
+    goto not_parallel;
+  if (!select_lex->explicit_limit)
+  {
+    DBUG_PRINT("info",("partition not using explicit_limit"));
+    goto parallel;
+  }
+
+  join= select_lex->join;
+  DBUG_PRINT("info",("partition join: %p", join));
+  if (join && join->skip_sort_order)
+  {
+    DBUG_PRINT("info",("partition order_list.elements: %u",
+                       select_lex->order_list.elements));
+    if (select_lex->order_list.elements)
+    {
+      Item *item= *select_lex->order_list.first->item;
+      DBUG_PRINT("info",("partition item: %p", item));
+      DBUG_PRINT("info",("partition item->type(): %u", item->type()));
+      DBUG_PRINT("info",("partition m_part_info->part_type: %u",
+                         m_part_info->part_type));
+      DBUG_PRINT("info",("partition m_is_sub_partitioned: %s",
+                         m_is_sub_partitioned ? "TRUE" : "FALSE"));
+      DBUG_PRINT("info",("partition m_part_info->part_expr: %p",
+                         m_part_info->part_expr));
+      if (item->type() == Item::FIELD_ITEM &&
+          m_part_info->part_type == RANGE_PARTITION &&
+          !m_is_sub_partitioned &&
+          (!m_part_info->part_expr ||
+           m_part_info->part_expr->type() == Item::FIELD_ITEM))
+      {
+        Field *order_field= ((Item_field *)item)->field;
+        DBUG_PRINT("info",("partition order_field: %p", order_field));
+        if (order_field && order_field->table == table_list->table)
+        {
+          Field *part_field= m_part_info->full_part_field_array[0];
+          if (set_top_table_fields)
+            order_field= top_table_field[order_field->field_index];
+          DBUG_PRINT("info",("partition order_field: %p", order_field));
+          DBUG_PRINT("info",("partition part_field: %p", part_field));
+          if (part_field == order_field)
+          {
+            /*
+              We are using ORDER BY partition_field LIMIT #
+              In this case, let's not do things in parallel as it's
+              likely that the query can be satisfied from the first
+              partition
+            */
+            DBUG_PRINT("info",("partition with ORDER on partition field"));
+            goto not_parallel;
+          }
+        }
+      }
+      DBUG_PRINT("info",("partition have order"));
+      goto parallel;
+    }
+
+    DBUG_PRINT("info",("partition group_list.elements: %u",
+                       select_lex->group_list.elements));
+    if (select_lex->group_list.elements)
+    {
+      Item *item= *select_lex->group_list.first->item;
+      DBUG_PRINT("info",("partition item: %p", item));
+      DBUG_PRINT("info",("partition item->type(): %u", item->type()));
+      DBUG_PRINT("info",("partition m_part_info->part_type: %u",
+                         m_part_info->part_type));
+      DBUG_PRINT("info",("partition m_is_sub_partitioned: %s",
+                         m_is_sub_partitioned ? "TRUE" : "FALSE"));
+      DBUG_PRINT("info",("partition m_part_info->part_expr: %p",
+                         m_part_info->part_expr));
+      if (item->type() == Item::FIELD_ITEM &&
+          m_part_info->part_type == RANGE_PARTITION &&
+          !m_is_sub_partitioned &&
+          (!m_part_info->part_expr ||
+           m_part_info->part_expr->type() == Item::FIELD_ITEM))
+      {
+        Field *group_field= ((Item_field *)item)->field;
+        DBUG_PRINT("info",("partition group_field: %p", group_field));
+        if (group_field && group_field->table == table_list->table)
+        {
+          Field *part_field= m_part_info->full_part_field_array[0];
+          if (set_top_table_fields)
+            group_field= top_table_field[group_field->field_index];
+          DBUG_PRINT("info",("partition group_field: %p", group_field));
+          DBUG_PRINT("info",("partition part_field: %p", part_field));
+          if (part_field == group_field)
+          {
+            DBUG_PRINT("info",("partition with GROUP BY on partition field"));
+            goto not_parallel;
+          }
+        }
+      }
+      DBUG_PRINT("info",("partition with GROUP BY"));
+      goto parallel;
+    }
+  }
+  else if (select_lex->order_list.elements ||
+           select_lex->group_list.elements)
+  {
+    DBUG_PRINT("info",("partition is not skip_order"));
+    DBUG_PRINT("info",("partition order_list.elements: %u",
+                       select_lex->order_list.elements));
+    DBUG_PRINT("info",("partition group_list.elements: %u",
+                       select_lex->group_list.elements));
+    goto parallel;
+  }
+  DBUG_PRINT("info",("partition is not skip_order"));
+
+not_parallel:
+  DBUG_PRINT("return",("partition FALSE"));
+  DBUG_RETURN(FALSE);
+
+parallel:
+  DBUG_PRINT("return",("partition TRUE"));
+  DBUG_RETURN(TRUE);
+}
+
+
+int ha_partition::handle_pre_scan(bool reverse_order, bool use_parallel)
+{
+  uint i;
+  DBUG_ENTER("ha_partition::handle_pre_scan");
+  DBUG_PRINT("enter",
+             ("m_part_spec.start_part: %u  m_part_spec.end_part: %u",
+              (uint) m_part_spec.start_part, (uint) m_part_spec.end_part));
+
+  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  {
+    if (!(bitmap_is_set(&(m_part_info->read_partitions), i)))
+      continue;
+    int error;
+    handler *file= m_file[i];
+
+    switch (m_index_scan_type) {
+    case partition_index_read:
+      error= file->pre_index_read_map(m_start_key.key,
+                                  m_start_key.keypart_map,
+                                  m_start_key.flag,
+                                  use_parallel);
+      break;
+    case partition_index_first:
+      error= file->pre_index_first(use_parallel);
+      break;
+    case partition_index_last:
+      error= file->pre_index_last(use_parallel);
+      break;
+    case partition_index_read_last:
+      error= file->pre_index_read_last_map(m_start_key.key,
+                                       m_start_key.keypart_map,
+                                       use_parallel);
+      break;
+    case partition_read_range:
+      error= file->pre_read_range_first(m_start_key.key? &m_start_key: NULL,
+                                    end_range, eq_range, TRUE, use_parallel);
+      break;
+    case partition_read_multi_range:
+      if (!bitmap_is_set(&m_mrr_used_partitions, i))
+        continue;
+      error= file->pre_multi_range_read_next(use_parallel);
+      break;
+    case partition_ft_read:
+      error= file->pre_ft_read(use_parallel);
+      break;
+    case partition_no_index_scan:
+      error= file->pre_rnd_next(use_parallel);
+      break;
+    default:
+      DBUG_ASSERT(FALSE);
+      DBUG_RETURN(0);
+    }
+    if (error == HA_ERR_END_OF_FILE)
+      error= 0;
+    if (error)
+      DBUG_RETURN(error);
+  }
+  table->status= 0;
+  DBUG_RETURN(0);
+}
+
 
 /****************************************************************************
   Unordered Index Scan Routines
@@ -5995,7 +7256,16 @@ int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
     partition_read_range is_next_same are always local constants
   */
 
-  if (m_index_scan_type == partition_read_range)
+  if (m_index_scan_type == partition_read_multi_range)
+  {
+    if (!(error= file->
+          multi_range_read_next(&m_range_info[m_part_spec.start_part])))
+    {
+      m_last_part= m_part_spec.start_part;
+      DBUG_RETURN(0);
+    }
+  }
+  else if (m_index_scan_type == partition_read_range)
   {
     if (!(error= file->read_range_next()))
     {
@@ -6012,7 +7282,7 @@ int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
       DBUG_RETURN(0);
     }
   }
-  else 
+  else
   {
     if (!(error= file->ha_index_next(buf)))
     {
@@ -6035,7 +7305,7 @@ int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
 
   SYNOPSIS
     handle_unordered_scan_next_partition()
-    buf                       Read row in MySQL Row Format
+    buf                       Read row in MariaDB Row Format
 
   RETURN VALUE
     HA_ERR_END_OF_FILE            End of scan
@@ -6053,6 +7323,7 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
   int saved_error= HA_ERR_END_OF_FILE;
   DBUG_ENTER("ha_partition::handle_unordered_scan_next_partition");
 
+  /* Read next partition that includes start_part */
   if (i)
     i= bitmap_get_next_set(&m_part_info->read_partitions, i - 1);
   else
@@ -6065,34 +7336,29 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
     int error;
     handler *file= m_file[i];
     m_part_spec.start_part= i;
+
     switch (m_index_scan_type) {
+    case partition_read_multi_range:
+      if (!bitmap_is_set(&m_mrr_used_partitions, i))
+        continue;
+      DBUG_PRINT("info", ("read_multi_range on partition %u", i));
+      error= file->multi_range_read_next(&m_range_info[i]);
+      break;
     case partition_read_range:
-      DBUG_PRINT("info", ("read_range_first on partition %d", i));
+      DBUG_PRINT("info", ("read_range_first on partition %u", i));
       error= file->read_range_first(m_start_key.key? &m_start_key: NULL,
                                     end_range, eq_range, FALSE);
       break;
     case partition_index_read:
-      DBUG_PRINT("info", ("index_read on partition %d", i));
+      DBUG_PRINT("info", ("index_read on partition %u", i));
       error= file->ha_index_read_map(buf, m_start_key.key,
                                      m_start_key.keypart_map,
                                      m_start_key.flag);
       break;
     case partition_index_first:
-      DBUG_PRINT("info", ("index_first on partition %d", i));
+      DBUG_PRINT("info", ("index_first on partition %u", i));
       error= file->ha_index_first(buf);
       break;
-    case partition_index_first_unordered:
-      /*
-        We perform a scan without sorting and this means that we
-        should not use the index_first since not all handlers
-        support it and it is also unnecessary to restrict sort
-        order.
-      */
-      DBUG_PRINT("info", ("read_range_first on partition %d", i));
-      table->record[0]= buf;
-      error= file->read_range_first(0, end_range, eq_range, 0);
-      table->record[0]= m_rec0;
-      break;
     default:
       DBUG_ASSERT(FALSE);
       DBUG_RETURN(1);
@@ -6106,12 +7372,12 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
       DBUG_RETURN(error);
 
     /*
-      If HA_ERR_KEY_NOT_FOUND, we must return that error instead of 
+      If HA_ERR_KEY_NOT_FOUND, we must return that error instead of
       HA_ERR_END_OF_FILE, to be able to continue search.
     */
     if (saved_error != HA_ERR_KEY_NOT_FOUND)
       saved_error= error;
-    DBUG_PRINT("info", ("END_OF_FILE/KEY_NOT_FOUND on partition %d", i));
+    DBUG_PRINT("info", ("END_OF_FILE/KEY_NOT_FOUND on partition %u", i));
   }
   if (saved_error == HA_ERR_END_OF_FILE)
     m_part_spec.start_part= NO_CURRENT_PART_ID;
@@ -6122,7 +7388,7 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
 /**
   Common routine to start index scan with ordered results.
 
-  @param[out] buf  Read row in MySQL Row Format
+  @param[out] buf  Read row in MariaDB Row Format
 
   @return Operation status
     @retval HA_ERR_END_OF_FILE  End of scan
@@ -6148,19 +7414,31 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
 
 int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
 {
+  int error;
   uint i;
   uint j= queue_first_element(&m_queue);
+  uint smallest_range_seq= 0;
   bool found= FALSE;
   uchar *part_rec_buf_ptr= m_ordered_rec_buffer;
   int saved_error= HA_ERR_END_OF_FILE;
   DBUG_ENTER("ha_partition::handle_ordered_index_scan");
+  DBUG_PRINT("enter", ("partition this: %p", this));
+
+   if (m_pre_calling)
+     error= handle_pre_scan(reverse_order, m_pre_call_use_parallel);
+   else
+     error= handle_pre_scan(reverse_order, check_parallel_search());
+  if (error)
+    DBUG_RETURN(error);
 
   if (m_key_not_found)
   {
+    /* m_key_not_found was set in the previous call to this function */
     m_key_not_found= false;
     bitmap_clear_all(&m_key_not_found_partitions);
   }
   m_top_entry= NO_CURRENT_PART_ID;
+  DBUG_PRINT("info", ("partition queue_remove_all(1)"));
   queue_remove_all(&m_queue);
   DBUG_ASSERT(bitmap_is_set(&m_part_info->read_partitions,
                             m_part_spec.start_part));
@@ -6180,14 +7458,14 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
   DBUG_PRINT("info", ("m_part_spec.start_part %u first_used_part %u",
                       m_part_spec.start_part, i));
   for (/* continue from above */ ;
-       i <= m_part_spec.end_part;
-       i= bitmap_get_next_set(&m_part_info->read_partitions, i))
+       i <= m_part_spec.end_part ;
+       i= bitmap_get_next_set(&m_part_info->read_partitions, i),
+       part_rec_buf_ptr+= m_priority_queue_rec_len)
   {
     DBUG_PRINT("info", ("reading from part %u (scan_type: %u)",
                         i, m_index_scan_type));
     DBUG_ASSERT(i == uint2korr(part_rec_buf_ptr));
     uchar *rec_buf_ptr= part_rec_buf_ptr + PARTITION_BYTES_IN_POS;
-    int error;
     handler *file= m_file[i];
 
     switch (m_index_scan_type) {
@@ -6196,6 +7474,7 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
                                      m_start_key.key,
                                      m_start_key.keypart_map,
                                      m_start_key.flag);
+      /* Caller has specified reverse_order */
       break;
     case partition_index_first:
       error= file->ha_index_first(rec_buf_ptr);
@@ -6207,16 +7486,49 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
       break;
     case partition_read_range:
     {
-      /* 
+      /*
         This can only read record to table->record[0], as it was set when
         the table was being opened. We have to memcpy data ourselves.
       */
       error= file->read_range_first(m_start_key.key? &m_start_key: NULL,
                                     end_range, eq_range, TRUE);
-      memcpy(rec_buf_ptr, table->record[0], m_rec_length);
+      if (!error)
+        memcpy(rec_buf_ptr, table->record[0], m_rec_length);
       reverse_order= FALSE;
       break;
     }
+    case partition_read_multi_range:
+    {
+      if (!bitmap_is_set(&m_mrr_used_partitions, i))
+        continue;
+      DBUG_PRINT("info", ("partition %u", i));
+      error= file->multi_range_read_next(&m_range_info[i]);
+      DBUG_PRINT("info", ("error: %d", error));
+      if (error == HA_ERR_KEY_NOT_FOUND || error == HA_ERR_END_OF_FILE)
+      {
+        bitmap_clear_bit(&m_mrr_used_partitions, i);
+        continue;
+      }
+      if (!error)
+      {
+        memcpy(rec_buf_ptr, table->record[0], m_rec_length);
+        reverse_order= FALSE;
+        m_stock_range_seq[i]= (((PARTITION_KEY_MULTI_RANGE *)
+                                m_range_info[i])->id);
+        /* Test if the key is in the first key range */
+        if (m_stock_range_seq[i] != m_mrr_range_current->id)
+        {
+          /*
+            smallest_range_seq contains the smallest key range we have seen
+            so far
+          */
+          if (!smallest_range_seq || smallest_range_seq > m_stock_range_seq[i])
+            smallest_range_seq= m_stock_range_seq[i];
+          continue;
+        }
+      }
+      break;
+    }
     default:
       DBUG_ASSERT(FALSE);
       DBUG_RETURN(HA_ERR_END_OF_FILE);
@@ -6234,10 +7546,6 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
       */
       queue_element(&m_queue, j++)= part_rec_buf_ptr;
     }
-    else if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
-    {
-      DBUG_RETURN(error);
-    }
     else if (error == HA_ERR_KEY_NOT_FOUND)
     {
       DBUG_PRINT("info", ("HA_ERR_KEY_NOT_FOUND from partition %u", i));
@@ -6245,7 +7553,53 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
       m_key_not_found= true;
       saved_error= error;
     }
-    part_rec_buf_ptr+= m_priority_queue_rec_len;
+    else if (error != HA_ERR_END_OF_FILE)
+    {
+      DBUG_RETURN(error);
+    }
+  }
+
+  if (!found && smallest_range_seq)
+  {
+    /* We know that there is an existing row based on code above */
+    found= TRUE;
+    part_rec_buf_ptr= m_ordered_rec_buffer;
+
+    /*
+      No key found in the first key range
+      Collect all partitions that has a key in smallest_range_seq
+     */
+    DBUG_PRINT("info", ("partition !found && smallest_range_seq"));
+    for (i= bitmap_get_first_set(&m_part_info->read_partitions);
+         i <= m_part_spec.end_part;
+         i= bitmap_get_next_set(&m_part_info->read_partitions, i))
+    {
+      DBUG_PRINT("info", ("partition current_part: %u", i));
+      if (i < m_part_spec.start_part)
+      {
+        part_rec_buf_ptr+= m_priority_queue_rec_len;
+        DBUG_PRINT("info", ("partition i < m_part_spec.start_part"));
+        continue;
+      }
+      if (!bitmap_is_set(&m_mrr_used_partitions, i))
+      {
+        part_rec_buf_ptr+= m_priority_queue_rec_len;
+        DBUG_PRINT("info", ("partition !bitmap_is_set(&m_mrr_used_partitions, i)"));
+        continue;
+      }
+      DBUG_ASSERT(i == uint2korr(part_rec_buf_ptr));
+      if (smallest_range_seq == m_stock_range_seq[i])
+      {
+        m_stock_range_seq[i]= 0;
+        queue_element(&m_queue, j++)= (uchar *) part_rec_buf_ptr;
+        DBUG_PRINT("info", ("partition smallest_range_seq == m_stock_range_seq[i]"));
+      }
+      part_rec_buf_ptr+= m_priority_queue_rec_len;
+    }
+
+    /* Update global m_mrr_range_current to the current range */
+    while (m_mrr_range_current->id < smallest_range_seq)
+      m_mrr_range_current= m_mrr_range_current->next;
   }
   if (found)
   {
@@ -6254,12 +7608,11 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
       after that read the first entry and copy it to the buffer to return in.
     */
     queue_set_max_at_top(&m_queue, reverse_order);
-    queue_set_cmp_arg(&m_queue, m_using_extended_keys? m_curr_key_info : (void*)this);
+    queue_set_cmp_arg(&m_queue, (void*) this);
     m_queue.elements= j - queue_first_element(&m_queue);
     queue_fix(&m_queue);
     return_top_record(buf);
-    table->status= 0;
-    DBUG_PRINT("info", ("Record returned from partition %d", m_top_entry));
+    DBUG_PRINT("info", ("Record returned from partition %u", m_top_entry));
     DBUG_RETURN(0);
   }
   DBUG_RETURN(saved_error);
@@ -6282,11 +7635,28 @@ void ha_partition::return_top_record(uchar *buf)
   uint part_id;
   uchar *key_buffer= queue_top(&m_queue);
   uchar *rec_buffer= key_buffer + PARTITION_BYTES_IN_POS;
+  DBUG_ENTER("ha_partition::return_top_record");
+  DBUG_PRINT("enter", ("partition this: %p", this));
 
   part_id= uint2korr(key_buffer);
   memcpy(buf, rec_buffer, m_rec_length);
   m_last_part= part_id;
+  DBUG_PRINT("info", ("partition m_last_part: %u", m_last_part));
   m_top_entry= part_id;
+  table->status= 0;                             // Found an existing row
+  m_file[part_id]->return_record_by_parent();
+  DBUG_VOID_RETURN;
+}
+
+/*
+  This function is only used if the partitioned table has own partitions.
+  This can happen if the partitioned VP engine is used (part of spider).
+*/
+
+void ha_partition::return_record_by_parent()
+{
+  m_file[m_last_part]->return_record_by_parent();
+  DBUG_ASSERT(0);
 }
 
 
@@ -6305,6 +7675,7 @@ int ha_partition::handle_ordered_index_scan_key_not_found()
   uchar *part_buf= m_ordered_rec_buffer;
   uchar *curr_rec_buf= NULL;
   DBUG_ENTER("ha_partition::handle_ordered_index_scan_key_not_found");
+  DBUG_PRINT("enter", ("partition this: %p", this));
   DBUG_ASSERT(m_key_not_found);
   /*
     Loop over all used partitions to get the correct offset
@@ -6325,7 +7696,10 @@ int ha_partition::handle_ordered_index_scan_key_not_found()
       /* HA_ERR_KEY_NOT_FOUND is not allowed from index_next! */
       DBUG_ASSERT(error != HA_ERR_KEY_NOT_FOUND);
       if (!error)
+      {
+        DBUG_PRINT("info", ("partition queue_insert(1)"));
         queue_insert(&m_queue, part_buf);
+      }
       else if (error != HA_ERR_END_OF_FILE && error != HA_ERR_KEY_NOT_FOUND)
         DBUG_RETURN(error);
     }
@@ -6362,11 +7736,15 @@ int ha_partition::handle_ordered_index_scan_key_not_found()
 int ha_partition::handle_ordered_next(uchar *buf, bool is_next_same)
 {
   int error;
+  DBUG_ENTER("ha_partition::handle_ordered_next");
+
+  if (m_top_entry == NO_CURRENT_PART_ID)
+    DBUG_RETURN(HA_ERR_END_OF_FILE);
+
   uint part_id= m_top_entry;
   uchar *rec_buf= queue_top(&m_queue) + PARTITION_BYTES_IN_POS;
   handler *file;
-  DBUG_ENTER("ha_partition::handle_ordered_next");
-  
+
   if (m_key_not_found)
   {
     if (is_next_same)
@@ -6408,6 +7786,122 @@ int ha_partition::handle_ordered_next(uchar *buf, bool is_next_same)
     error= file->read_range_next();
     memcpy(rec_buf, table->record[0], m_rec_length);
   }
+  else if (m_index_scan_type == partition_read_multi_range)
+  {
+    DBUG_PRINT("info", ("partition_read_multi_range route"));
+    DBUG_PRINT("info", ("part_id: %u", part_id));
+    bool get_next= FALSE;
+    error= file->multi_range_read_next(&m_range_info[part_id]);
+    DBUG_PRINT("info", ("error: %d", error));
+    if (error == HA_ERR_KEY_NOT_FOUND)
+      error= HA_ERR_END_OF_FILE;
+    if (error == HA_ERR_END_OF_FILE)
+    {
+      bitmap_clear_bit(&m_mrr_used_partitions, part_id);
+      DBUG_PRINT("info", ("partition m_queue.elements: %u", m_queue.elements));
+      if (m_queue.elements)
+      {
+        DBUG_PRINT("info", ("partition queue_remove_top(1)"));
+        queue_remove_top(&m_queue);
+        if (m_queue.elements)
+        {
+          return_top_record(buf);
+          DBUG_PRINT("info", ("Record returned from partition %u (3)",
+                              m_top_entry));
+          DBUG_RETURN(0);
+        }
+      }
+      get_next= TRUE;
+    }
+    else if (!error)
+    {
+      DBUG_PRINT("info", ("m_range_info[%u])->id: %u", part_id,
+                          ((PARTITION_KEY_MULTI_RANGE *)
+                           m_range_info[part_id])->id));
+      DBUG_PRINT("info", ("m_mrr_range_current->id: %u",
+                          m_mrr_range_current->id));
+      memcpy(rec_buf, table->record[0], m_rec_length);
+      if (((PARTITION_KEY_MULTI_RANGE *) m_range_info[part_id])->id !=
+          m_mrr_range_current->id)
+      {
+        m_stock_range_seq[part_id]=
+          ((PARTITION_KEY_MULTI_RANGE *) m_range_info[part_id])->id;
+        DBUG_PRINT("info", ("partition queue_remove_top(2)"));
+        queue_remove_top(&m_queue);
+        if (!m_queue.elements)
+          get_next= TRUE;
+      }
+    }
+    if (get_next)
+    {
+      DBUG_PRINT("info", ("get_next route"));
+      uint i, j= 0, smallest_range_seq= UINT_MAX32;
+      for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+      {
+        if (!(bitmap_is_set(&(m_part_info->read_partitions), i)))
+          continue;
+        if (!bitmap_is_set(&m_mrr_used_partitions, i))
+          continue;
+        if (smallest_range_seq > m_stock_range_seq[i])
+          smallest_range_seq= m_stock_range_seq[i];
+      }
+
+      DBUG_PRINT("info", ("smallest_range_seq: %u", smallest_range_seq));
+      if (smallest_range_seq != UINT_MAX32)
+      {
+        uchar *part_rec_buf_ptr= m_ordered_rec_buffer;
+        DBUG_PRINT("info", ("partition queue_remove_all(2)"));
+        queue_remove_all(&m_queue);
+        DBUG_PRINT("info", ("m_part_spec.start_part: %u",
+          m_part_spec.start_part));
+
+        for (i= bitmap_get_first_set(&m_part_info->read_partitions);
+             i <= m_part_spec.end_part;
+             i= bitmap_get_next_set(&m_part_info->read_partitions, i),
+               part_rec_buf_ptr+= m_priority_queue_rec_len)
+        {
+          DBUG_PRINT("info",("partition part_id: %u", i));
+          if (i < m_part_spec.start_part)
+          {
+            DBUG_PRINT("info",("partition i < m_part_spec.start_part"));
+            continue;
+          }
+          if (!bitmap_is_set(&m_mrr_used_partitions, i))
+          {
+            DBUG_PRINT("info",("partition !bitmap_is_set(&m_mrr_used_partitions, i)"));
+            continue;
+          }
+          DBUG_PRINT("info",("partition uint2korr: %u",
+                             uint2korr(part_rec_buf_ptr)));
+          DBUG_ASSERT(i == uint2korr(part_rec_buf_ptr));
+          DBUG_PRINT("info", ("partition m_stock_range_seq[%u]: %u",
+                              i, m_stock_range_seq[i]));
+          if (smallest_range_seq == m_stock_range_seq[i])
+          {
+            m_stock_range_seq[i]= 0;
+            DBUG_PRINT("info", ("partition queue_insert(2)"));
+            queue_insert(&m_queue, part_rec_buf_ptr);
+            j++;
+          }
+        }
+        while (m_mrr_range_current->id < smallest_range_seq)
+          m_mrr_range_current= m_mrr_range_current->next;
+
+        DBUG_PRINT("info",("partition m_mrr_range_current: %p",
+                           m_mrr_range_current));
+        DBUG_PRINT("info",("partition m_mrr_range_current->id: %u",
+                           m_mrr_range_current ? m_mrr_range_current->id : 0));
+        queue_set_max_at_top(&m_queue, FALSE);
+        queue_set_cmp_arg(&m_queue, (void*) this);
+        m_queue.elements= j;
+        queue_fix(&m_queue);
+        return_top_record(buf);
+        DBUG_PRINT("info", ("Record returned from partition %u (4)",
+                            m_top_entry));
+        DBUG_RETURN(0);
+      }
+    }
+  }
   else if (!is_next_same)
     error= file->ha_index_next(rec_buf);
   else
@@ -6416,16 +7910,16 @@ int ha_partition::handle_ordered_next(uchar *buf, bool is_next_same)
 
   if (error)
   {
-    if (error == HA_ERR_END_OF_FILE)
+    if (error == HA_ERR_END_OF_FILE && m_queue.elements)
     {
       /* Return next buffered row */
+      DBUG_PRINT("info", ("partition queue_remove_top(3)"));
       queue_remove_top(&m_queue);
       if (m_queue.elements)
       {
+         return_top_record(buf);
          DBUG_PRINT("info", ("Record returned from partition %u (2)",
                      m_top_entry));
-         return_top_record(buf);
-         table->status= 0;
          error= 0;
       }
     }
@@ -6461,30 +7955,35 @@ int ha_partition::handle_ordered_next(uchar *buf, bool is_next_same)
 int ha_partition::handle_ordered_prev(uchar *buf)
 {
   int error;
+  DBUG_ENTER("ha_partition::handle_ordered_prev");
+  DBUG_PRINT("enter", ("partition: %p", this));
+
+  if (m_top_entry == NO_CURRENT_PART_ID)
+    DBUG_RETURN(HA_ERR_END_OF_FILE);
+
   uint part_id= m_top_entry;
   uchar *rec_buf= queue_top(&m_queue) + PARTITION_BYTES_IN_POS;
   handler *file= m_file[part_id];
-  DBUG_ENTER("ha_partition::handle_ordered_prev");
 
   if ((error= file->ha_index_prev(rec_buf)))
   {
-    if (error == HA_ERR_END_OF_FILE)
+    if (error == HA_ERR_END_OF_FILE && m_queue.elements)
     {
+      DBUG_PRINT("info", ("partition queue_remove_top(4)"));
       queue_remove_top(&m_queue);
       if (m_queue.elements)
       {
 	return_top_record(buf);
-	DBUG_PRINT("info", ("Record returned from partition %d (2)",
+	DBUG_PRINT("info", ("Record returned from partition %u (2)",
 			    m_top_entry));
         error= 0;
-        table->status= 0;
       }
     }
     DBUG_RETURN(error);
   }
   queue_replace_top(&m_queue);
   return_top_record(buf);
-  DBUG_PRINT("info", ("Record returned from partition %d", m_top_entry));
+  DBUG_PRINT("info", ("Record returned from partition %u", m_top_entry));
   DBUG_RETURN(0);
 }
 
@@ -6636,7 +8135,8 @@ int ha_partition::info(uint flag)
         {
           set_if_bigger(part_share->next_auto_inc_val,
                         auto_increment_value);
-          part_share->auto_inc_initialized= true;
+          if (can_use_for_auto_inc_init())
+            part_share->auto_inc_initialized= true;
           DBUG_PRINT("info", ("initializing next_auto_inc_val to %lu",
                        (ulong) part_share->next_auto_inc_val));
         }
@@ -7145,7 +8645,7 @@ void ha_partition::get_dynamic_partition_info(PARTITION_STATS *stat_info,
   HA_EXTRA_DELETE_CANNOT_BATCH:
   HA_EXTRA_UPDATE_CANNOT_BATCH:
     Inform handler that delete_row()/update_row() cannot batch deletes/updates
-    and should perform them immediately. This may be needed when table has 
+    and should perform them immediately. This may be needed when table has
     AFTER DELETE/UPDATE triggers which access to subject table.
     These flags are reset by the handler::extra(HA_EXTRA_RESET) call.
 
@@ -7161,7 +8661,7 @@ void ha_partition::get_dynamic_partition_info(PARTITION_STATS *stat_info,
 int ha_partition::extra(enum ha_extra_function operation)
 {
   DBUG_ENTER("ha_partition:extra");
-  DBUG_PRINT("info", ("operation: %d", (int) operation));
+  DBUG_PRINT("enter", ("operation: %d", (int) operation));
 
   switch (operation) {
     /* Category 1), used by most handlers */
@@ -7188,7 +8688,7 @@ int ha_partition::extra(enum ha_extra_function operation)
   /* Category 3), used by MyISAM handlers */
   case HA_EXTRA_PREPARE_FOR_UPDATE:
     /*
-      Needs to be run on the first partition in the range now, and 
+      Needs to be run on the first partition in the range now, and
       later in late_extra_cache, when switching to a new partition to scan.
     */
     m_extra_prepare_for_update= TRUE;
@@ -7257,18 +8757,9 @@ int ha_partition::extra(enum ha_extra_function operation)
       with row being inserted by PK/unique key without reporting error
       to the SQL-layer.
 
-      This optimization is not safe for partitioned table in general case
-      since we may have to put new version of row into partition which is
-      different from partition in which old version resides (for example
-      when we partition by non-PK column or by some column which is not
-      part of unique key which were violated).
-      And since NDB which is the only engine at the moment that supports
-      this optimization handles partitioning on its own we simple disable
-      it here. (BTW for NDB this optimization is safe since it supports
-      only KEY partitioning and won't use this optimization for tables
-      which have additional unique constraints).
+      At this time, this is safe by limitation of ha_partition
     */
-    break;
+    DBUG_RETURN(loop_extra(operation));
   }
     /* Category 7), used by federated handlers */
   case HA_EXTRA_INSERT_WITH_UPDATE:
@@ -7282,20 +8773,39 @@ int ha_partition::extra(enum ha_extra_function operation)
   }
     /* Category 9) Operations only used by MERGE */
   case HA_EXTRA_ADD_CHILDREN_LIST:
+    DBUG_RETURN(loop_extra(operation));
   case HA_EXTRA_ATTACH_CHILDREN:
-  case HA_EXTRA_IS_ATTACHED_CHILDREN:
-  case HA_EXTRA_DETACH_CHILDREN:
   {
-    /* Special actions for MERGE tables. Ignore. */
+    int result;
+    uint num_locks;
+    handler **file;
+    if ((result= loop_extra(operation)))
+      DBUG_RETURN(result);
+
+    /* Recalculate lock count as each child may have different set of locks */
+    num_locks= 0;
+    file= m_file;
+    do
+    {
+      num_locks+= (*file)->lock_count();
+    } while (*(++file));
+
+    m_num_locks= num_locks;
     break;
   }
+  case HA_EXTRA_IS_ATTACHED_CHILDREN:
+    DBUG_RETURN(loop_extra(operation));
+  case HA_EXTRA_DETACH_CHILDREN:
+    DBUG_RETURN(loop_extra(operation));
+  case HA_EXTRA_MARK_AS_LOG_TABLE:
   /*
     http://dev.mysql.com/doc/refman/5.1/en/partitioning-limitations.html
     says we no longer support logging to partitioned tables, so we fail
     here.
   */
-  case HA_EXTRA_MARK_AS_LOG_TABLE:
     DBUG_RETURN(ER_UNSUPORTED_LOG_ENGINE);
+  case HA_EXTRA_STARTING_ORDERED_INDEX_SCAN:
+    DBUG_RETURN(loop_extra(operation));
   default:
   {
     /* Temporary crash to discover what is wrong */
@@ -7376,7 +8886,7 @@ int ha_partition::extra_opt(enum ha_extra_function operation, ulong cachesize)
 void ha_partition::prepare_extra_cache(uint cachesize)
 {
   DBUG_ENTER("ha_partition::prepare_extra_cache()");
-  DBUG_PRINT("info", ("cachesize %u", cachesize));
+  DBUG_PRINT("enter", ("cachesize %u", cachesize));
 
   m_extra_cache= TRUE;
   m_extra_cache_size= cachesize;
@@ -7443,7 +8953,7 @@ int ha_partition::loop_extra(enum ha_extra_function operation)
   int result= 0, tmp;
   uint i;
   DBUG_ENTER("ha_partition::loop_extra()");
-  
+
   for (i= bitmap_get_first_set(&m_part_info->lock_partitions);
        i < m_tot_parts;
        i= bitmap_get_next_set(&m_part_info->lock_partitions, i))
@@ -7472,9 +8982,9 @@ void ha_partition::late_extra_cache(uint partition_id)
 {
   handler *file;
   DBUG_ENTER("ha_partition::late_extra_cache");
-  DBUG_PRINT("info", ("extra_cache %u prepare %u partid %u size %u",
-                      m_extra_cache, m_extra_prepare_for_update,
-                      partition_id, m_extra_cache_size));
+  DBUG_PRINT("enter", ("extra_cache %u prepare %u partid %u size %u",
+                       m_extra_cache, m_extra_prepare_for_update,
+                       partition_id, m_extra_cache_size));
 
   if (!m_extra_cache && !m_extra_prepare_for_update)
     DBUG_VOID_RETURN;
@@ -7671,7 +9181,7 @@ ha_rows ha_partition::records_in_range(uint inx, key_range *min_key,
          != NO_CURRENT_PART_ID)
   {
     rows= m_file[part_id]->records_in_range(inx, min_key, max_key);
-      
+
     DBUG_PRINT("info", ("part %u match %lu rows of %lu", part_id, (ulong) rows,
                         (ulong) m_file[part_id]->stats.records));
 
@@ -7773,7 +9283,8 @@ double ha_partition::read_time(uint index, uint ranges, ha_rows rows)
 
 ha_rows ha_partition::records()
 {
-  ha_rows rows, tot_rows= 0;
+  int error;
+  ha_rows tot_rows= 0;
   uint i;
   DBUG_ENTER("ha_partition::records");
 
@@ -7781,11 +9292,13 @@ ha_rows ha_partition::records()
        i < m_tot_parts;
        i= bitmap_get_next_set(&m_part_info->read_partitions, i))
   {
-    rows= m_file[i]->records();
-    if (rows == HA_POS_ERROR)
+    ha_rows rows;
+    if ((error= m_file[i]->pre_records()) ||
+        (rows= m_file[i]->records()) == HA_POS_ERROR)
       DBUG_RETURN(HA_POS_ERROR);
     tot_rows+= rows;
   }
+  DBUG_PRINT("exit", ("records: %lld", (longlong) tot_rows));
   DBUG_RETURN(tot_rows);
 }
 
@@ -7809,7 +9322,7 @@ bool ha_partition::can_switch_engines()
 {
   handler **file;
   DBUG_ENTER("ha_partition::can_switch_engines");
- 
+
   file= m_file;
   do
   {
@@ -8044,10 +9557,9 @@ void ha_partition::print_error(int error, myf errflag)
 {
   THD *thd= ha_thd();
   DBUG_ENTER("ha_partition::print_error");
-
-  /* Should probably look for my own errors first */
   DBUG_PRINT("enter", ("error: %d", error));
 
+  /* Should probably look for my own errors first */
   if ((error == HA_ERR_NO_PARTITION_FOUND) &&
       ! (thd->lex->alter_info.flags & Alter_info::ALTER_TRUNCATE_PARTITION))
   {
@@ -8534,7 +10046,7 @@ uint ha_partition::min_record_length(uint options) const
     the same record. Otherwise we use the particular handler to decide if
     they are the same. Sort in partition id order if not equal.
 
-  MariaDB note: 
+  MariaDB note:
     Please don't merge the code from MySQL that does this:
 
     We get two references and need to check if those records are the same.
@@ -8548,15 +10060,18 @@ uint ha_partition::min_record_length(uint options) const
 int ha_partition::cmp_ref(const uchar *ref1, const uchar *ref2)
 {
   int cmp;
-  my_ptrdiff_t diff1, diff2;
+  uint32 diff1, diff2;
   DBUG_ENTER("ha_partition::cmp_ref");
 
-  cmp = m_file[0]->cmp_ref((ref1 + PARTITION_BYTES_IN_POS),
-			   (ref2 + PARTITION_BYTES_IN_POS));
+  cmp= m_file[0]->cmp_ref((ref1 + PARTITION_BYTES_IN_POS),
+                          (ref2 + PARTITION_BYTES_IN_POS));
   if (cmp)
     DBUG_RETURN(cmp);
 
-  if ((ref1[0] == ref2[0]) && (ref1[1] == ref2[1]))
+  diff2= uint2korr(ref2);
+  diff1= uint2korr(ref1);
+
+  if (diff1 == diff2)
   {
    /* This means that the references are same and are in same partition.*/
     DBUG_RETURN(0);
@@ -8569,22 +10084,7 @@ int ha_partition::cmp_ref(const uchar *ref1, const uchar *ref2)
     Remove this assert if DB_ROW_ID is changed to be per partition.
   */
   DBUG_ASSERT(!m_innodb);
-
-  diff1= ref2[1] - ref1[1];
-  diff2= ref2[0] - ref1[0];
-  if (diff1 > 0)
-  {
-    DBUG_RETURN(-1);
-  }
-  if (diff1 < 0)
-  {
-    DBUG_RETURN(+1);
-  }
-  if (diff2 > 0)
-  {
-    DBUG_RETURN(-1);
-  }
-  DBUG_RETURN(+1);
+  DBUG_RETURN(diff2 > diff1 ? -1 : 1);
 }
 
 
@@ -8593,6 +10093,82 @@ int ha_partition::cmp_ref(const uchar *ref1, const uchar *ref2)
 ****************************************************************************/
 
 
+/**
+   Retreive new values for part_share->next_auto_inc_val if needed
+
+   This is needed if the value has not been initialized or if one of
+   the underlying partitions require that the value should be re-calculated
+*/
+
+void ha_partition::update_next_auto_inc_val()
+{
+  if (!part_share->auto_inc_initialized ||
+      need_info_for_auto_inc())
+    info(HA_STATUS_AUTO);
+}
+
+
+/**
+  Determine whether a partition needs auto-increment initialization.
+
+  @return
+    TRUE                    A  partition needs auto-increment initialization
+    FALSE                   No partition needs auto-increment initialization
+
+  Resets part_share->auto_inc_initialized if next auto_increment needs to be
+  recalculated.
+*/
+
+bool ha_partition::need_info_for_auto_inc()
+{
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::need_info_for_auto_inc");
+
+  do
+  {
+    if ((*file)->need_info_for_auto_inc())
+    {
+      /* We have to get new auto_increment values from handler */
+      part_share->auto_inc_initialized= FALSE;
+      DBUG_RETURN(TRUE);
+    }
+  } while (*(++file));
+  DBUG_RETURN(FALSE);
+}
+
+
+/**
+  Determine if all partitions can use the current auto-increment value for
+  auto-increment initialization.
+
+  @return
+    TRUE                    All partitions can use the current auto-increment
+                            value for auto-increment initialization
+    FALSE                   All partitions cannot use the current
+                            auto-increment value for auto-increment
+                            initialization
+
+  Notes
+    This function is only called for ::info(HA_STATUS_AUTO) and is
+    mainly used by the Spider engine, which returns false
+    except in the case of DROP TABLE or ALTER TABLE when it returns TRUE.
+    Other engines always returns TRUE for this call.
+*/
+
+bool ha_partition::can_use_for_auto_inc_init()
+{
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::can_use_for_auto_inc_init");
+
+  do
+  {
+    if (!(*file)->can_use_for_auto_inc_init())
+      DBUG_RETURN(FALSE);
+  } while (*(++file));
+  DBUG_RETURN(TRUE);
+}
+
+
 int ha_partition::reset_auto_increment(ulonglong value)
 {
   handler **file= m_file;
@@ -8626,8 +10202,8 @@ void ha_partition::get_auto_increment(ulonglong offset, ulonglong increment,
                                       ulonglong *nb_reserved_values)
 {
   DBUG_ENTER("ha_partition::get_auto_increment");
-  DBUG_PRINT("info", ("offset: %lu inc: %lu desired_values: %lu "
-                      "first_value: %lu", (ulong) offset, (ulong) increment,
+  DBUG_PRINT("enter", ("offset: %lu  inc: %lu  desired_values: %lu  "
+                       "first_value: %lu", (ulong) offset, (ulong) increment,
                       (ulong) nb_desired_values, (ulong) *first_value));
   DBUG_ASSERT(increment && nb_desired_values);
   *first_value= 0;
@@ -8671,7 +10247,7 @@ void ha_partition::get_auto_increment(ulonglong offset, ulonglong increment,
     /*
       Get a lock for handling the auto_increment in part_share
       for avoiding two concurrent statements getting the same number.
-    */ 
+    */
 
     lock_auto_increment();
 
@@ -8682,8 +10258,8 @@ void ha_partition::get_auto_increment(ulonglong offset, ulonglong increment,
       based replication. Because the statement-based binary log contains
       only the first generated value used by the statement, and slaves assumes
       all other generated values used by this statement were consecutive to
-      this first one, we must exclusively lock the generator until the statement
-      is done.
+      this first one, we must exclusively lock the generator until the
+      statement is done.
     */
     if (!auto_increment_safe_stmt_log_lock &&
         thd->lex->sql_command != SQLCOM_INSERT &&
@@ -8946,8 +10522,8 @@ int ha_partition::check_misplaced_rows(uint read_part_id, bool do_repair)
       }
       else
       {
-        DBUG_PRINT("info", ("Moving row from partition %d to %d",
-                            read_part_id, correct_part_id));
+        DBUG_PRINT("info", ("Moving row from partition %u to %u",
+                            (uint) read_part_id, (uint) correct_part_id));
 
         /*
           Insert row into correct partition. Notice that there are no commit
@@ -8978,19 +10554,19 @@ int ha_partition::check_misplaced_rows(uint read_part_id, bool do_repair)
           {
             /* Log this error, so the DBA can notice it and fix it! */
             sql_print_error("Table '%-192s' failed to move/insert a row"
-                            " from part %d into part %d:\n%s",
+                            " from part %u into part %u:\n%s",
                             table->s->table_name.str,
-                            read_part_id,
-                            correct_part_id,
+                            (uint) read_part_id,
+                            (uint) correct_part_id,
                             str.c_ptr_safe());
           }
 	  print_admin_msg(ha_thd(), MYSQL_ERRMSG_SIZE, "error",
                           table_share->db.str, table->alias,
                           opt_op_name[REPAIR_PARTS],
                           "Failed to move/insert a row"
-                          " from part %d into part %d:\n%s",
-                          read_part_id,
-                          correct_part_id,
+                          " from part %u into part %u:\n%s",
+                          (uint) read_part_id,
+                          (uint) correct_part_id,
                           str.c_ptr_safe());
           break;
         }
@@ -9011,14 +10587,14 @@ int ha_partition::check_misplaced_rows(uint read_part_id, bool do_repair)
           append_row_to_str(str);
 
           /* Log this error, so the DBA can notice it and fix it! */
-          sql_print_error("Table '%-192s': Delete from part %d failed with"
+          sql_print_error("Table '%-192s': Delete from part %u failed with"
                           " error %d. But it was already inserted into"
-                          " part %d, when moving the misplaced row!"
+                          " part %u, when moving the misplaced row!"
                           "\nPlease manually fix the duplicate row:\n%s",
                           table->s->table_name.str,
-                          read_part_id,
+                          (uint) read_part_id,
                           result,
-                          correct_part_id,
+                          (uint) correct_part_id,
                           str.c_ptr_safe());
           break;
         }
@@ -9148,6 +10724,670 @@ int ha_partition::check_for_upgrade(HA_CHECK_OPT *check_opt)
 }
 
 
+TABLE_LIST *ha_partition::get_next_global_for_child()
+{
+  handler **file;
+  DBUG_ENTER("ha_partition::get_next_global_for_child");
+  for (file= m_file; *file; file++)
+  {
+    TABLE_LIST *table_list;
+    if ((table_list= (*file)->get_next_global_for_child()))
+      DBUG_RETURN(table_list);
+  }
+  DBUG_RETURN(0);
+}
+
+
+const COND *ha_partition::cond_push(const COND *cond)
+{
+  handler **file= m_file;
+  COND *res_cond= NULL;
+  DBUG_ENTER("ha_partition::cond_push");
+
+  if (set_top_table_fields)
+  {
+    /*
+      We want to do this in a separate loop to not come into a situation
+      where we have only done cond_push() to some of the tables
+    */
+    do
+    {
+      if (((*file)->set_top_table_and_fields(top_table,
+                                             top_table_field,
+                                             top_table_fields)))
+        DBUG_RETURN(cond);                      // Abort cond push, no error
+    } while (*(++file));
+    file= m_file;
+  }
+
+  do
+  {
+    if ((*file)->pushed_cond != cond)
+    {
+      if ((*file)->cond_push(cond))
+        res_cond= (COND *) cond;
+      else
+        (*file)->pushed_cond= cond;
+    }
+  } while (*(++file));
+  DBUG_RETURN(res_cond);
+}
+
+
+void ha_partition::cond_pop()
+{
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::cond_push");
+
+  do
+  {
+    (*file)->cond_pop();
+  } while (*(++file));
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Perform bulk update preparation on each partition.
+
+  SYNOPSIS
+    start_bulk_update()
+
+  RETURN VALUE
+    TRUE                      Error
+    FALSE                     Success
+*/
+
+bool ha_partition::start_bulk_update()
+{
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::start_bulk_update");
+
+  if (bitmap_is_overlapping(&m_part_info->full_part_field_set,
+                            table->write_set))
+    DBUG_RETURN(TRUE);
+
+  do
+  {
+    if ((*file)->start_bulk_update())
+      DBUG_RETURN(TRUE);
+  } while (*(++file));
+  DBUG_RETURN(FALSE);
+}
+
+
+/**
+  Perform bulk update execution on each partition.  A bulk update allows
+  a handler to batch the updated rows instead of performing the updates
+  one row at a time.
+
+  SYNOPSIS
+    exec_bulk_update()
+
+  RETURN VALUE
+    TRUE                      Error
+    FALSE                     Success
+*/
+
+int ha_partition::exec_bulk_update(ha_rows *dup_key_found)
+{
+  int error;
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::exec_bulk_update");
+
+  do
+  {
+    if ((error= (*file)->exec_bulk_update(dup_key_found)))
+      DBUG_RETURN(error);
+  } while (*(++file));
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Perform bulk update cleanup on each partition.
+
+  SYNOPSIS
+    end_bulk_update()
+
+  RETURN VALUE
+    NONE
+*/
+
+int ha_partition::end_bulk_update()
+{
+  int error= 0;
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::end_bulk_update");
+
+  do
+  {
+    int tmp;
+    if ((tmp= (*file)->end_bulk_update()))
+      error= tmp;
+  } while (*(++file));
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Add the row to the bulk update on the partition on which the row is stored.
+  A bulk update allows a handler to batch the updated rows instead of
+  performing the updates one row at a time.
+
+  SYNOPSIS
+    bulk_update_row()
+    old_data                  Old record
+    new_data                  New record
+    dup_key_found             Number of duplicate keys found
+
+  RETURN VALUE
+    >1                        Error
+    1                         Bulk update not used, normal operation used
+    0                         Bulk update used by handler
+*/
+
+int ha_partition::bulk_update_row(const uchar *old_data, const uchar *new_data,
+                                  ha_rows *dup_key_found)
+{
+  int error= 0;
+  uint32 part_id;
+  longlong func_value;
+  my_bitmap_map *old_map;
+  DBUG_ENTER("ha_partition::bulk_update_row");
+
+  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  error= m_part_info->get_partition_id(m_part_info, &part_id,
+                                       &func_value);
+  dbug_tmp_restore_column_map(table->read_set, old_map);
+  if (unlikely(error))
+  {
+    m_part_info->err_value= func_value;
+    goto end;
+  }
+
+  error= m_file[part_id]->ha_bulk_update_row(old_data, new_data,
+                                             dup_key_found);
+
+end:
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Perform bulk delete preparation on each partition.
+
+  SYNOPSIS
+    start_bulk_delete()
+
+  RETURN VALUE
+    TRUE                      Error
+    FALSE                     Success
+*/
+
+bool ha_partition::start_bulk_delete()
+{
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::start_bulk_delete");
+
+  do
+  {
+    if ((*file)->start_bulk_delete())
+      DBUG_RETURN(TRUE);
+  } while (*(++file));
+  DBUG_RETURN(FALSE);
+}
+
+
+/**
+  Perform bulk delete cleanup on each partition.
+
+  SYNOPSIS
+    end_bulk_delete()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::end_bulk_delete()
+{
+  int error= 0;
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::end_bulk_delete");
+
+  do
+  {
+    int tmp;
+    if ((tmp= (*file)->end_bulk_delete()))
+      error= tmp;
+  } while (*(++file));
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Perform initialization for a direct update request.
+
+  SYNOPSIS
+    direct_update_rows_init()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::direct_update_rows_init()
+{
+  int error;
+  uint i, found;
+  handler *file;
+  DBUG_ENTER("ha_partition::direct_update_rows_init");
+
+  if (bitmap_is_overlapping(&m_part_info->full_part_field_set,
+                            table->write_set))
+  {
+    DBUG_PRINT("info", ("partition FALSE by updating part_key"));
+    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+  }
+
+  m_part_spec.start_part= 0;
+  m_part_spec.end_part= m_tot_parts - 1;
+  m_direct_update_part_spec= m_part_spec;
+
+  found= 0;
+  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  {
+    if (bitmap_is_set(&(m_part_info->read_partitions), i) &&
+        bitmap_is_set(&(m_part_info->lock_partitions), i))
+    {
+      file= m_file[i];
+      if ((error= (m_pre_calling ?
+                   file->pre_direct_update_rows_init() :
+                   file->direct_update_rows_init())))
+      {
+        DBUG_PRINT("info", ("partition FALSE by storage engine"));
+        DBUG_RETURN(error);
+      }
+      found++;
+    }
+  }
+
+  TABLE_LIST *table_list= table->pos_in_table_list;
+  if (found != 1 && table_list)
+  {
+    while (table_list->parent_l)
+      table_list= table_list->parent_l;
+    st_select_lex *select_lex= table_list->select_lex;
+    DBUG_PRINT("info", ("partition select_lex: %p", select_lex));
+    if (select_lex && select_lex->explicit_limit)
+    {
+      DBUG_PRINT("info", ("partition explicit_limit=TRUE"));
+      DBUG_PRINT("info", ("partition offset_limit: %p",
+                          select_lex->offset_limit));
+      DBUG_PRINT("info", ("partition select_limit: %p",
+                          select_lex->select_limit));
+      DBUG_PRINT("info", ("partition FALSE by select_lex"));
+      DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+    }
+  }
+  DBUG_PRINT("info", ("partition OK"));
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Do initialization for performing parallel direct update
+  for a handlersocket update request.
+
+  SYNOPSIS
+    pre_direct_update_rows_init()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::pre_direct_update_rows_init()
+{
+  bool save_m_pre_calling;
+  int error;
+  DBUG_ENTER("ha_partition::pre_direct_update_rows_init");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  error= direct_update_rows_init();
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Execute a direct update request.  A direct update request updates all
+  qualified rows in a single operation, rather than one row at a time.
+  The direct update operation is pushed down to each individual
+  partition.
+
+  SYNOPSIS
+    direct_update_rows()
+    update_rows               Number of updated rows
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::direct_update_rows(ha_rows *update_rows_result)
+{
+  int error;
+  bool rnd_seq= FALSE;
+  ha_rows update_rows= 0;
+  uint32 i;
+  DBUG_ENTER("ha_partition::direct_update_rows");
+
+  /* If first call to direct_update_rows with RND scan */
+  if ((m_pre_calling ? pre_inited : inited) == RND && m_scan_value == 1)
+  {
+    rnd_seq= TRUE;
+    m_scan_value= 2;
+  }
+
+  *update_rows_result= 0;
+  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  {
+    handler *file= m_file[i];
+    if (bitmap_is_set(&(m_part_info->read_partitions), i) &&
+        bitmap_is_set(&(m_part_info->lock_partitions), i))
+    {
+      if (rnd_seq && (m_pre_calling ? file->pre_inited : file->inited) == NONE)
+      {
+        if ((error= (m_pre_calling ?
+                     file->ha_pre_rnd_init(TRUE) :
+                     file->ha_rnd_init(TRUE))))
+          DBUG_RETURN(error);
+      }
+      if ((error= (m_pre_calling ?
+                   (file)->pre_direct_update_rows() :
+                   (file)->ha_direct_update_rows(&update_rows))))
+      {
+        if (rnd_seq)
+        {
+          if (m_pre_calling)
+            file->ha_pre_rnd_end();
+          else
+            file->ha_rnd_end();
+        }
+        DBUG_RETURN(error);
+      }
+      *update_rows_result+= update_rows;
+    }
+    if (rnd_seq)
+    {
+      if ((error= (m_pre_calling ?
+                   file->ha_pre_index_or_rnd_end() :
+                   file->ha_index_or_rnd_end())))
+        DBUG_RETURN(error);
+    }
+  }
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Start parallel execution of a direct update for a handlersocket update
+  request.  A direct update request updates all qualified rows in a single
+  operation, rather than one row at a time.  The direct update operation
+  is pushed down to each individual partition.
+
+  SYNOPSIS
+    pre_direct_update_rows()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::pre_direct_update_rows()
+{
+  bool save_m_pre_calling;
+  int error;
+  ha_rows not_used= 0;
+  DBUG_ENTER("ha_partition::pre_direct_update_rows");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  error= direct_update_rows(&not_used);
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Perform initialization for a direct delete request.
+
+  SYNOPSIS
+    direct_delete_rows_init()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::direct_delete_rows_init()
+{
+  int error;
+  uint i, found;
+  DBUG_ENTER("ha_partition::direct_delete_rows_init");
+
+  m_part_spec.start_part= 0;
+  m_part_spec.end_part= m_tot_parts - 1;
+  m_direct_update_part_spec= m_part_spec;
+
+  found= 0;
+  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  {
+    if (bitmap_is_set(&(m_part_info->read_partitions), i) &&
+        bitmap_is_set(&(m_part_info->lock_partitions), i))
+    {
+      handler *file= m_file[i];
+      if ((error= (m_pre_calling ?
+                   file->pre_direct_delete_rows_init() :
+                   file->direct_delete_rows_init())))
+      {
+        DBUG_PRINT("exit", ("error in direct_delete_rows_init"));
+        DBUG_RETURN(error);
+      }
+      found++;
+    }
+  }
+
+  TABLE_LIST *table_list= table->pos_in_table_list;
+  if (found != 1 && table_list)
+  {
+    while (table_list->parent_l)
+      table_list= table_list->parent_l;
+    st_select_lex *select_lex= table_list->select_lex;
+    DBUG_PRINT("info", ("partition select_lex: %p", select_lex));
+    if (select_lex && select_lex->explicit_limit)
+    {
+      DBUG_PRINT("info", ("partition explicit_limit: TRUE"));
+      DBUG_PRINT("info", ("partition offset_limit: %p",
+                          select_lex->offset_limit));
+      DBUG_PRINT("info", ("partition select_limit: %p",
+                          select_lex->select_limit));
+      DBUG_PRINT("info", ("partition FALSE by select_lex"));
+      DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+    }
+  }
+  DBUG_PRINT("exit", ("OK"));
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Do initialization for performing parallel direct delete
+  for a handlersocket delete request.
+
+  SYNOPSIS
+    pre_direct_delete_rows_init()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::pre_direct_delete_rows_init()
+{
+  bool save_m_pre_calling;
+  int error;
+  DBUG_ENTER("ha_partition::pre_direct_delete_rows_init");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  error= direct_delete_rows_init();
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+
+/**
+  Execute a direct delete request.  A direct delete request deletes all
+  qualified rows in a single operation, rather than one row at a time.
+  The direct delete operation is pushed down to each individual
+  partition.
+
+  SYNOPSIS
+    direct_delete_rows()
+    delete_rows               Number of deleted rows
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::direct_delete_rows(ha_rows *delete_rows_result)
+{
+  int error;
+  bool rnd_seq= FALSE;
+  ha_rows delete_rows= 0;
+  uint32 i;
+  handler *file;
+  DBUG_ENTER("ha_partition::direct_delete_rows");
+
+  if ((m_pre_calling ? pre_inited : inited) == RND && m_scan_value == 1)
+  {
+    rnd_seq= TRUE;
+    m_scan_value= 2;
+  }
+
+  *delete_rows_result= 0;
+  m_part_spec= m_direct_update_part_spec;
+  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  {
+    file= m_file[i];
+    if (bitmap_is_set(&(m_part_info->read_partitions), i) &&
+        bitmap_is_set(&(m_part_info->lock_partitions), i))
+    {
+      if (rnd_seq && (m_pre_calling ? file->pre_inited : file->inited) == NONE)
+      {
+        if ((error= (m_pre_calling ?
+                     file->ha_pre_rnd_init(TRUE) :
+                     file->ha_rnd_init(TRUE))))
+          DBUG_RETURN(error);
+      }
+      if ((error= (m_pre_calling ?
+                   file->pre_direct_delete_rows() :
+                   file->ha_direct_delete_rows(&delete_rows))))
+      {
+        if (m_pre_calling)
+          file->ha_pre_rnd_end();
+        else
+          file->ha_rnd_end();
+        DBUG_RETURN(error);
+      }
+      delete_rows_result+= delete_rows;
+    }
+    if (rnd_seq)
+    {
+      if ((error= (m_pre_calling ?
+                   file->ha_pre_index_or_rnd_end() :
+                   file->ha_index_or_rnd_end())))
+        DBUG_RETURN(error);
+    }
+  }
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Start parallel execution of a direct delete for a handlersocket delete
+  request.  A direct delete request deletes all qualified rows in a single
+  operation, rather than one row at a time.  The direct delete operation
+  is pushed down to each individual partition.
+
+  SYNOPSIS
+    pre_direct_delete_rows()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::pre_direct_delete_rows()
+{
+  bool save_m_pre_calling;
+  int error;
+  ha_rows not_used;
+  DBUG_ENTER("ha_partition::pre_direct_delete_rows");
+  save_m_pre_calling= m_pre_calling;
+  m_pre_calling= TRUE;
+  error= direct_delete_rows(&not_used);
+  m_pre_calling= save_m_pre_calling;
+  DBUG_RETURN(error);
+}
+
+/**
+  Push metadata for the current operation down to each partition.
+
+  SYNOPSIS
+    info_push()
+
+  RETURN VALUE
+    >0                        Error
+    0                         Success
+*/
+
+int ha_partition::info_push(uint info_type, void *info)
+{
+  int error= 0;
+  handler **file= m_file;
+  DBUG_ENTER("ha_partition::info_push");
+
+  do
+  {
+    int tmp;
+    if ((tmp= (*file)->info_push(info_type, info)))
+      error= tmp;
+  } while (*(++file));
+  DBUG_RETURN(error);
+}
+
+
+void ha_partition::clear_top_table_fields()
+{
+  handler **file;
+  DBUG_ENTER("ha_partition::clear_top_table_fields");
+
+  if (set_top_table_fields)
+  {
+    set_top_table_fields= FALSE;
+    top_table= NULL;
+    top_table_field= NULL;
+    top_table_fields= 0;
+    for (file= m_file; *file; file++)
+      (*file)->clear_top_table_fields();
+  }
+  DBUG_VOID_RETURN;
+}
+
+
 struct st_mysql_storage_engine partition_storage_engine=
 { MYSQL_HANDLERTON_INTERFACE_VERSION };
 
diff --git a/sql/ha_partition.h b/sql/ha_partition.h
index 40e6fd78c97..0b9f1dc3953 100644
--- a/sql/ha_partition.h
+++ b/sql/ha_partition.h
@@ -67,6 +67,17 @@ public:
   }
 };
 
+class ha_partition;
+
+/* Partition Full Text Search info */
+struct st_partition_ft_info
+{
+  struct _ft_vft        *please;
+  st_partition_ft_info  *next;
+  ha_partition          *file;
+  FT_INFO               **part_ft_info;
+};
+
 
 extern PSI_mutex_key key_partition_auto_inc_mutex;
 
@@ -169,7 +180,34 @@ private:
                                      bool is_subpart);
 };
 
+typedef struct st_partition_key_multi_range
+{
+  uint id;
+  uchar *key[2];
+  uint length[2];
+  KEY_MULTI_RANGE key_multi_range;
+  range_id_t ptr;
+  st_partition_key_multi_range *next;
+} PARTITION_KEY_MULTI_RANGE;
+
+
+typedef struct st_partition_part_key_multi_range
+{
+  PARTITION_KEY_MULTI_RANGE *partition_key_multi_range;
+  st_partition_part_key_multi_range *next;
+} PARTITION_PART_KEY_MULTI_RANGE;
+
+
+class ha_partition;
+typedef struct st_partition_part_key_multi_range_hld
+{
+  ha_partition *partition;
+  uint32 part_id;
+  PARTITION_PART_KEY_MULTI_RANGE *partition_part_key_multi_range;
+} PARTITION_PART_KEY_MULTI_RANGE_HLD;
+
 
+extern "C" int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2);
 extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2);
 
 class ha_partition :public handler
@@ -179,16 +217,17 @@ private:
   {
     partition_index_read= 0,
     partition_index_first= 1,
-    partition_index_first_unordered= 2,
     partition_index_last= 3,
     partition_index_read_last= 4,
     partition_read_range = 5,
-    partition_no_index_scan= 6
+    partition_no_index_scan= 6,
+    partition_read_multi_range = 7,
+    partition_ft_read= 8
   };
   /* Data for the partition handler */
   int  m_mode;                          // Open mode
   uint m_open_test_lock;                // Open test_if_locked
-  uchar *m_file_buffer;                 // Content of the .par file 
+  uchar *m_file_buffer;                 // Content of the .par file
   char *m_name_buffer_ptr;		// Pointer to first partition name
   MEM_ROOT m_mem_root;
   plugin_ref *m_engine_array;           // Array of types of the handlers
@@ -201,6 +240,8 @@ private:
   partition_info *m_part_info;          // local reference to partition
   Field **m_part_field_array;           // Part field array locally to save acc
   uchar *m_ordered_rec_buffer;          // Row and key buffer for ord. idx scan
+  st_partition_ft_info *ft_first;
+  st_partition_ft_info *ft_current;
   /*
     Current index.
     When used in key_rec_cmp: If clustered pk, index compare
@@ -217,7 +258,7 @@ private:
     Length of an element in m_ordered_rec_buffer. The elements are composed of
 
       [part_no] [table->record copy] [underlying_table_rowid]
-    
+
     underlying_table_rowid is only stored when the table has no extended keys.
   */
   uint m_priority_queue_rec_len;
@@ -265,14 +306,16 @@ private:
   bool m_create_handler;                 // Handler used to create table
   bool m_is_sub_partitioned;             // Is subpartitioned
   bool m_ordered_scan_ongoing;
+  bool m_rnd_init_and_first;
+  bool m_ft_init_and_first;
 
-  /* 
+  /*
     If set, this object was created with ha_partition::clone and doesn't
     "own" the m_part_info structure.
   */
   ha_partition *m_is_clone_of;
   MEM_ROOT *m_clone_mem_root;
-  
+
   /*
     We keep track if all underlying handlers are MyISAM since MyISAM has a
     great number of extra flags not needed by other handlers.
@@ -317,6 +360,12 @@ private:
   ha_rows   m_bulk_inserted_rows;
   /** used for prediction of start_bulk_insert rows */
   enum_monotonicity_info m_part_func_monotonicity_info;
+  part_id_range m_direct_update_part_spec;
+  bool                m_pre_calling;
+  bool                m_pre_call_use_parallel;
+  /* Keep track of bulk access requests */
+  bool                bulk_access_executing;
+
   /** keep track of locked partitions */
   MY_BITMAP m_locked_partitions;
   /** Stores shared auto_increment etc. */
@@ -335,6 +384,18 @@ private:
   MY_BITMAP m_key_not_found_partitions;
   bool m_key_not_found;
 public:
+  handler **get_child_handlers()
+  {
+    return m_file;
+  }
+  virtual part_id_range *get_part_spec()
+  {
+    return &m_part_spec;
+  }
+  virtual uint get_no_current_part_id()
+  {
+    return NO_CURRENT_PART_ID;
+  }
   Partition_share *get_part_share() { return part_share; }
   handler *clone(const char *name, MEM_ROOT *mem_root);
   virtual void set_part_info(partition_info *part_info)
@@ -342,6 +403,9 @@ public:
      m_part_info= part_info;
      m_is_sub_partitioned= part_info->is_sub_partitioned();
   }
+
+  virtual void return_record_by_parent();
+
   /*
     -------------------------------------------------------------------------
     MODULE create/delete handler object
@@ -360,6 +424,7 @@ public:
                  ha_partition *clone_arg,
                  MEM_ROOT *clone_mem_root_arg);
    ~ha_partition();
+   void ha_partition_init();
   /*
     A partition handler has no characteristics in itself. It only inherits
     those from the underlying handlers. Here we set-up those constants to
@@ -543,8 +608,23 @@ public:
     number of calls to write_row.
   */
   virtual int write_row(uchar * buf);
+  virtual bool start_bulk_update();
+  virtual int exec_bulk_update(ha_rows *dup_key_found);
+  virtual int end_bulk_update();
+  virtual int bulk_update_row(const uchar *old_data, const uchar *new_data,
+                              ha_rows *dup_key_found);
   virtual int update_row(const uchar * old_data, const uchar * new_data);
+  virtual int direct_update_rows_init();
+  virtual int pre_direct_update_rows_init();
+  virtual int direct_update_rows(ha_rows *update_rows);
+  virtual int pre_direct_update_rows();
+  virtual bool start_bulk_delete();
+  virtual int end_bulk_delete();
   virtual int delete_row(const uchar * buf);
+  virtual int direct_delete_rows_init();
+  virtual int pre_direct_delete_rows_init();
+  virtual int direct_delete_rows(ha_rows *delete_rows);
+  virtual int pre_direct_delete_rows();
   virtual int delete_all_rows(void);
   virtual int truncate();
   virtual void start_bulk_insert(ha_rows rows, uint flags);
@@ -671,16 +751,8 @@ public:
     read_first_row is virtual method but is only implemented by
     handler.cc, no storage engine has implemented it so neither
     will the partition handler.
-    
-    virtual int read_first_row(uchar *buf, uint primary_key);
-  */
 
-  /*
-    We don't implement multi read range yet, will do later.
-    virtual int read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
-    KEY_MULTI_RANGE *ranges, uint range_count,
-    bool sorted, HANDLER_BUFFER *buffer);
-    virtual int read_multi_range_next(KEY_MULTI_RANGE **found_range_p);
+    virtual int read_first_row(uchar *buf, uint primary_key);
   */
 
 
@@ -689,12 +761,59 @@ public:
 			       bool eq_range, bool sorted);
   virtual int read_range_next();
 
+
+  HANDLER_BUFFER *m_mrr_buffer;
+  uint *m_mrr_buffer_size;
+  uchar *m_mrr_full_buffer;
+  uint m_mrr_full_buffer_size;
+  uint m_mrr_new_full_buffer_size;
+  MY_BITMAP m_mrr_used_partitions;
+  uint *m_stock_range_seq;
+  uint m_current_range_seq;
+  uint m_mrr_mode;
+  uint m_mrr_n_ranges;
+  range_id_t *m_range_info;
+  bool m_multi_range_read_first;
+  uint m_mrr_range_init_flags;
+  uint m_mrr_range_length;
+  PARTITION_KEY_MULTI_RANGE *m_mrr_range_first;
+  PARTITION_KEY_MULTI_RANGE *m_mrr_range_current;
+  uint *m_part_mrr_range_length;
+  PARTITION_PART_KEY_MULTI_RANGE **m_part_mrr_range_first;
+  PARTITION_PART_KEY_MULTI_RANGE **m_part_mrr_range_current;
+  PARTITION_PART_KEY_MULTI_RANGE_HLD *m_partition_part_key_multi_range_hld;
+  range_seq_t m_seq;
+  RANGE_SEQ_IF *m_seq_if;
+  RANGE_SEQ_IF m_part_seq_if;
+
+  virtual int multi_range_key_create_key(
+    RANGE_SEQ_IF *seq,
+    range_seq_t seq_it
+  );
+  virtual ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
+                                              void *seq_init_param,
+                                              uint n_ranges, uint *bufsz,
+                                              uint *mrr_mode,
+                                              Cost_estimate *cost);
+  virtual ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys,
+                                        uint key_parts, uint *bufsz,
+                                        uint *mrr_mode, Cost_estimate *cost);
+  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
+                                    uint n_ranges, uint mrr_mode,
+                                    HANDLER_BUFFER *buf);
+  virtual int multi_range_read_next(range_id_t *range_info);
+  virtual int multi_range_read_explain_info(uint mrr_mode, char *str,
+                                            size_t size);
+  uint last_part() { return m_last_part; }
+
 private:
   bool init_record_priority_queue();
   void destroy_record_priority_queue();
   int common_index_read(uchar * buf, bool have_start_key);
   int common_first_last(uchar * buf);
   int partition_scan_set_up(uchar * buf, bool idx_read_flag);
+  bool check_parallel_search();
+  int handle_pre_scan(bool reverse_order, bool use_parallel);
   int handle_unordered_next(uchar * buf, bool next_same);
   int handle_unordered_scan_next_partition(uchar * buf);
   int handle_ordered_index_scan(uchar * buf, bool reverse_order);
@@ -735,7 +854,7 @@ private:
                                           Query_cache_block_table
                                           **block_table,
                                           handler *file, uint *n);
-  static const uint NO_CURRENT_PART_ID;
+  static const uint NO_CURRENT_PART_ID= NOT_A_PARTITION_ID;
   int loop_extra(enum ha_extra_function operation);
   int loop_extra_alter(enum ha_extra_function operations);
   void late_extra_cache(uint partition_id);
@@ -984,7 +1103,7 @@ public:
     special file for handling names of partitions, engine types.
     HA_REC_NOT_IN_SEQ is always set for partition handler since we cannot
     guarantee that the records will be returned in sequence.
-    HA_CAN_GEOMETRY, HA_CAN_FULLTEXT, HA_CAN_SQL_HANDLER, HA_DUPLICATE_POS,
+    HA_DUPLICATE_POS,
     HA_CAN_INSERT_DELAYED, HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is disabled
     until further investigated.
   */
@@ -1066,7 +1185,7 @@ public:
 
     The maximum supported values is the minimum of all handlers in the table
   */
-  uint min_of_the_max_uint(uint (handler::*operator_func)(void) const) const; 
+  uint min_of_the_max_uint(uint (handler::*operator_func)(void) const) const;
   virtual uint max_supported_record_length() const;
   virtual uint max_supported_keys() const;
   virtual uint max_supported_key_parts() const;
@@ -1111,6 +1230,8 @@ public:
     auto_increment_column_changed
      -------------------------------------------------------------------------
   */
+  virtual bool need_info_for_auto_inc();
+  virtual bool can_use_for_auto_inc_init();
   virtual void get_auto_increment(ulonglong offset, ulonglong increment,
                                   ulonglong nb_desired_values,
                                   ulonglong *first_value,
@@ -1118,16 +1239,17 @@ public:
   virtual void release_auto_increment();
 private:
   virtual int reset_auto_increment(ulonglong value);
+  void update_next_auto_inc_val();
   virtual void lock_auto_increment()
   {
     /* lock already taken */
     if (auto_increment_safe_stmt_log_lock)
       return;
-    DBUG_ASSERT(!auto_increment_lock);
-    if(table_share->tmp_table == NO_TMP_TABLE)
+    if (table_share->tmp_table == NO_TMP_TABLE)
     {
-      auto_increment_lock= TRUE;
       part_share->lock_auto_inc();
+      DBUG_ASSERT(!auto_increment_lock);
+      auto_increment_lock= TRUE;
     }
   }
   virtual void unlock_auto_increment()
@@ -1137,10 +1259,10 @@ private:
       It will be set to false and thus unlocked at the end of the statement by
       ha_partition::release_auto_increment.
     */
-    if(auto_increment_lock && !auto_increment_safe_stmt_log_lock)
+    if (auto_increment_lock && !auto_increment_safe_stmt_log_lock)
     {
-      part_share->unlock_auto_inc();
       auto_increment_lock= FALSE;
+      part_share->unlock_auto_inc();
     }
   }
   virtual void set_auto_increment_if_higher(Field *field)
@@ -1148,6 +1270,8 @@ private:
     ulonglong nr= (((Field_num*) field)->unsigned_flag ||
                    field->val_int() > 0) ? field->val_int() : 0;
     lock_auto_increment();
+    DBUG_ASSERT(part_share->auto_inc_initialized ||
+                !can_use_for_auto_inc_init());
     /* must check when the mutex is taken */
     if (nr >= part_share->next_auto_inc_val)
       part_share->next_auto_inc_val= nr + 1;
@@ -1196,14 +1320,15 @@ public:
     -------------------------------------------------------------------------
     MODULE fulltext index
     -------------------------------------------------------------------------
-    Fulltext stuff not yet.
-    -------------------------------------------------------------------------
-    virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
-    virtual FT_INFO *ft_init_ext(uint flags,uint inx,const uchar *key,
-    uint keylen)
-    { return NULL; }
-    virtual int ft_read(uchar *buf) { return HA_ERR_WRONG_COMMAND; }
   */
+    void ft_close_search(FT_INFO *handler);
+    virtual int ft_init();
+    virtual int pre_ft_init();
+    virtual void ft_end();
+    virtual int pre_ft_end();
+    virtual FT_INFO *ft_init_ext(uint flags, uint inx, String *key);
+    virtual int ft_read(uchar *buf);
+    virtual int pre_ft_read(bool use_parallel);
 
   /*
      -------------------------------------------------------------------------
@@ -1265,6 +1390,16 @@ public:
     virtual bool is_crashed() const;
     virtual int check_for_upgrade(HA_CHECK_OPT *check_opt);
 
+  /*
+    -------------------------------------------------------------------------
+    MODULE condition pushdown
+    -------------------------------------------------------------------------
+  */
+    virtual const COND *cond_push(const COND *cond);
+    virtual void cond_pop();
+    virtual void clear_top_table_fields();
+    virtual int info_push(uint info_type, void *info);
+
     private:
     int handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt, uint flags);
     int handle_opt_part(THD *thd, HA_CHECK_OPT *check_opt, uint part_id,
@@ -1292,6 +1427,7 @@ public:
   /* Enabled keycache for performance reasons, WL#4571 */
     virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT *check_opt);
     virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt);
+    virtual TABLE_LIST *get_next_global_for_child();
 
   /*
     -------------------------------------------------------------------------
@@ -1364,11 +1500,6 @@ public:
   }
 
   friend int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2);
+  friend int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2);
 };
-
-bool print_admin_msg(THD* thd, uint len,
-                            const char* msg_type,
-                            const char* db_name, String &table_name,
-                            const char* op_name, const char *fmt, ...);
-
 #endif /* HA_PARTITION_INCLUDED */
diff --git a/sql/handler.cc b/sql/handler.cc
index 9ad866d92de..bb52f6bb211 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -4110,7 +4110,7 @@ int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
 
 int
 handler::ha_bulk_update_row(const uchar *old_data, const uchar *new_data,
-                            uint *dup_key_found)
+                            ha_rows *dup_key_found)
 {
   DBUG_ASSERT(table_share->tmp_table != NO_TMP_TABLE ||
               m_lock_type == F_WRLCK);
@@ -5396,6 +5396,27 @@ int ha_discover_table_names(THD *thd, LEX_CSTRING *db, MY_DIR *dirp,
 }
 
 
+/*
+int handler::pre_read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
+                                        KEY_MULTI_RANGE *ranges,
+                                        uint range_count,
+                                        bool sorted, HANDLER_BUFFER *buffer,
+                                        bool use_parallel)
+{
+  int result;
+  DBUG_ENTER("handler::pre_read_multi_range_first");
+  result = pre_read_range_first(ranges->start_key.keypart_map ?
+                                &ranges->start_key : 0,
+                                ranges->end_key.keypart_map ?
+                                &ranges->end_key : 0,
+                                test(ranges->range_flag & EQ_RANGE),
+                                sorted,
+                                use_parallel);
+  DBUG_RETURN(result);
+}
+*/
+
+
 /**
   Read first row between two ranges.
   Store ranges for future calls to read_range_next.
@@ -6044,6 +6065,7 @@ int handler::ha_reset()
   /* Reset information about pushed engine conditions */
   cancel_pushed_idx_cond();
   /* Reset information about pushed index conditions */
+  clear_top_table_fields();
   DBUG_RETURN(reset());
 }
 
@@ -6188,6 +6210,59 @@ int handler::ha_delete_row(const uchar *buf)
 }
 
 
+/**
+  Execute a direct update request.  A direct update request updates all
+  qualified rows in a single operation, rather than one row at a time.
+  In a Spider cluster the direct update operation is pushed down to the
+  child levels of the cluster.
+
+  Note that this can't be used in case of statment logging
+
+  @param  update_rows   Number of updated rows.
+
+  @retval 0             Success.
+  @retval != 0          Failure.
+*/
+
+int handler::ha_direct_update_rows(ha_rows *update_rows)
+{
+  int error;
+
+  MYSQL_UPDATE_ROW_START(table_share->db.str, table_share->table_name.str);
+  mark_trx_read_write();
+
+  error = direct_update_rows(update_rows);
+  MYSQL_UPDATE_ROW_DONE(error);
+  return error;
+}
+
+
+/**
+  Execute a direct delete request.  A direct delete request deletes all
+  qualified rows in a single operation, rather than one row at a time.
+  In a Spider cluster the direct delete operation is pushed down to the
+  child levels of the cluster.
+
+  @param  delete_rows   Number of deleted rows.
+
+  @retval 0             Success.
+  @retval != 0          Failure.
+*/
+
+int handler::ha_direct_delete_rows(ha_rows *delete_rows)
+{
+  int error;
+  /* Ensure we are not using binlog row */
+  DBUG_ASSERT(!table->in_use->is_current_stmt_binlog_format_row());
+
+  MYSQL_DELETE_ROW_START(table_share->db.str, table_share->table_name.str);
+  mark_trx_read_write();
+
+  error = direct_delete_rows(delete_rows);
+  MYSQL_DELETE_ROW_DONE(error);
+  return error;
+}
+
 
 /** @brief
   use_hidden_primary_key() is called in case of an update/delete when
diff --git a/sql/handler.h b/sql/handler.h
index 50e8d7e0e78..6fbb61c902c 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -162,6 +162,7 @@ enum enum_alter_inplace_result {
 */
 #define HA_BINLOG_ROW_CAPABLE  (1ULL << 34)
 #define HA_BINLOG_STMT_CAPABLE (1ULL << 35)
+
 /*
     When a multiple key conflict happens in a REPLACE command mysql
     expects the conflicts to be reported in the ascending order of
@@ -287,6 +288,17 @@ enum enum_alter_inplace_result {
  */
 #define HA_BINLOG_FLAGS (HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE)
 
+/* The following are used by Spider */
+#define HA_CAN_FORCE_BULK_UPDATE (1ULL << 50)
+#define HA_CAN_FORCE_BULK_DELETE (1ULL << 51)
+#define HA_CAN_DIRECT_UPDATE_AND_DELETE (1ULL << 52)
+
+/* The following is for partition handler */
+#define HA_CAN_MULTISTEP_MERGE (1LL << 53)
+
+/* calling cmp_ref() on the engine is expensive */
+#define HA_CMP_REF_IS_EXPENSIVE (1ULL << 54)
+
 /* bits in index_flags(index_number) for what you can do with index */
 #define HA_READ_NEXT            1       /* TODO really use this flag */
 #define HA_READ_PREV            2       /* supports ::index_prev */
@@ -438,6 +450,12 @@ static const uint MYSQL_START_TRANS_OPT_READ_WRITE         = 4;
 #define HA_CHECK_DUP (HA_CHECK_DUP_KEY + HA_CHECK_DUP_UNIQUE)
 #define HA_CHECK_ALL (~0U)
 
+/* Options for info_push() */
+#define INFO_KIND_UPDATE_FIELDS       101
+#define INFO_KIND_UPDATE_VALUES       102
+#define INFO_KIND_FORCE_LIMIT_BEGIN   103
+#define INFO_KIND_FORCE_LIMIT_END     104
+
 enum legacy_db_type
 {
   /* note these numerical values are fixed and can *not* be changed */
@@ -1447,6 +1465,10 @@ handlerton *ha_default_tmp_handlerton(THD *thd);
 // MySQL compatibility. Unused.
 #define HTON_SUPPORTS_FOREIGN_KEYS   (1 << 0) //Foreign key constraint supported.
 
+#define HTON_CAN_MERGE               (1 <<11) //Merge type table
+// Engine needs to access the main connect string in partitions
+#define HTON_CAN_READ_CONNECT_STRING_IN_PARTITION (1 <<12)
+
 class Ha_trx_info;
 
 struct THD_TRANS
@@ -2816,7 +2838,8 @@ public:
   /** Length of ref (1-8 or the clustered key length) */
   uint ref_length;
   FT_INFO *ft_handler;
-  enum {NONE=0, INDEX, RND} inited;
+  enum init_stat { NONE=0, INDEX, RND };
+  init_stat inited, pre_inited;
 
   const COND *pushed_cond;
   /**
@@ -2882,6 +2905,11 @@ public:
   virtual void unbind_psi();
   virtual void rebind_psi();
 
+  bool set_top_table_fields;
+  struct TABLE *top_table;
+  Field **top_table_field;
+  uint top_table_fields;
+
 private:
   /**
     The lock type set by when calling::ha_external_lock(). This is 
@@ -2910,13 +2938,15 @@ public:
     key_used_on_scan(MAX_KEY),
     active_index(MAX_KEY), keyread(MAX_KEY),
     ref_length(sizeof(my_off_t)),
-    ft_handler(0), inited(NONE),
+    ft_handler(0), inited(NONE), pre_inited(NONE),
     pushed_cond(0), next_insert_id(0), insert_id_for_cur_row(0),
     tracker(NULL),
     pushed_idx_cond(NULL),
     pushed_idx_cond_keyno(MAX_KEY),
     auto_inc_intervals_count(0),
-    m_psi(NULL), m_lock_type(F_UNLCK), ha_share(NULL)
+    m_psi(NULL), set_top_table_fields(FALSE), top_table(0),
+    top_table_field(0), top_table_fields(0),
+    m_lock_type(F_UNLCK), ha_share(NULL)
   {
     DBUG_PRINT("info",
                ("handler created F_UNLCK %d F_RDLCK %d F_WRLCK %d",
@@ -3049,7 +3079,7 @@ public:
     DBUG_RETURN(ret);
   }
   int ha_bulk_update_row(const uchar *old_data, const uchar *new_data,
-                         uint *dup_key_found);
+                         ha_rows *dup_key_found);
   int ha_delete_all_rows();
   int ha_truncate();
   int ha_reset_auto_increment(ulonglong value);
@@ -3190,6 +3220,7 @@ public:
     Number of rows in table. It will only be called if
     (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
   */
+  virtual int pre_records() { return 0; }
   virtual ha_rows records() { return stats.records; }
   /**
     Return upper bound of current number of records in the table
@@ -3246,7 +3277,7 @@ public:
     @retval  0           Success
     @retval  >0          Error code
   */
-  virtual int exec_bulk_update(uint *dup_key_found)
+  virtual int exec_bulk_update(ha_rows *dup_key_found)
   {
     DBUG_ASSERT(FALSE);
     return HA_ERR_WRONG_COMMAND;
@@ -3255,7 +3286,7 @@ public:
     Perform any needed clean-up, no outstanding updates are there at the
     moment.
   */
-  virtual void end_bulk_update() { return; }
+  virtual int end_bulk_update() { return 0; }
   /**
     Execute all outstanding deletes and close down the bulk delete.
 
@@ -3267,6 +3298,79 @@ public:
     DBUG_ASSERT(FALSE);
     return HA_ERR_WRONG_COMMAND;
   }
+  virtual int pre_index_read_map(const uchar *key,
+                                 key_part_map keypart_map,
+                                 enum ha_rkey_function find_flag,
+                                 bool use_parallel)
+   { return 0; }
+  virtual int pre_index_first(bool use_parallel)
+   { return 0; }
+  virtual int pre_index_last(bool use_parallel)
+   { return 0; }
+  virtual int pre_index_read_last_map(const uchar *key,
+                                      key_part_map keypart_map,
+                                      bool use_parallel)
+   { return 0; }
+/*
+  virtual int pre_read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
+                                         KEY_MULTI_RANGE *ranges,
+                                         uint range_count,
+                                         bool sorted, HANDLER_BUFFER *buffer,
+                                         bool use_parallel);
+*/
+  virtual int pre_multi_range_read_next(bool use_parallel)
+  { return 0; }
+  virtual int pre_read_range_first(const key_range *start_key,
+                                   const key_range *end_key,
+                                   bool eq_range, bool sorted,
+                                   bool use_parallel)
+   { return 0; }
+  virtual int pre_ft_read(bool use_parallel)
+   { return 0; }
+  virtual int pre_rnd_next(bool use_parallel)
+   { return 0; }
+  int ha_pre_rnd_init(bool scan)
+  {
+    int result;
+    DBUG_ENTER("ha_pre_rnd_init");
+    DBUG_ASSERT(pre_inited==NONE || (pre_inited==RND && scan));
+    pre_inited= (result= pre_rnd_init(scan)) ? NONE: RND;
+    DBUG_RETURN(result);
+  }
+  int ha_pre_rnd_end()
+  {
+    DBUG_ENTER("ha_pre_rnd_end");
+    DBUG_ASSERT(pre_inited==RND);
+    pre_inited=NONE;
+    DBUG_RETURN(pre_rnd_end());
+  }
+  virtual int pre_rnd_init(bool scan) { return 0; }
+  virtual int pre_rnd_end() { return 0; }
+  virtual int pre_index_init(uint idx, bool sorted) { return 0; }
+  virtual int pre_index_end() { return 0; }
+  int ha_pre_index_init(uint idx, bool sorted)
+  {
+    int result;
+    DBUG_ENTER("ha_pre_index_init");
+    DBUG_ASSERT(pre_inited==NONE);
+    if (!(result= pre_index_init(idx, sorted)))
+      pre_inited=INDEX;
+    DBUG_RETURN(result);
+  }
+  int ha_pre_index_end()
+  {
+    DBUG_ENTER("ha_pre_index_end");
+    DBUG_ASSERT(pre_inited==INDEX);
+    pre_inited=NONE;
+    DBUG_RETURN(pre_index_end());
+  }
+  int ha_pre_index_or_rnd_end()
+  {
+    return (pre_inited == INDEX ?
+            ha_pre_index_end() :
+            pre_inited == RND ? ha_pre_rnd_end() : 0 );
+  }
+
   /**
      @brief
      Positions an index cursor to the index specified in the
@@ -3387,7 +3491,9 @@ public:
   int compare_key(key_range *range);
   int compare_key2(key_range *range) const;
   virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
-  void ft_end() { ft_handler=NULL; }
+  virtual int pre_ft_init() { return HA_ERR_WRONG_COMMAND; }
+  virtual void ft_end() {}
+  virtual int pre_ft_end() { return 0; }
   virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
     { return NULL; }
 public:
@@ -3410,6 +3516,7 @@ public:
 
   /* Same as above, but with statistics */
   inline int ha_ft_read(uchar *buf);
+  inline void ha_ft_end() { ft_end(); ft_handler=NULL; }
   int ha_rnd_next(uchar *buf);
   int ha_rnd_pos(uchar *buf, uchar *pos);
   inline int ha_rnd_pos_by_record(uchar *buf);
@@ -3467,6 +3574,8 @@ public:
   virtual void try_semi_consistent_read(bool) {}
   virtual void unlock_row() {}
   virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
+  virtual bool need_info_for_auto_inc() { return 0; }
+  virtual bool can_use_for_auto_inc_init() { return 1; }
   virtual void get_auto_increment(ulonglong offset, ulonglong increment,
                                   ulonglong nb_desired_values,
                                   ulonglong *first_value,
@@ -3574,6 +3683,7 @@ public:
     return 0;
   }
   virtual void set_part_info(partition_info *part_info) {return;}
+  virtual void return_record_by_parent() { return; }
 
   virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
 
@@ -3778,6 +3888,41 @@ public:
  virtual void cond_pop() { return; };
 
  /**
+   Push metadata for the current operation down to the table handler.
+ */
+ virtual int info_push(uint info_type, void *info) { return 0; };
+
+ /**
+    This function is used to get correlating of a parent (table/column)
+    and children (table/column). When conditions are pushed down to child
+    table (like child of myisam_merge), child table needs to know about
+    which table/column is my parent for understanding conditions.
+ */
+ virtual int set_top_table_and_fields(TABLE *top_table,
+                                      Field **top_table_field,
+                                      uint top_table_fields)
+ {
+   if (!set_top_table_fields)
+   {
+     set_top_table_fields= TRUE;
+     this->top_table= top_table;
+     this->top_table_field= top_table_field;
+     this->top_table_fields= top_table_fields;
+   }
+   return 0;
+ }
+ virtual void clear_top_table_fields()
+ {
+   if (set_top_table_fields)
+   {
+     set_top_table_fields= FALSE;
+     top_table= NULL;
+     top_table_field= NULL;
+     top_table_fields= 0;
+   }
+ }
+
+ /**
    Push down an index condition to the handler.
 
    The server will use this method to push down a condition it wants
@@ -3810,6 +3955,10 @@ public:
    pushed_idx_cond_keyno= MAX_KEY;
    in_range_check_pushed_down= false;
  }
+
+ /* Needed for partition / spider */
+  virtual TABLE_LIST *get_next_global_for_child() { return NULL; }
+
  /**
    Part of old, deprecated in-place ALTER API.
  */
@@ -4195,6 +4344,49 @@ private:
   {
     return HA_ERR_WRONG_COMMAND;
   }
+
+  /* Perform initialization for a direct update request */
+public:
+  int ha_direct_update_rows(ha_rows *update_rows);
+  virtual int direct_update_rows_init()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+private:
+  virtual int pre_direct_update_rows_init()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+  virtual int direct_update_rows(ha_rows *update_rows __attribute__((unused)))
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+  virtual int pre_direct_update_rows()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+
+  /* Perform initialization for a direct delete request */
+public:
+  int ha_direct_delete_rows(ha_rows *delete_rows);
+  virtual int direct_delete_rows_init()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+private:
+  virtual int pre_direct_delete_rows_init()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+  virtual int direct_delete_rows(ha_rows *delete_rows __attribute__((unused)))
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+  virtual int pre_direct_delete_rows()
+  {
+    return HA_ERR_WRONG_COMMAND;
+  }
+
   /**
     Reset state of file to after 'open'.
     This function is called after every statement for all tables used
@@ -4274,7 +4466,7 @@ public:
     @retval  1   Bulk delete not used, normal operation used
   */
   virtual int bulk_update_row(const uchar *old_data, const uchar *new_data,
-                              uint *dup_key_found)
+                              ha_rows *dup_key_found)
   {
     DBUG_ASSERT(FALSE);
     return HA_ERR_WRONG_COMMAND;
diff --git a/sql/item.cc b/sql/item.cc
index 88cd7305fdd..cde9170b990 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -538,7 +538,6 @@ Item::Item(THD *thd):
   marker= 0;
   maybe_null=null_value=with_sum_func=with_window_func=with_field=0;
   in_rollup= 0;
-  with_subselect= 0;
    /* Initially this item is not attached to any JOIN_TAB. */
   join_tab_idx= MAX_TABLES;
 
@@ -583,8 +582,7 @@ Item::Item(THD *thd, Item *item):
   with_window_func(item->with_window_func),
   with_field(item->with_field),
   fixed(item->fixed),
-  is_autogenerated_name(item->is_autogenerated_name),
-  with_subselect(item->has_subquery())
+  is_autogenerated_name(item->is_autogenerated_name)
 {
   next= thd->free_list;				// Put in free list
   thd->free_list= this;
@@ -2732,6 +2730,252 @@ Item* Item_func_or_sum::build_clone(THD *thd)
   return copy;
 }
 
+Item_sp::Item_sp(THD *thd, Name_resolution_context *context_arg,
+                 sp_name *name_arg) :
+  context(context_arg), m_name(name_arg), m_sp(NULL), func_ctx(NULL),
+  sp_result_field(NULL)
+{
+  dummy_table= (TABLE*) thd->calloc(sizeof(TABLE) + sizeof(TABLE_SHARE) +
+                                    sizeof(Query_arena));
+  dummy_table->s= (TABLE_SHARE*) (dummy_table + 1);
+  /* TODO(cvicentiu) Move this sp_query_arena in the class as a direct member.
+     Currently it can not be done due to header include dependencies. */
+  sp_query_arena= (Query_arena *) (dummy_table->s + 1);
+  memset(&sp_mem_root, 0, sizeof(sp_mem_root));
+}
+
+const char *
+Item_sp::func_name(THD *thd) const
+{
+  /* Calculate length to avoid reallocation of string for sure */
+  uint len= (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
+              m_name->m_name.length)*2 + //characters*quoting
+             2 +                         // ` and `
+             (m_name->m_explicit_name ?
+              3 : 0) +                   // '`', '`' and '.' for the db
+             1 +                         // end of string
+             ALIGN_SIZE(1));             // to avoid String reallocation
+  String qname((char *)alloc_root(thd->mem_root, len), len,
+               system_charset_info);
+
+  qname.length(0);
+  if (m_name->m_explicit_name)
+  {
+    append_identifier(thd, &qname, m_name->m_db.str, m_name->m_db.length);
+    qname.append('.');
+  }
+  append_identifier(thd, &qname, m_name->m_name.str, m_name->m_name.length);
+  return qname.c_ptr_safe();
+}
+
+void
+Item_sp::cleanup()
+{
+  delete sp_result_field;
+  sp_result_field= NULL;
+  m_sp= NULL;
+  delete func_ctx;
+  func_ctx= NULL;
+  free_root(&sp_mem_root, MYF(0));
+  dummy_table->alias.free();
+}
+
+/**
+  @brief Checks if requested access to function can be granted to user.
+    If function isn't found yet, it searches function first.
+    If function can't be found or user don't have requested access
+    error is raised.
+
+  @param thd thread handler
+
+  @return Indication if the access was granted or not.
+  @retval FALSE Access is granted.
+  @retval TRUE Requested access can't be granted or function doesn't exists.
+
+*/
+bool
+Item_sp::sp_check_access(THD *thd)
+{
+  DBUG_ENTER("Item_sp::sp_check_access");
+  DBUG_ASSERT(m_sp);
+  DBUG_RETURN(m_sp->check_execute_access(thd));
+}
+
+/**
+  @brief Execute function & store value in field.
+
+  @return Function returns error status.
+  @retval FALSE on success.
+  @retval TRUE if an error occurred.
+*/
+bool Item_sp::execute(THD *thd, bool *null_value, Item **args, uint arg_count)
+{
+  if (execute_impl(thd, args, arg_count))
+  {
+    *null_value= 1;
+    context->process_error(thd);
+    if (thd->killed)
+      thd->send_kill_message();
+    return true;
+  }
+
+  /* Check that the field (the value) is not NULL. */
+
+  *null_value= sp_result_field->is_null();
+  return (*null_value);
+}
+
+/**
+   @brief Execute function and store the return value in the field.
+
+   @note This function was intended to be the concrete implementation of
+    the interface function execute. This was never realized.
+
+   @return The error state.
+   @retval FALSE on success
+   @retval TRUE if an error occurred.
+*/
+bool
+Item_sp::execute_impl(THD *thd, Item **args, uint arg_count)
+{
+  Sub_statement_state statement_state;
+  Security_context *save_security_ctx= thd->security_ctx;
+  enum enum_sp_data_access access=
+    (m_sp->daccess() == SP_DEFAULT_ACCESS) ?
+     SP_DEFAULT_ACCESS_MAPPING : m_sp->daccess();
+
+  DBUG_ENTER("Item_sp::execute_impl");
+
+  if (context->security_ctx)
+  {
+    /* Set view definer security context */
+    thd->security_ctx= context->security_ctx;
+  }
+
+  if (sp_check_access(thd))
+  {
+    thd->security_ctx= save_security_ctx;
+    DBUG_RETURN(TRUE);
+  }
+
+  /*
+    Throw an error if a non-deterministic function is called while
+    statement-based replication (SBR) is active.
+  */
+
+  if (!m_sp->detistic() && !trust_function_creators &&
+      (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) &&
+      (mysql_bin_log.is_open() &&
+       thd->variables.binlog_format == BINLOG_FORMAT_STMT))
+  {
+    my_error(ER_BINLOG_UNSAFE_ROUTINE, MYF(0));
+    thd->security_ctx= save_security_ctx;
+    DBUG_RETURN(TRUE);
+  }
+
+  /*
+    Disable the binlogging if this is not a SELECT statement. If this is a
+    SELECT, leave binlogging on, so execute_function() code writes the
+    function call into binlog.
+  */
+  thd->reset_sub_statement_state(&statement_state, SUB_STMT_FUNCTION);
+
+  /*
+     If this function is an aggregate function, we want to initialise the
+     mem_root only once per group. For a regular stored function, we will
+     initialise once for each call to execute_function.
+  */
+  m_sp->agg_type();
+  DBUG_ASSERT(m_sp->agg_type() == GROUP_AGGREGATE ||
+              (m_sp->agg_type() == NOT_AGGREGATE && !func_ctx));
+  if (!func_ctx)
+  {
+    init_sql_alloc(&sp_mem_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(0));
+    *sp_query_arena= Query_arena(&sp_mem_root,
+                                 Query_arena::STMT_INITIALIZED_FOR_SP);
+  }
+
+  bool err_status= m_sp->execute_function(thd, args, arg_count,
+                                          sp_result_field, &func_ctx,
+                                          sp_query_arena);
+  /*
+     We free the function context when the function finished executing normally
+     (quit_func == TRUE) or the function has exited with an error.
+  */
+  if (err_status || func_ctx->quit_func)
+  {
+    /* Free Items allocated during function execution. */
+    delete func_ctx;
+    func_ctx= NULL;
+    sp_query_arena->free_items();
+    free_root(&sp_mem_root, MYF(0));
+    memset(&sp_mem_root, 0, sizeof(sp_mem_root));
+  }
+  thd->restore_sub_statement_state(&statement_state);
+
+  thd->security_ctx= save_security_ctx;
+  DBUG_RETURN(err_status);
+}
+
+
+/**
+  @brief Initialize the result field by creating a temporary dummy table
+    and assign it to a newly created field object. Meta data used to
+    create the field is fetched from the sp_head belonging to the stored
+    proceedure found in the stored procedure functon cache.
+
+  @note This function should be called from fix_fields to init the result
+    field. It is some what related to Item_field.
+
+  @see Item_field
+
+  @param thd A pointer to the session and thread context.
+
+  @return Function return error status.
+  @retval TRUE is returned on an error
+  @retval FALSE is returned on success.
+*/
+
+bool
+Item_sp::init_result_field(THD *thd, uint max_length, uint maybe_null,
+                           bool *null_value, LEX_CSTRING *name)
+{
+  DBUG_ENTER("Item_sp::init_result_field");
+
+  DBUG_ASSERT(m_sp != NULL);
+  DBUG_ASSERT(sp_result_field == NULL);
+
+  /*
+     A Field needs to be attached to a Table.
+     Below we "create" a dummy table by initializing
+     the needed pointers.
+   */
+  dummy_table->alias.set("", 0, table_alias_charset);
+  dummy_table->in_use= thd;
+  dummy_table->copy_blobs= TRUE;
+  dummy_table->s->table_cache_key= empty_clex_str;
+  dummy_table->s->table_name= empty_clex_str;
+  dummy_table->maybe_null= maybe_null;
+
+  if (!(sp_result_field= m_sp->create_result_field(max_length, name,
+                                                   dummy_table)))
+   DBUG_RETURN(TRUE);
+
+  if (sp_result_field->pack_length() > sizeof(result_buf))
+  {
+    void *tmp;
+    if (!(tmp= thd->alloc(sp_result_field->pack_length())))
+      DBUG_RETURN(TRUE);
+    sp_result_field->move_field((uchar*) tmp);
+  }
+  else
+    sp_result_field->move_field(result_buf);
+
+  sp_result_field->null_ptr= (uchar *) null_value;
+  sp_result_field->null_bit= 1;
+
+  DBUG_RETURN(FALSE);
+}
 
 /**
   @brief
@@ -3714,20 +3958,6 @@ Item *Item_null::clone_item(THD *thd)
 
 /*********************** Item_param related ******************************/
 
-/** 
-  Default function of Item_param::set_param_func, so in case
-  of malformed packet the server won't SIGSEGV.
-*/
-
-static void
-default_set_param_func(Item_param *param,
-                       uchar **pos __attribute__((unused)),
-                       ulong len __attribute__((unused)))
-{
-  param->set_null();
-}
-
-
 Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
                        uint pos_in_query_arg, uint len_in_query_arg):
   Item_basic_value(thd),
@@ -3745,8 +3975,8 @@ Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
   state(NO_VALUE),
   /* Don't pretend to be a literal unless value for this item is set. */
   item_type(PARAM_ITEM),
+  m_empty_string_is_null(false),
   indicator(STMT_INDICATOR_NONE),
-  set_param_func(default_set_param_func),
   m_out_param_info(NULL),
   /*
     Set m_is_settable_routine_parameter to "true" by default.
@@ -3787,8 +4017,10 @@ void Item_param::set_null()
 void Item_param::set_int(longlong i, uint32 max_length_arg)
 {
   DBUG_ENTER("Item_param::set_int");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == INT_RESULT);
   value.integer= (longlong) i;
-  state= INT_VALUE;
+  state= SHORT_DATA_VALUE;
+  collation.set_numeric();
   max_length= max_length_arg;
   decimals= 0;
   maybe_null= 0;
@@ -3799,8 +4031,10 @@ void Item_param::set_int(longlong i, uint32 max_length_arg)
 void Item_param::set_double(double d)
 {
   DBUG_ENTER("Item_param::set_double");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == REAL_RESULT);
   value.real= d;
-  state= REAL_VALUE;
+  state= SHORT_DATA_VALUE;
+  collation.set_numeric();
   max_length= DBL_DIG + 8;
   decimals= NOT_FIXED_DEC;
   maybe_null= 0;
@@ -3825,13 +4059,15 @@ void Item_param::set_decimal(const char *str, ulong length)
 {
   char *end;
   DBUG_ENTER("Item_param::set_decimal");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == DECIMAL_RESULT);
 
   end= (char*) str+length;
-  str2my_decimal(E_DEC_FATAL_ERROR, str, &decimal_value, &end);
-  state= DECIMAL_VALUE;
-  decimals= decimal_value.frac;
+  str2my_decimal(E_DEC_FATAL_ERROR, str, &value.m_decimal, &end);
+  state= SHORT_DATA_VALUE;
+  decimals= value.m_decimal.frac;
+  collation.set_numeric();
   max_length=
-    my_decimal_precision_to_length_no_truncation(decimal_value.precision(),
+    my_decimal_precision_to_length_no_truncation(value.m_decimal.precision(),
                                                  decimals, unsigned_flag);
   maybe_null= 0;
   fix_type(Item::DECIMAL_ITEM);
@@ -3840,13 +4076,15 @@ void Item_param::set_decimal(const char *str, ulong length)
 
 void Item_param::set_decimal(const my_decimal *dv, bool unsigned_arg)
 {
-  state= DECIMAL_VALUE;
+  DBUG_ASSERT(value.type_handler()->cmp_type() == DECIMAL_RESULT);
+  state= SHORT_DATA_VALUE;
 
-  my_decimal2decimal(dv, &decimal_value);
+  my_decimal2decimal(dv, &value.m_decimal);
 
-  decimals= (uint8) decimal_value.frac;
+  decimals= (uint8) value.m_decimal.frac;
+  collation.set_numeric();
   unsigned_flag= unsigned_arg;
-  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
+  max_length= my_decimal_precision_to_length(value.m_decimal.intg + decimals,
                                              decimals, unsigned_flag);
   fix_type(Item::DECIMAL_ITEM);
 }
@@ -3854,7 +4092,8 @@ void Item_param::set_decimal(const my_decimal *dv, bool unsigned_arg)
 
 void Item_param::fix_temporal(uint32 max_length_arg, uint decimals_arg)
 {
-  state= TIME_VALUE;
+  state= SHORT_DATA_VALUE;
+  collation.set_numeric();
   max_length= max_length_arg;
   decimals= decimals_arg;
   fix_type(Item::DATE_ITEM);
@@ -3864,6 +4103,7 @@ void Item_param::fix_temporal(uint32 max_length_arg, uint decimals_arg)
 void Item_param::set_time(const MYSQL_TIME *tm,
                           uint32 max_length_arg, uint decimals_arg)
 {
+  DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT);
   value.time= *tm;
   fix_temporal(max_length_arg, decimals_arg);
 }
@@ -3886,6 +4126,7 @@ void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
                           uint32 max_length_arg)
 { 
   DBUG_ENTER("Item_param::set_time");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT);
 
   value.time= *tm;
   value.time.time_type= time_type;
@@ -3904,18 +4145,34 @@ void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
 }
 
 
-bool Item_param::set_str(const char *str, ulong length)
+bool Item_param::set_str(const char *str, ulong length,
+                         CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
 {
   DBUG_ENTER("Item_param::set_str");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == STRING_RESULT);
   /*
     Assign string with no conversion: data is converted only after it's
     been written to the binary log.
   */
   uint dummy_errors;
-  if (str_value.copy(str, length, &my_charset_bin, &my_charset_bin,
-                     &dummy_errors))
+  if (value.m_string.copy(str, length, fromcs, tocs, &dummy_errors))
     DBUG_RETURN(TRUE);
-  state= STRING_VALUE;
+  /*
+    Set str_value_ptr to make sure it's in sync with str_value.
+    This is needed in case if we're called from Item_param::set_value(),
+    from the code responsible for setting OUT parameters in
+    sp_head::execute_procedure(). This makes sure that
+    Protocol_binary::send_out_parameters() later gets a valid value
+    from Item_param::val_str().
+    Note, for IN parameters, Item_param::convert_str_value() will be called
+    later, which will convert the value from the client character set to the
+    connection character set, and will reset both str_value and str_value_ptr.
+  */
+  value.m_string_ptr.set(value.m_string.ptr(),
+                         value.m_string.length(),
+                         value.m_string.charset());
+  state= SHORT_DATA_VALUE;
+  collation.set(tocs, DERIVATION_COERCIBLE);
   max_length= length;
   maybe_null= 0;
   /* max_length and decimals are set after charset conversion */
@@ -3928,6 +4185,7 @@ bool Item_param::set_str(const char *str, ulong length)
 bool Item_param::set_longdata(const char *str, ulong length)
 {
   DBUG_ENTER("Item_param::set_longdata");
+  DBUG_ASSERT(value.type_handler()->cmp_type() == STRING_RESULT);
 
   /*
     If client character set is multibyte, end of long data packet
@@ -3938,7 +4196,7 @@ bool Item_param::set_longdata(const char *str, ulong length)
     (here), and first have to concatenate all pieces together,
     write query to the binary log and only then perform conversion.
   */
-  if (str_value.length() + length > max_long_data_size)
+  if (value.m_string.length() + length > max_long_data_size)
   {
     my_message(ER_UNKNOWN_ERROR,
                "Parameter of prepared statement which is set through "
@@ -3948,7 +4206,7 @@ bool Item_param::set_longdata(const char *str, ulong length)
     DBUG_RETURN(true);
   }
 
-  if (str_value.append(str, length, &my_charset_bin))
+  if (value.m_string.append(str, length, &my_charset_bin))
     DBUG_RETURN(TRUE);
   state= LONG_DATA_VALUE;
   maybe_null= 0;
@@ -4011,16 +4269,16 @@ bool Item_param::set_from_item(THD *thd, Item *item)
     else
     {
       unsigned_flag= item->unsigned_flag;
-      set_int(val, MY_INT64_NUM_DECIMAL_DIGITS);
-      set_handler_by_result_type(item->result_type());
-      DBUG_RETURN(!unsigned_flag && value.integer < 0 ? 1 : 0);
+      set_handler(item->type_handler());
+      DBUG_RETURN(set_limit_clause_param(val));
     }
   }
   struct st_value tmp;
   if (!item->save_in_value(&tmp))
   {
-    if (item->type_handler()->Item_param_set_from_value(thd, this, item, &tmp))
-      DBUG_RETURN(true);
+    const Type_handler *h= item->type_handler();
+    set_handler(h);
+    DBUG_RETURN(set_value(thd, item, &tmp, h));
   }
   else
     set_null();
@@ -4040,16 +4298,16 @@ void Item_param::reset()
 {
   DBUG_ENTER("Item_param::reset");
   /* Shrink string buffer if it's bigger than max possible CHAR column */
-  if (str_value.alloced_length() > MAX_CHAR_WIDTH)
-    str_value.free();
+  if (value.m_string.alloced_length() > MAX_CHAR_WIDTH)
+    value.m_string.free();
   else
-    str_value.length(0);
-  str_value_ptr.length(0);
+    value.m_string.length(0);
+  value.m_string_ptr.length(0);
   /*
     We must prevent all charset conversions until data has been written
     to the binary log.
   */
-  str_value.set_charset(&my_charset_bin);
+  value.m_string.set_charset(&my_charset_bin);
   collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
   state= NO_VALUE;
   maybe_null= 1;
@@ -4078,19 +4336,9 @@ int Item_param::save_in_field(Field *field, bool no_conversions)
     Garbage (e.g. in case of a memory overrun) is handled after the switch.
   */
   switch (state) {
-  case INT_VALUE:
-    return field->store(value.integer, unsigned_flag);
-  case REAL_VALUE:
-    return field->store(value.real);
-  case DECIMAL_VALUE:
-    return field->store_decimal(&decimal_value);
-  case TIME_VALUE:
-    field->store_time_dec(&value.time, decimals);
-    return 0;
-  case STRING_VALUE:
+  case SHORT_DATA_VALUE:
   case LONG_DATA_VALUE:
-    return field->store(str_value.ptr(), str_value.length(),
-                        str_value.charset());
+    return value.type_handler()->Item_save_in_field(this, field, no_conversions);
   case NULL_VALUE:
     return set_field_to_null_with_conversions(field, no_conversions);
   case DEFAULT_VALUE:
@@ -4110,6 +4358,28 @@ int Item_param::save_in_field(Field *field, bool no_conversions)
 }
 
 
+bool Item_param::can_return_value() const
+{
+  // There's no "default". See comments in Item_param::save_in_field().
+  switch (state) {
+  case SHORT_DATA_VALUE:
+  case LONG_DATA_VALUE:
+    return true;
+  case IGNORE_VALUE:
+  case DEFAULT_VALUE:
+    invalid_default_param();
+    // fall through
+  case NULL_VALUE:
+    return false;
+  case NO_VALUE:
+    DBUG_ASSERT(0); // Should not be possible
+    return false;
+  }
+  DBUG_ASSERT(0); // Garbage
+  return false;
+}
+
+
 void Item_param::invalid_default_param() const
 {
   my_message(ER_INVALID_DEFAULT_PARAM,
@@ -4119,7 +4389,14 @@ void Item_param::invalid_default_param() const
 
 bool Item_param::get_date(MYSQL_TIME *res, ulonglong fuzzydate)
 {
-  if (state == TIME_VALUE)
+  /*
+    LIMIT clause parameter should not call get_date()
+    For non-LIMIT parameters, handlers must be the same.
+  */
+  DBUG_ASSERT(type_handler()->result_type() ==
+              value.type_handler()->result_type());
+  if (state == SHORT_DATA_VALUE &&
+      value.type_handler()->cmp_type() == TIME_RESULT)
   {
     *res= value.time;
     return 0;
@@ -4128,157 +4405,117 @@ bool Item_param::get_date(MYSQL_TIME *res, ulonglong fuzzydate)
 }
 
 
-double Item_param::val_real()
+double Item_param::PValue::val_real() const
 {
-  // There's no "default". See comments in Item_param::save_in_field().
-  switch (state) {
-  case REAL_VALUE:
-    return value.real;
-  case INT_VALUE:
-    return (double) value.integer;
-  case DECIMAL_VALUE:
+  switch (type_handler()->cmp_type()) {
+  case REAL_RESULT:
+    return real;
+  case INT_RESULT:
+    return (double) integer;
+  case DECIMAL_RESULT:
   {
     double result;
-    my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &result);
+    my_decimal2double(E_DEC_FATAL_ERROR, &m_decimal, &result);
     return result;
   }
-  case STRING_VALUE:
-  case LONG_DATA_VALUE:
-  {
-    return double_from_string_with_check(&str_value);
-  }
-  case TIME_VALUE:
+  case STRING_RESULT:
+    return double_from_string_with_check(&m_string);
+  case TIME_RESULT:
     /*
       This works for example when user says SELECT ?+0.0 and supplies
       time value for the placeholder.
     */
-    return TIME_to_double(&value.time);
-  case IGNORE_VALUE:
-  case DEFAULT_VALUE:
-    invalid_default_param();
-    // fall through
-  case NULL_VALUE:
-    return 0.0;
-  case NO_VALUE:
-    DBUG_ASSERT(0); // Should not be possible
-    return 0.0;
+    return TIME_to_double(&time);
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
   }
-  DBUG_ASSERT(0); // Garbage
   return 0.0;
-} 
+}
 
 
-longlong Item_param::val_int() 
-{ 
-  // There's no "default". See comments in Item_param::save_in_field().
-  switch (state) {
-  case REAL_VALUE:
-    return (longlong) rint(value.real);
-  case INT_VALUE:
-    return value.integer;
-  case DECIMAL_VALUE:
+longlong Item_param::PValue::val_int(const Type_std_attributes *attr) const
+{
+  switch (type_handler()->cmp_type()) {
+  case REAL_RESULT:
+    return (longlong) rint(real);
+  case INT_RESULT:
+    return integer;
+  case DECIMAL_RESULT:
   {
     longlong i;
-    my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &i);
+    my_decimal2int(E_DEC_FATAL_ERROR, &m_decimal, attr->unsigned_flag, &i);
     return i;
   }
-  case STRING_VALUE:
-  case LONG_DATA_VALUE:
-    {
-      return longlong_from_string_with_check(&str_value);
-    }
-  case TIME_VALUE:
-    return (longlong) TIME_to_ulonglong(&value.time);
-  case IGNORE_VALUE:
-  case DEFAULT_VALUE:
-    invalid_default_param();
-    // fall through
-  case NULL_VALUE:
-    return 0; 
-  case NO_VALUE:
-    DBUG_ASSERT(0); // Should not be possible
-    return 0;
+  case STRING_RESULT:
+    return longlong_from_string_with_check(&m_string);
+  case TIME_RESULT:
+    return (longlong) TIME_to_ulonglong(&time);
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
   }
-  DBUG_ASSERT(0); // Garbage
   return 0;
 }
 
 
-my_decimal *Item_param::val_decimal(my_decimal *dec)
+my_decimal *Item_param::PValue::val_decimal(my_decimal *dec,
+                                            const Type_std_attributes *attr)
 {
-  // There's no "default". See comments in Item_param::save_in_field().
-  switch (state) {
-  case DECIMAL_VALUE:
-    return &decimal_value;
-  case REAL_VALUE:
-    double2my_decimal(E_DEC_FATAL_ERROR, value.real, dec);
+  switch (type_handler()->cmp_type()) {
+  case DECIMAL_RESULT:
+    return &m_decimal;
+  case REAL_RESULT:
+    double2my_decimal(E_DEC_FATAL_ERROR, real, dec);
     return dec;
-  case INT_VALUE:
-    int2my_decimal(E_DEC_FATAL_ERROR, value.integer, unsigned_flag, dec);
+  case INT_RESULT:
+    int2my_decimal(E_DEC_FATAL_ERROR, integer, attr->unsigned_flag, dec);
     return dec;
-  case STRING_VALUE:
-  case LONG_DATA_VALUE:
-    return decimal_from_string_with_check(dec, &str_value);
-  case TIME_VALUE:
-  {
-    return TIME_to_my_decimal(&value.time, dec);
-  }
-  case IGNORE_VALUE:
-  case DEFAULT_VALUE:
-    invalid_default_param();
-    // fall through
-  case NULL_VALUE:
-    return 0;
-  case NO_VALUE:
-    DBUG_ASSERT(0); // Should not be possible
-    return 0;
+  case STRING_RESULT:
+    return decimal_from_string_with_check(dec, &m_string);
+  case TIME_RESULT:
+    return TIME_to_my_decimal(&time, dec);
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
   }
-  DBUG_ASSERT(0); // Gabrage
   return 0;
 }
 
 
-String *Item_param::val_str(String* str) 
-{ 
-  // There's no "default". See comments in Item_param::save_in_field().
-  switch (state) {
-  case STRING_VALUE:
-  case LONG_DATA_VALUE:
-    return &str_value_ptr;
-  case REAL_VALUE:
-    str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
+String *Item_param::PValue::val_str(String *str,
+                                    const Type_std_attributes *attr)
+{
+  switch (type_handler()->cmp_type()) {
+  case STRING_RESULT:
+    return &m_string_ptr;
+  case REAL_RESULT:
+    str->set_real(real, NOT_FIXED_DEC, &my_charset_bin);
     return str;
-  case INT_VALUE:
-    str->set(value.integer, &my_charset_bin);
+  case INT_RESULT:
+    str->set(integer, &my_charset_bin);
     return str;
-  case DECIMAL_VALUE:
-    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
-                          0, 0, 0, str) <= 1)
+  case DECIMAL_RESULT:
+    if (my_decimal2string(E_DEC_FATAL_ERROR, &m_decimal, 0, 0, 0, str) <= 1)
       return str;
     return NULL;
-  case TIME_VALUE:
+  case TIME_RESULT:
   {
     if (str->reserve(MAX_DATE_STRING_REP_LENGTH))
-      break;
-    str->length((uint) my_TIME_to_str(&value.time, (char*) str->ptr(),
-                decimals));
+      return NULL;
+    str->length((uint) my_TIME_to_str(&time, (char*) str->ptr(),
+                attr->decimals));
     str->set_charset(&my_charset_bin);
     return str;
   }
-  case IGNORE_VALUE:
-  case DEFAULT_VALUE:
-    invalid_default_param();
-    // fall through
-  case NULL_VALUE:
-    return NULL; 
-  case NO_VALUE:
-    DBUG_ASSERT(0); // Should not be possible
-    return NULL;
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
   }
-  DBUG_ASSERT(0); // Garbage
   return NULL;
 }
 
+
 /**
   Return Param item values in string format, for generating the dynamic 
   query used in update/binary logs.
@@ -4290,32 +4527,31 @@ String *Item_param::val_str(String* str)
     that binary log contains wrong statement 
 */
 
-const String *Item_param::query_val_str(THD *thd, String* str) const
+const String *Item_param::value_query_val_str(THD *thd, String *str) const
 {
-  // There's no "default". See comments in Item_param::save_in_field().
-  switch (state) {
-  case INT_VALUE:
+  switch (value.type_handler()->cmp_type()) {
+  case INT_RESULT:
     str->set_int(value.integer, unsigned_flag, &my_charset_bin);
     return str;
-  case REAL_VALUE:
+  case REAL_RESULT:
     str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
     return str;
-  case DECIMAL_VALUE:
-    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
+  case DECIMAL_RESULT:
+    if (my_decimal2string(E_DEC_FATAL_ERROR, &value.m_decimal,
                           0, 0, 0, str) > 1)
       return &my_null_string;
     return str;
-  case TIME_VALUE:
+  case TIME_RESULT:
     {
       static const uint32 typelen= 9; // "TIMESTAMP" is the longest type name
       char *buf, *ptr;
       str->length(0);
       /*
         TODO: in case of error we need to notify replication
-        that binary log contains wrong statement 
+        that binary log contains wrong statement
       */
       if (str->reserve(MAX_DATE_STRING_REP_LENGTH + 3 + typelen))
-        break; 
+        return NULL;
 
       /* Create date string inplace */
       switch (value.time.time_type) {
@@ -4341,15 +4577,29 @@ const String *Item_param::query_val_str(THD *thd, String* str) const
       str->length((uint32) (ptr - buf));
       return str;
     }
-  case STRING_VALUE:
-  case LONG_DATA_VALUE:
+  case STRING_RESULT:
     {
       str->length(0);
       append_query_string(value.cs_info.character_set_client, str,
-                          str_value.ptr(), str_value.length(),
+                          value.m_string.ptr(), value.m_string.length(),
                           thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES);
       return str;
     }
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
+  }
+  return NULL;
+}
+
+
+const String *Item_param::query_val_str(THD *thd, String* str) const
+{
+  // There's no "default". See comments in Item_param::save_in_field().
+  switch (state) {
+  case SHORT_DATA_VALUE:
+  case LONG_DATA_VALUE:
+    return value_query_val_str(thd, str);
   case IGNORE_VALUE:
   case DEFAULT_VALUE:
     return &my_default_string;
@@ -4372,19 +4622,20 @@ const String *Item_param::query_val_str(THD *thd, String* str) const
 bool Item_param::convert_str_value(THD *thd)
 {
   bool rc= FALSE;
-  if (state == STRING_VALUE || state == LONG_DATA_VALUE)
+  if ((state == SHORT_DATA_VALUE || state == LONG_DATA_VALUE) &&
+      value.type_handler()->cmp_type() == STRING_RESULT)
   {
-    rc= value.cs_info.convert_if_needed(thd, &str_value);
+    rc= value.cs_info.convert_if_needed(thd, &value.m_string);
     /* Here str_value is guaranteed to be in final_character_set_of_str_value */
 
     /*
       str_value_ptr is returned from val_str(). It must be not alloced
       to prevent it's modification by val_str() invoker.
     */
-    str_value_ptr.set(str_value.ptr(), str_value.length(),
-                      str_value.charset());
+    value.m_string_ptr.set(value.m_string.ptr(), value.m_string.length(),
+                           value.m_string.charset());
     /* Synchronize item charset and length with value charset */
-    fix_charset_and_length_from_str_value(DERIVATION_COERCIBLE);
+    fix_charset_and_length_from_str_value(value.m_string, DERIVATION_COERCIBLE);
   }
   return rc;
 }
@@ -4393,18 +4644,48 @@ bool Item_param::convert_str_value(THD *thd)
 bool Item_param::basic_const_item() const
 {
   DBUG_ASSERT(fixed || state == NO_VALUE);
-  if (state == NO_VALUE || state == TIME_VALUE)
+  if (state == NO_VALUE ||
+      (state == SHORT_DATA_VALUE && type_handler()->cmp_type() == TIME_RESULT))
     return FALSE;
   return TRUE;
 }
 
 
+Item *Item_param::value_clone_item(THD *thd)
+{
+  MEM_ROOT *mem_root= thd->mem_root;
+  switch (value.type_handler()->cmp_type()) {
+  case INT_RESULT:
+    return (unsigned_flag ?
+            new (mem_root) Item_uint(thd, name.str, value.integer, max_length) :
+            new (mem_root) Item_int(thd, name.str, value.integer, max_length));
+  case REAL_RESULT:
+    return new (mem_root) Item_float(thd, name.str, value.real, decimals,
+                                     max_length);
+  case DECIMAL_RESULT:
+    return 0; // Should create Item_decimal. See MDEV-11361.
+  case STRING_RESULT:
+    return new (mem_root) Item_string(thd, name.str,
+                                      value.m_string.c_ptr_quick(),
+                                      value.m_string.length(),
+                                      value.m_string.charset(),
+                                      collation.derivation,
+                                      collation.repertoire);
+  case TIME_RESULT:
+    break;
+  case ROW_RESULT:
+    DBUG_ASSERT(0);
+    break;
+  }
+  return 0;
+}
+
+
 /* see comments in the header file */
 
 Item *
 Item_param::clone_item(THD *thd)
 {
-  MEM_ROOT *mem_root= thd->mem_root;
   // There's no "default". See comments in Item_param::save_in_field().
   switch (state) {
   case IGNORE_VALUE:
@@ -4412,24 +4693,13 @@ Item_param::clone_item(THD *thd)
     invalid_default_param();
     // fall through
   case NULL_VALUE:
-    return new (mem_root) Item_null(thd, name.str);
-  case INT_VALUE:
-    return (unsigned_flag ?
-            new (mem_root) Item_uint(thd, name.str, value.integer, max_length) :
-            new (mem_root) Item_int(thd, name.str, value.integer, max_length));
-  case REAL_VALUE:
-    return new (mem_root) Item_float(thd, name.str, value.real, decimals,
-                                     max_length);
-  case DECIMAL_VALUE:
-    return 0; // Should create Item_decimal. See MDEV-11361.
-  case STRING_VALUE:
+    return new (thd->mem_root) Item_null(thd, name.str);
+  case SHORT_DATA_VALUE:
   case LONG_DATA_VALUE:
-    return new (mem_root) Item_string(thd, name.str, str_value.c_ptr_quick(),
-                                      str_value.length(), str_value.charset(),
-                                      collation.derivation,
-                                      collation.repertoire);
-  case TIME_VALUE:
-    return 0;
+  {
+    DBUG_ASSERT(type_handler()->cmp_type() == value.type_handler()->cmp_type());
+    return value_clone_item(thd);
+  }
   case NO_VALUE:
     return 0;
   }
@@ -4438,6 +4708,24 @@ Item_param::clone_item(THD *thd)
 }
 
 
+bool Item_param::value_eq(const Item *item, bool binary_cmp) const
+{
+  switch (value.type_handler()->cmp_type()) {
+  case INT_RESULT:
+    return int_eq(value.integer, item);
+  case REAL_RESULT:
+    return real_eq(value.real, item);
+  case STRING_RESULT:
+    return str_eq(&value.m_string, item, binary_cmp);
+  case DECIMAL_RESULT:
+  case TIME_RESULT:
+  case ROW_RESULT:
+    break;
+  }
+  return false;
+}
+
+
 bool
 Item_param::eq(const Item *item, bool binary_cmp) const
 {
@@ -4452,15 +4740,9 @@ Item_param::eq(const Item *item, bool binary_cmp) const
     return false;
   case NULL_VALUE:
     return null_eq(item);
-  case INT_VALUE:
-    return int_eq(value.integer, item);
-  case REAL_VALUE:
-    return real_eq(value.real, item);
-  case STRING_VALUE:
+  case SHORT_DATA_VALUE:
   case LONG_DATA_VALUE:
-    return str_eq(&str_value, item, binary_cmp);
-  case DECIMAL_VALUE:
-  case TIME_VALUE:
+    return value_eq(item, binary_cmp);
   case NO_VALUE:
     return false;
   }
@@ -4521,18 +4803,14 @@ Item_param::set_param_type_and_swap_value(Item_param *src)
 {
   Type_std_attributes::set(src);
   set_handler(src->type_handler());
-  set_param_func= src->set_param_func;
   item_type= src->item_type;
 
   maybe_null= src->maybe_null;
   null_value= src->null_value;
   state= src->state;
   fixed= src->fixed;
-  value= src->value;
 
-  decimal_value.swap(src->decimal_value);
-  str_value.swap(src->str_value);
-  str_value_ptr.swap(src->str_value_ptr);
+  value.swap(src->value);
 }
 
 
@@ -4577,65 +4855,21 @@ bool
 Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it)
 {
   Item *arg= *it;
-
-  if (arg->is_null())
+  struct st_value tmp;
+  /*
+    The OUT parameter is bound to some data type.
+    It's important not to touch m_type_handler,
+    to make sure the next mysql_stmt_execute()
+    correctly fetches the value from the client-server protocol,
+    using set_param_func().
+  */
+  if (arg->save_in_value(&tmp) ||
+      set_value(thd, arg, &tmp, arg->type_handler()))
   {
     set_null();
-    return FALSE;
-  }
-
-  null_value= FALSE;
-
-  switch (arg->result_type()) {
-  case STRING_RESULT:
-  {
-    char str_buffer[STRING_BUFFER_USUAL_SIZE];
-    String sv_buffer(str_buffer, sizeof(str_buffer), &my_charset_bin);
-    String *sv= arg->val_str(&sv_buffer);
-
-    if (!sv)
-      return TRUE;
-
-    set_str(sv->c_ptr_safe(), sv->length());
-    str_value_ptr.set(str_value.ptr(),
-                      str_value.length(),
-                      str_value.charset());
-    collation.set(str_value.charset(), DERIVATION_COERCIBLE);
-    decimals= 0;
-    break;
-  }
-
-  case REAL_RESULT:
-    set_double(arg->val_real());
-    break;
-
-  case INT_RESULT:
-    set_int(arg->val_int(), arg->max_length);
-    break;
-
-  case DECIMAL_RESULT:
-  {
-    my_decimal dv_buf;
-    my_decimal *dv= arg->val_decimal(&dv_buf);
-
-    if (!dv)
-      return TRUE;
-
-    set_decimal(dv, !dv->sign());
-    break;
-  }
-
-  default:
-    /* That can not happen. */
-
-    DBUG_ASSERT(TRUE);  // Abort in debug mode.
-
-    set_null();         // Set to NULL in release mode.
-    return FALSE;
+    return false;
   }
-
-  set_handler_by_result_type(arg->result_type());
-  return FALSE;
+  return null_value= false;
 }
 
 
@@ -8274,7 +8508,7 @@ Item_cache_wrapper::Item_cache_wrapper(THD *thd, Item *item_arg):
   with_sum_func= orig_item->with_sum_func;
   with_field= orig_item->with_field;
   name= item_arg->name;
-  with_subselect=  orig_item->with_subselect;
+  m_with_subquery= orig_item->with_subquery();
 
   if ((expr_value= orig_item->get_cache(thd)))
     expr_value->setup(thd, orig_item);
diff --git a/sql/item.h b/sql/item.h
index b81af3db4de..d178d9f97d6 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -411,6 +411,8 @@ public:
 
   virtual const Send_field *get_out_param_info() const
   { return NULL; }
+
+  virtual Item_param *get_item_param() { return 0; }
 };
 
 
@@ -720,9 +722,6 @@ public:
   bool fixed;                           /* If item fixed with fix_fields */
   bool is_autogenerated_name;           /* indicate was name of this Item
                                            autogenerated or set by user */
-  bool with_subselect;                  /* If this item is a subselect or some
-                                           of its arguments is or contains a
-                                           subselect */
   // alloc & destruct is done as start of select on THD::mem_root
   Item(THD *thd);
   /*
@@ -1898,9 +1897,10 @@ public:
   virtual bool is_outer_field() const { DBUG_ASSERT(fixed); return FALSE; }
 
   /**
-    Checks if this item or any of its decendents contains a subquery.
+    Checks if this item or any of its decendents contains a subquery. This is a
+    replacement of the former Item::has_subquery() and Item::with_subselect.
   */
-  virtual bool has_subquery() const { return with_subselect; }
+  virtual bool with_subquery() const { DBUG_ASSERT(fixed); return false; }
 
   Item* set_expr_cache(THD *thd);
 
@@ -1978,6 +1978,21 @@ inline Item* get_item_copy (THD *thd, T* item)
 }	
 
 
+/*
+  This class is a replacement for the former member Item::with_subselect.
+  Determines if the descendant Item is a subselect or some of
+  its arguments is or contains a subselect.
+*/
+class With_subquery_cache
+{
+protected:
+  bool m_with_subquery;
+public:
+  With_subquery_cache(): m_with_subquery(false) { }
+  void join(const Item *item) { m_with_subquery|= item->with_subquery(); }
+};
+
+
 class Type_geometry_attributes
 {
   uint m_geometry_type;
@@ -2200,7 +2215,8 @@ protected:
     uint repertoire() const { return MY_STRING_METADATA::repertoire; }
     size_t char_length() const { return MY_STRING_METADATA::char_length; }
   };
-  void fix_charset_and_length_from_str_value(Derivation dv, Metadata metadata)
+  void fix_charset_and_length(CHARSET_INFO *cs,
+                              Derivation dv, Metadata metadata)
   {
     /*
       We have to have a different max_length than 'length' here to
@@ -2209,13 +2225,13 @@ protected:
       number of chars for a string of this type because we in Create_field::
       divide the max_length with mbmaxlen).
     */
-    collation.set(str_value.charset(), dv, metadata.repertoire());
+    collation.set(cs, dv, metadata.repertoire());
     fix_char_length(metadata.char_length());
     decimals= NOT_FIXED_DEC;
   }
-  void fix_charset_and_length_from_str_value(Derivation dv)
+  void fix_charset_and_length_from_str_value(const String &str, Derivation dv)
   {
-    fix_charset_and_length_from_str_value(dv, Metadata(&str_value));
+    fix_charset_and_length(str.charset(), dv, Metadata(&str));
   }
   Item_basic_value(THD *thd): Item(thd) {}
   /*
@@ -3097,12 +3113,27 @@ public:
   For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
   in result set and placeholders metadata, no matter what type you will
   supply for this placeholder in mysql_stmt_execute.
+
+  Item_param has two Type_handler pointers,
+  which can point to different handlers:
+
+  1. In the Type_handler_hybrid_field_type member
+     It's initialized in:
+     - Item_param::setup_conversion(), for client-server PS protocol,
+       according to the bind type.
+     - Item_param::set_from_item(), for EXECUTE and EXECUTE IMMEDIATE,
+       according to the actual parameter data type.
+
+  2. In the "value" member.
+     It's initialized in:
+     - Item_param::set_param_func(), for client-server PS protocol.
+     - Item_param::set_from_item(), for EXECUTE and EXECUTE IMMEDIATE.
 */
 
 class Item_param :public Item_basic_value,
                   private Settable_routine_parameter,
                   public Rewritable_query_parameter,
-                  public Type_handler_hybrid_field_type,
+                  private Type_handler_hybrid_field_type,
                   public Type_geometry_attributes
 {
   /*
@@ -3148,9 +3179,8 @@ class Item_param :public Item_basic_value,
   */
   enum enum_item_param_state
   {
-    NO_VALUE, NULL_VALUE, INT_VALUE, REAL_VALUE,
-    STRING_VALUE, TIME_VALUE, LONG_DATA_VALUE,
-    DECIMAL_VALUE, DEFAULT_VALUE, IGNORE_VALUE
+    NO_VALUE, NULL_VALUE, SHORT_DATA_VALUE, LONG_DATA_VALUE,
+    DEFAULT_VALUE, IGNORE_VALUE
   } state;
 
   enum Type item_type;
@@ -3163,7 +3193,6 @@ class Item_param :public Item_basic_value,
 
   void fix_temporal(uint32 max_length_arg, uint decimals_arg);
 
-public:
   struct CONVERSION_INFO
   {
     /*
@@ -3205,31 +3234,71 @@ public:
     }
   };
 
+  bool m_empty_string_is_null;
+
+  class PValue_simple
+  {
+  public:
+    union
+    {
+      longlong integer;
+      double   real;
+      CONVERSION_INFO cs_info;
+      MYSQL_TIME     time;
+    };
+    void swap(PValue_simple &other)
+    {
+      swap_variables(PValue_simple, *this, other);
+    }
+  };
+
+  class PValue: public Type_handler_hybrid_field_type,
+                public PValue_simple,
+                public Value_source
+  {
+  public:
+    PValue(): Type_handler_hybrid_field_type(&type_handler_null) {}
+    my_decimal m_decimal;
+    String m_string;
+    /*
+      A buffer for string and long data values. Historically all allocated
+      values returned from val_str() were treated as eligible to
+      modification. I. e. in some cases Item_func_concat can append it's
+      second argument to return value of the first one. Because of that we
+      can't return the original buffer holding string data from val_str(),
+      and have to have one buffer for data and another just pointing to
+      the data. This is the latter one and it's returned from val_str().
+      Can not be declared inside the union as it's not a POD type.
+    */
+    String m_string_ptr;
+
+    void swap(PValue &other)
+    {
+      Type_handler_hybrid_field_type::swap(other);
+      PValue_simple::swap(other);
+      m_decimal.swap(other.m_decimal);
+      m_string.swap(other.m_string);
+      m_string_ptr.swap(other.m_string_ptr);
+    }
+    double val_real() const;
+    longlong val_int(const Type_std_attributes *attr) const;
+    my_decimal *val_decimal(my_decimal *dec, const Type_std_attributes *attr);
+    String *val_str(String *str, const Type_std_attributes *attr);
+  };
+
+  PValue value;
+
+  const String *value_query_val_str(THD *thd, String* str) const;
+  bool value_eq(const Item *item, bool binary_cmp) const;
+  Item *value_clone_item(THD *thd);
+  bool can_return_value() const;
+
+public:
   /*
     Used for bulk protocol only.
   */
   enum enum_indicator_type indicator;
 
-  /*
-    A buffer for string and long data values. Historically all allocated
-    values returned from val_str() were treated as eligible to
-    modification. I. e. in some cases Item_func_concat can append it's
-    second argument to return value of the first one. Because of that we
-    can't return the original buffer holding string data from val_str(),
-    and have to have one buffer for data and another just pointing to
-    the data. This is the latter one and it's returned from val_str().
-    Can not be declared inside the union as it's not a POD type.
-  */
-  String str_value_ptr;
-  my_decimal decimal_value;
-  union
-  {
-    longlong integer;
-    double   real;
-    CONVERSION_INFO cs_info;
-    MYSQL_TIME     time;
-  } value;
-
   const Type_handler *type_handler() const
   { return Type_handler_hybrid_field_type::type_handler(); }
 
@@ -3248,10 +3317,22 @@ public:
     return item_type;
   }
 
-  double val_real();
-  longlong val_int();
-  my_decimal *val_decimal(my_decimal*);
-  String *val_str(String*);
+  double val_real()
+  {
+    return can_return_value() ? value.val_real() : 0e0;
+  }
+  longlong val_int()
+  {
+    return can_return_value() ? value.val_int(this) : 0;
+  }
+  my_decimal *val_decimal(my_decimal *dec)
+  {
+    return can_return_value() ? value.val_decimal(dec, this) : NULL;
+  }
+  String *val_str(String *str)
+  {
+    return can_return_value() ? value.val_str(str, this) : NULL;
+  }
   bool get_date(MYSQL_TIME *tm, ulonglong fuzzydate);
   int  save_in_field(Field *field, bool no_conversions);
 
@@ -3262,20 +3343,64 @@ public:
   void set_double(double i);
   void set_decimal(const char *str, ulong length);
   void set_decimal(const my_decimal *dv, bool unsigned_arg);
-  bool set_str(const char *str, ulong length);
+  bool set_str(const char *str, ulong length,
+               CHARSET_INFO *fromcs, CHARSET_INFO *tocs);
   bool set_longdata(const char *str, ulong length);
   void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
   void set_time(const MYSQL_TIME *tm, uint32 max_length_arg, uint decimals_arg);
   bool set_from_item(THD *thd, Item *item);
   void reset();
+
+  void set_param_tiny(uchar **pos, ulong len);
+  void set_param_short(uchar **pos, ulong len);
+  void set_param_int32(uchar **pos, ulong len);
+  void set_param_int64(uchar **pos, ulong len);
+  void set_param_float(uchar **pos, ulong len);
+  void set_param_double(uchar **pos, ulong len);
+  void set_param_decimal(uchar **pos, ulong len);
+  void set_param_time(uchar **pos, ulong len);
+  void set_param_datetime(uchar **pos, ulong len);
+  void set_param_date(uchar **pos, ulong len);
+  void set_param_str(uchar **pos, ulong len);
+
+  void setup_conversion(THD *thd, uchar param_type);
+  void setup_conversion_blob(THD *thd);
+  void setup_conversion_string(THD *thd, CHARSET_INFO *fromcs);
+
   /*
     Assign placeholder value from bind data.
     Note, that 'len' has different semantics in embedded library (as we
     don't need to check that packet is not broken there). See
     sql_prepare.cc for details.
   */
-  void (*set_param_func)(Item_param *param, uchar **pos, ulong len);
+  void set_param_func(uchar **pos, ulong len)
+  {
+    /*
+      To avoid Item_param::set_xxx() asserting on data type mismatch,
+      we set the value type handler here:
+      - It can not be initialized yet after Item_param::setup_conversion().
+      - Also, for LIMIT clause parameters, the value type handler might have
+        changed from the real type handler to type_handler_longlong.
+        So here we'll restore it.
+    */
+    const Type_handler *h= Item_param::type_handler();
+    value.set_handler(h);
+    h->Item_param_set_param_func(this, pos, len);
+  }
 
+  bool set_value(THD *thd, const Type_all_attributes *attr,
+                 const st_value *val, const Type_handler *h)
+  {
+    value.set_handler(h); // See comments in set_param_func()
+    return h->Item_param_set_from_value(thd, this, attr, val);
+  }
+
+  bool set_limit_clause_param(longlong nr)
+  {
+    value.set_handler(&type_handler_longlong);
+    set_int(nr, MY_INT64_NUM_DECIMAL_DIGITS);
+    return !unsigned_flag && value.integer < 0;
+  }
   const String *query_val_str(THD *thd, String *str) const;
 
   bool convert_str_value(THD *thd);
@@ -3301,7 +3426,8 @@ public:
   }
   bool has_int_value() const
   {
-    return state == INT_VALUE;
+    return state == SHORT_DATA_VALUE &&
+           value.type_handler()->cmp_type() == INT_RESULT;
   }
   /*
     This method is used to make a copy of a basic constant item when
@@ -3342,6 +3468,8 @@ private:
 public:
   virtual const Send_field *get_out_param_info() const;
 
+  Item_param *get_item_param() { return this; }
+
   virtual void make_field(THD *thd, Send_field *field);
 
 private:
@@ -3562,7 +3690,7 @@ class Item_string :public Item_basic_constant
 protected:
   void fix_from_value(Derivation dv, const Metadata metadata)
   {
-    fix_charset_and_length_from_str_value(dv, metadata);
+    fix_charset_and_length(str_value.charset(), dv, metadata);
     // it is constant => can be used without fix_fields (and frequently used)
     fixed= 1;
   }
@@ -4279,7 +4407,8 @@ public:
 */
 class Item_func_or_sum: public Item_result_field,
                         public Item_args,
-                        public Used_tables_and_const_cache
+                        public Used_tables_and_const_cache,
+                        public With_subquery_cache
 {
 protected:
   bool agg_arg_charsets(DTCollation &c, Item **items, uint nitems,
@@ -4362,6 +4491,7 @@ public:
     Used_tables_and_const_cache(item) { }
   Item_func_or_sum(THD *thd, List<Item> &list):
     Item_result_field(thd), Item_args(thd, list) { }
+  bool with_subquery() const { DBUG_ASSERT(fixed); return m_with_subquery; }
   bool walk(Item_processor processor, bool walk_subquery, void *arg)
   {
     if (walk_args(processor, walk_subquery, arg))
@@ -4391,6 +4521,35 @@ public:
   Item* build_clone(THD *thd);
 };
 
+class sp_head;
+class sp_name;
+struct st_sp_security_context;
+
+class Item_sp
+{
+public:
+  Name_resolution_context *context;
+  sp_name *m_name;
+  sp_head *m_sp;
+  TABLE *dummy_table;
+  uchar result_buf[64];
+  sp_rcontext *func_ctx;
+  MEM_ROOT sp_mem_root;
+  Query_arena *sp_query_arena;
+
+  /*
+     The result field of the stored function.
+  */
+  Field *sp_result_field;
+  Item_sp(THD *thd, Name_resolution_context *context_arg, sp_name *name_arg);
+  const char *func_name(THD *thd) const;
+  void cleanup();
+  bool sp_check_access(THD *thd);
+  bool execute(THD *thd, bool *null_value, Item **args, uint arg_count);
+  bool execute_impl(THD *thd, Item **args, uint arg_count);
+  bool init_result_field(THD *thd, uint max_length, uint maybe_null,
+                         bool *null_value, LEX_CSTRING *name);
+};
 
 class Item_ref :public Item_ident
 {
@@ -4576,9 +4735,9 @@ public:
   /**
     Checks if the item tree that ref points to contains a subquery.
   */
-  virtual bool has_subquery() const 
-  { 
-    return (*ref)->has_subquery();
+  virtual bool with_subquery() const
+  {
+    return (*ref)->with_subquery();
   }
   Item *get_copy(THD *thd)
   { return get_item_copy<Item_ref>(thd, this); }
@@ -4701,7 +4860,8 @@ class Expression_cache_tracker;
   The objects of this class can store its values in an expression cache.
 */
 
-class Item_cache_wrapper :public Item_result_field
+class Item_cache_wrapper :public Item_result_field,
+                          public With_subquery_cache
 {
 private:
   /* Pointer on the cached expression */
@@ -4728,6 +4888,7 @@ public:
 
   enum Type type() const { return EXPR_CACHE_ITEM; }
   enum Type real_type() const { return orig_item->type(); }
+  bool with_subquery() const { DBUG_ASSERT(fixed); return m_with_subquery; }
 
   bool set_cache(THD *thd);
   Expression_cache_tracker* init_tracker(MEM_ROOT *mem_root);
@@ -5773,6 +5934,7 @@ public:
   }
 
   virtual void store(Item *item);
+  virtual Item *get_item() { return example; }
   virtual bool cache_value()= 0;
   bool basic_const_item() const
   { return MY_TEST(example && example->basic_const_item()); }
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 4360e629388..d38b0100246 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -1368,7 +1368,7 @@ bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
   }
   if (args[1]->maybe_null)
     maybe_null=1;
-  with_subselect= 1;
+  m_with_subquery= true;
   with_sum_func= with_sum_func || args[1]->with_sum_func;
   with_field= with_field || args[1]->with_field;
   used_tables_and_const_cache_join(args[1]);
@@ -4626,7 +4626,7 @@ Item_cond::fix_fields(THD *thd, Item **ref)
   
     with_sum_func|=    item->with_sum_func;
     with_field|=       item->with_field;
-    with_subselect|=   item->has_subquery();
+    m_with_subquery|=  item->with_subquery();
     with_window_func|= item->with_window_func;
     maybe_null|=       item->maybe_null;
   }
@@ -5487,7 +5487,7 @@ void Regexp_processor_pcre::pcre_exec_warn(int rc) const
   switch (rc)
   {
   case PCRE_ERROR_NULL:
-    errmsg= "pcre_exec: null arguement passed";
+    errmsg= "pcre_exec: null argument passed";
     break;
   case PCRE_ERROR_BADOPTION:
     errmsg= "pcre_exec: bad option";
@@ -6629,7 +6629,7 @@ bool Item_equal::fix_fields(THD *thd, Item **ref)
     used_tables_cache|= item->used_tables();
     tmp_table_map= item->not_null_tables();
     not_null_tables_cache|= tmp_table_map;
-    DBUG_ASSERT(!item->with_sum_func && !item->with_subselect);
+    DBUG_ASSERT(!item->with_sum_func && !item->with_subquery());
     if (item->maybe_null)
       maybe_null= 1;
     if (!item->get_item_equal())
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 0a3339e7ffe..1561a78a12a 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -356,7 +356,7 @@ public:
   Item_in_optimizer(THD *thd, Item *a, Item *b):
     Item_bool_func(thd, a, b), cache(0), expr_cache(0),
     save_cache(0), result_for_null_param(UNKNOWN)
-  { with_subselect= true; }
+  { m_with_subquery= true; }
   bool fix_fields(THD *, Item **);
   bool fix_left(THD *thd);
   table_map not_null_tables() const { return 0; }
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 659ec29e452..a8b4a64856e 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -362,7 +362,7 @@ Item_func::fix_fields(THD *thd, Item **ref)
       with_window_func= with_window_func || item->with_window_func;
       with_field= with_field || item->with_field;
       used_tables_and_const_cache_join(item);
-      with_subselect|=        item->has_subquery();
+      m_with_subquery|= item->with_subquery();
     }
   }
   if (check_arguments())
@@ -3249,7 +3249,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
 	func->maybe_null=1;
       func->with_sum_func= func->with_sum_func || item->with_sum_func;
       func->with_field= func->with_field || item->with_field;
-      func->with_subselect|= item->with_subselect;
+      func->With_subquery_cache::join(item);
       func->used_tables_and_const_cache_join(item);
       f_args.arg_type[i]=item->result_type();
     }
@@ -6238,35 +6238,24 @@ longlong Item_func_row_count::val_int()
 
 Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
                            sp_name *name):
-  Item_func(thd), context(context_arg), m_name(name), m_sp(NULL), sp_result_field(NULL)
+  Item_func(thd), Item_sp(thd, context_arg, name)
 {
   maybe_null= 1;
-  dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
-  dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
 }
 
 
 Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
                            sp_name *name_arg, List<Item> &list):
-  Item_func(thd, list), context(context_arg), m_name(name_arg), m_sp(NULL),
-  sp_result_field(NULL)
+  Item_func(thd, list), Item_sp(thd, context_arg, name_arg)
 {
   maybe_null= 1;
-  dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
-  dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
 }
 
 
 void
 Item_func_sp::cleanup()
 {
-  if (sp_result_field)
-  {
-    delete sp_result_field;
-    sp_result_field= NULL;
-  }
-  m_sp= NULL;
-  dummy_table->alias.free();
+  Item_sp::cleanup();
   Item_func::cleanup();
 }
 
@@ -6274,25 +6263,7 @@ const char *
 Item_func_sp::func_name() const
 {
   THD *thd= current_thd;
-  /* Calculate length to avoid reallocation of string for sure */
-  uint len= (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
-              m_name->m_name.length)*2 + //characters*quoting
-             2 +                         // ` and `
-             (m_name->m_explicit_name ?
-              3 : 0) +                   // '`', '`' and '.' for the db
-             1 +                         // end of string
-             ALIGN_SIZE(1));             // to avoid String reallocation
-  String qname((char *)alloc_root(thd->mem_root, len), len,
-               system_charset_info);
-
-  qname.length(0);
-  if (m_name->m_explicit_name)
-  {
-    append_identifier(thd, &qname, m_name->m_db.str, m_name->m_db.length);
-    qname.append('.');
-  }
-  append_identifier(thd, &qname, m_name->m_name.str, m_name->m_name.length);
-  return qname.c_ptr_safe();
+  return Item_sp::func_name(thd);
 }
 
 
@@ -6306,75 +6277,6 @@ void my_missing_function_error(const LEX_CSTRING &token, const char *func_name)
 
 
 /**
-  @brief Initialize the result field by creating a temporary dummy table
-    and assign it to a newly created field object. Meta data used to
-    create the field is fetched from the sp_head belonging to the stored
-    proceedure found in the stored procedure functon cache.
-  
-  @note This function should be called from fix_fields to init the result
-    field. It is some what related to Item_field.
-
-  @see Item_field
-
-  @param thd A pointer to the session and thread context.
-
-  @return Function return error status.
-  @retval TRUE is returned on an error
-  @retval FALSE is returned on success.
-*/
-
-bool
-Item_func_sp::init_result_field(THD *thd, sp_head *sp)
-{
-  TABLE_SHARE *share;
-  DBUG_ENTER("Item_func_sp::init_result_field");
-
-  DBUG_ASSERT(m_sp == NULL);
-  DBUG_ASSERT(sp_result_field == NULL);
-
-  if (!(m_sp= sp))
-  {
-    my_missing_function_error (m_name->m_name, ErrConvDQName(m_name).ptr());
-    context->process_error(thd);
-    DBUG_RETURN(TRUE);
-  }
-
-  /*
-     A Field need to be attached to a Table.
-     Below we "create" a dummy table by initializing 
-     the needed pointers.
-   */
-  
-  share= dummy_table->s;
-  dummy_table->alias.set("", 0, table_alias_charset);
-  dummy_table->maybe_null = maybe_null;
-  dummy_table->in_use= thd;
-  dummy_table->copy_blobs= TRUE;
-  share->table_cache_key= empty_clex_str;
-  share->table_name= empty_clex_str;
-
-  if (!(sp_result_field= m_sp->create_result_field(max_length, &name, dummy_table)))
-  {
-   DBUG_RETURN(TRUE);
-  }
-  
-  if (sp_result_field->pack_length() > sizeof(result_buf))
-  {
-    void *tmp;
-    if (!(tmp= thd->alloc(sp_result_field->pack_length())))
-      DBUG_RETURN(TRUE);
-    sp_result_field->move_field((uchar*) tmp);
-  }
-  else
-    sp_result_field->move_field(result_buf);
-  
-  sp_result_field->null_ptr= (uchar *) &null_value;
-  sp_result_field->null_bit= 1;
-  DBUG_RETURN(FALSE);
-}
-
-
-/**
   @note
   Deterministic stored procedures are considered inexpensive.
   Consequently such procedures may be evaluated during optimization,
@@ -6408,95 +6310,11 @@ void Item_func_sp::fix_length_and_dec()
 }
 
 
-/**
-  @brief Execute function & store value in field.
-
-  @return Function returns error status.
-  @retval FALSE on success.
-  @retval TRUE if an error occurred.
-*/
-
 bool
 Item_func_sp::execute()
 {
-  THD *thd= current_thd;
-  
   /* Execute function and store the return value in the field. */
-
-  if (execute_impl(thd))
-  {
-    null_value= 1;
-    context->process_error(thd);
-    if (thd->killed)
-      thd->send_kill_message();
-    return TRUE;
-  }
-
-  /* Check that the field (the value) is not NULL. */
-
-  null_value= sp_result_field->is_null();
-
-  return null_value;
-}
-
-
-/**
-   @brief Execute function and store the return value in the field.
-
-   @note This function was intended to be the concrete implementation of
-    the interface function execute. This was never realized.
-
-   @return The error state.
-   @retval FALSE on success
-   @retval TRUE if an error occurred.
-*/
-bool
-Item_func_sp::execute_impl(THD *thd)
-{
-  bool err_status= TRUE;
-  Sub_statement_state statement_state;
-  Security_context *save_security_ctx= thd->security_ctx;
-  enum enum_sp_data_access access=
-    (m_sp->daccess() == SP_DEFAULT_ACCESS) ?
-     SP_DEFAULT_ACCESS_MAPPING : m_sp->daccess();
-
-  DBUG_ENTER("Item_func_sp::execute_impl");
-
-  if (context->security_ctx)
-  {
-    /* Set view definer security context */
-    thd->security_ctx= context->security_ctx;
-  }
-  if (sp_check_access(thd))
-    goto error;
-
-  /*
-    Throw an error if a non-deterministic function is called while
-    statement-based replication (SBR) is active.
-  */
-
-  if (!m_sp->detistic() && !trust_function_creators &&
-      (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) &&
-      (mysql_bin_log.is_open() &&
-       thd->variables.binlog_format == BINLOG_FORMAT_STMT))
-  {
-    my_error(ER_BINLOG_UNSAFE_ROUTINE, MYF(0));
-    goto error;
-  }
-
-  /*
-    Disable the binlogging if this is not a SELECT statement. If this is a
-    SELECT, leave binlogging on, so execute_function() code writes the
-    function call into binlog.
-  */
-  thd->reset_sub_statement_state(&statement_state, SUB_STMT_FUNCTION);
-  err_status= m_sp->execute_function(thd, args, arg_count, sp_result_field); 
-  thd->restore_sub_statement_state(&statement_state);
-
-error:
-  thd->security_ctx= save_security_ctx;
-
-  DBUG_RETURN(err_status);
+  return Item_sp::execute(current_thd, &null_value, args, arg_count);
 }
 
 
@@ -6561,29 +6379,6 @@ longlong Item_func_sqlcode::val_int()
 }
 
 
-/**
-  @brief Checks if requested access to function can be granted to user.
-    If function isn't found yet, it searches function first.
-    If function can't be found or user don't have requested access
-    error is raised.
-
-  @param thd thread handler
-
-  @return Indication if the access was granted or not.
-  @retval FALSE Access is granted.
-  @retval TRUE Requested access can't be granted or function doesn't exists.
-    
-*/
-
-bool
-Item_func_sp::sp_check_access(THD *thd)
-{
-  DBUG_ENTER("Item_func_sp::sp_check_access");
-  DBUG_ASSERT(m_sp);
-  DBUG_RETURN(m_sp->check_execute_access(thd));
-}
-
-
 bool
 Item_func_sp::fix_fields(THD *thd, Item **ref)
 {
@@ -6620,20 +6415,66 @@ Item_func_sp::fix_fields(THD *thd, Item **ref)
     }
   }
 
+
+  /* Custom aggregates are transformed into an Item_sum_sp. We can not do this
+     earlier as we have no way of knowing what kind of Item we should create
+     when parsing the query.
+
+     TODO(cvicentiu): See if this limitation can be lifted.
+  */
+
+  DBUG_ASSERT(m_sp == NULL);
+  if (!(m_sp= sp))
+  {
+    my_missing_function_error(m_name->m_name, ErrConvDQName(m_name).ptr());
+    context->process_error(thd);
+    DBUG_RETURN(TRUE);
+  }
+
   /*
-    We must call init_result_field before Item_func::fix_fields() 
+    We must call init_result_field before Item_func::fix_fields()
     to make m_sp and result_field members available to fix_length_and_dec(),
     which is called from Item_func::fix_fields().
   */
-  res= init_result_field(thd, sp);
+  res= init_result_field(thd, max_length, maybe_null, &null_value, &name);
 
   if (res)
-    DBUG_RETURN(res);
+    DBUG_RETURN(TRUE);
+
+  if (m_sp->agg_type() == GROUP_AGGREGATE)
+  {
+    List<Item> list;
+    list.empty();
+    for (uint i=0; i < arg_count; i++)
+      list.push_back(*(args+i));
+
+    Item_sum_sp *item_sp;
+    Query_arena *arena, backup;
+    arena= thd->activate_stmt_arena_if_needed(&backup);
+
+    if (arg_count)
+      item_sp= new (thd->mem_root) Item_sum_sp(thd, context, m_name, sp, list);
+    else
+      item_sp= new (thd->mem_root) Item_sum_sp(thd, context, m_name, sp);
+
+    if (arena)
+      thd->restore_active_arena(arena, &backup);
+    if (!item_sp)
+      DBUG_RETURN(TRUE);
+    *ref= item_sp;
+    item_sp->name= name;
+    bool err= item_sp->fix_fields(thd, ref);
+    if (err)
+      DBUG_RETURN(TRUE);
+
+    list.empty();
+    DBUG_RETURN(FALSE);
+  }
 
   res= Item_func::fix_fields(thd, ref);
 
   if (res)
-    DBUG_RETURN(res);
+    DBUG_RETURN(TRUE);
 
   if (thd->lex->is_view_context_analysis())
   {
diff --git a/sql/item_func.h b/sql/item_func.h
index c4a87b4f699..f6640c9b719 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -2735,26 +2735,12 @@ public:
  *
  */
 
-class sp_head;
-class sp_name;
-struct st_sp_security_context;
-
-class Item_func_sp :public Item_func
+class Item_func_sp :public Item_func,
+                    public Item_sp
 {
 private:
-  Name_resolution_context *context;
-  sp_name *m_name;
-  mutable sp_head *m_sp;
-  TABLE *dummy_table;
-  uchar result_buf[64];
-  /*
-     The result field of the concrete stored function.
-  */
-  Field *sp_result_field;
 
   bool execute();
-  bool execute_impl(THD *thd);
-  bool init_result_field(THD *thd, sp_head *sp);
 
 protected:
   bool is_expensive_processor(void *arg)
@@ -2846,7 +2832,6 @@ public:
   virtual bool change_context_processor(void *cntx)
     { context= (Name_resolution_context *)cntx; return FALSE; }
 
-  bool sp_check_access(THD * thd);
   virtual enum Functype functype() const { return FUNC_SP; }
 
   bool fix_fields(THD *thd, Item **ref);
diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc
index a060ed221bf..aee44a7a01f 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -165,6 +165,9 @@ String *Item_func_geometry_from_json::val_str(String *str)
     case Geometry::GEOJ_TOO_FEW_POINTS:
       code= ER_GEOJSON_TOO_FEW_POINTS;
       break;
+    case Geometry::GEOJ_EMPTY_COORDINATES:
+      code= ER_GEOJSON_EMPTY_COORDINATES;
+      break;
     case Geometry::GEOJ_POLYGON_NOT_CLOSED:
       code= ER_GEOJSON_NOT_CLOSED;
       break;
diff --git a/sql/item_jsonfunc.cc b/sql/item_jsonfunc.cc
index 54ffa5a2e63..7afb94ba332 100644
--- a/sql/item_jsonfunc.cc
+++ b/sql/item_jsonfunc.cc
@@ -69,6 +69,7 @@ static inline bool append_simple(String *s, const uchar *a, size_t a_len)
 /*
   Appends JSON string to the String object taking charsets in
   consideration.
+*/
 static int st_append_json(String *s,
              CHARSET_INFO *json_cs, const uchar *js, uint js_len)
 {
@@ -82,9 +83,8 @@ static int st_append_json(String *s,
     return 0;
   }
 
-  return js_len;
+  return str_len;
 }
-*/
 
 
 /*
@@ -475,6 +475,9 @@ String *Item_func_json_value::val_str(String *str)
   json_scan_start(&je, js->charset(),(const uchar *) js->ptr(),
                   (const uchar *) js->ptr() + js->length());
 
+  str->length(0);
+  str->set_charset(&my_charset_utf8mb4_bin);
+
   path.cur_step= path.p.steps;
 continue_search:
   if (json_find_path(&je, &path.p, &path.cur_step, array_counters))
@@ -515,8 +518,7 @@ bool Item_func_json_value::check_and_get_value(json_engine_t *je, String *res,
     return true;
   }
 
-  res->set((const char *) je->value, je->value_len, je->s.cs);
-  return false;
+  return st_append_json(res, je->s.cs, je->value, je->value_len); 
 }
 
 
diff --git a/sql/item_row.cc b/sql/item_row.cc
index eae88cd2e6e..64794093bec 100644
--- a/sql/item_row.cc
+++ b/sql/item_row.cc
@@ -64,7 +64,7 @@ bool Item_row::fix_fields(THD *thd, Item **ref)
     with_sum_func= with_sum_func || item->with_sum_func;
     with_window_func = with_window_func || item->with_window_func;
     with_field= with_field || item->with_field;
-    with_subselect|= item->with_subselect;
+    m_with_subquery|= item->with_subquery();
   }
   fixed= 1;
   return FALSE;
diff --git a/sql/item_row.h b/sql/item_row.h
index a66ae7fb5dc..064c1f267b4 100644
--- a/sql/item_row.h
+++ b/sql/item_row.h
@@ -35,7 +35,8 @@
 */
 class Item_row: public Item,
                 private Item_args,
-                private Used_tables_and_const_cache
+                private Used_tables_and_const_cache,
+                private With_subquery_cache
 {
   table_map not_null_tables_cache;
   /**
@@ -52,6 +53,7 @@ public:
     not_null_tables_cache(0), with_null(0)
   { }
 
+  bool with_subquery() const { DBUG_ASSERT(fixed); return m_with_subquery; }
   enum Type type() const { return ROW_ITEM; };
   const Type_handler *type_handler() const { return &type_handler_row; }
   void illegal_method_call(const char *);
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 3a7d8582913..e47fa17896d 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -64,7 +64,6 @@ Item_subselect::Item_subselect(THD *thd_arg):
 #ifndef DBUG_OFF
   exec_counter= 0;
 #endif
-  with_subselect= 1;
   reset();
   /*
     Item value is NULL if select_result_interceptor didn't change this value
diff --git a/sql/item_subselect.h b/sql/item_subselect.h
index e48b45fb11e..55c9d759ddf 100644
--- a/sql/item_subselect.h
+++ b/sql/item_subselect.h
@@ -182,6 +182,7 @@ public:
     return null_value;
   }
   bool fix_fields(THD *thd, Item **ref);
+  bool with_subquery() const { DBUG_ASSERT(fixed); return true; }
   bool mark_as_dependent(THD *thd, st_select_lex *select, Item *item);
   void fix_after_pullout(st_select_lex *new_parent, Item **ref, bool merge);
   void recalc_used_tables(st_select_lex *new_parent, bool after_pullout);
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 269190ef3df..d4abdfc614f 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -30,6 +30,10 @@
 #include "sql_priv.h"
 #include "sql_select.h"
 #include "uniques.h"
+#include "sp_rcontext.h"
+#include "sp.h"
+#include "sql_parse.h"
+#include "sp_head.h"
 
 /**
   Calculate the affordable RAM limit for structures like TREE or Unique
@@ -1126,7 +1130,7 @@ Item_sum_num::fix_fields(THD *thd, Item **ref)
     if (args[i]->fix_fields(thd, args + i) || args[i]->check_cols(1))
       return TRUE;
     set_if_bigger(decimals, args[i]->decimals);
-    with_subselect|= args[i]->with_subselect;
+    m_with_subquery|= args[i]->with_subquery();
     with_window_func|= args[i]->with_window_func;
   }
   result_field=0;
@@ -1146,18 +1150,20 @@ Item_sum_num::fix_fields(THD *thd, Item **ref)
 bool
 Item_sum_hybrid::fix_fields(THD *thd, Item **ref)
 {
+  DBUG_ENTER("Item_sum_hybrid::fix_fields");
   DBUG_ASSERT(fixed == 0);
 
   Item *item= args[0];
 
   if (init_sum_func_check(thd))
-    return TRUE;
+    DBUG_RETURN(TRUE);
 
   // 'item' can be changed during fix_fields
   if ((!item->fixed && item->fix_fields(thd, args)) ||
       (item= args[0])->check_cols(1))
-    return TRUE;
-  with_subselect= args[0]->with_subselect;
+    DBUG_RETURN(TRUE);
+
+  m_with_subquery= args[0]->with_subquery();
   with_window_func|= args[0]->with_window_func;
 
   fix_length_and_dec();
@@ -1166,11 +1172,11 @@ Item_sum_hybrid::fix_fields(THD *thd, Item **ref)
   result_field=0;
 
   if (check_sum_func(thd, ref))
-    return TRUE;
+    DBUG_RETURN(TRUE);
 
   orig_args[0]= args[0];
   fixed= 1;
-  return FALSE;
+  DBUG_RETURN(FALSE);
 }
 
 
@@ -1201,15 +1207,16 @@ void Item_sum_hybrid::fix_length_and_dec()
 
 void Item_sum_hybrid::setup_hybrid(THD *thd, Item *item, Item *value_arg)
 {
+  DBUG_ENTER("Item_sum_hybrid::setup_hybrid");
   if (!(value= item->get_cache(thd)))
-    return;
+    DBUG_VOID_RETURN;
   value->setup(thd, item);
   value->store(value_arg);
   /* Don't cache value, as it will change */
   if (!item->const_item())
     value->set_used_tables(RAND_TABLE_BIT);
   if (!(arg_cache= item->get_cache(thd)))
-    return;
+    DBUG_VOID_RETURN;
   arg_cache->setup(thd, item);
   /* Don't cache value, as it will change */
   if (!item->const_item())
@@ -1217,23 +1224,178 @@ void Item_sum_hybrid::setup_hybrid(THD *thd, Item *item, Item *value_arg)
   cmp= new Arg_comparator();
   if (cmp)
     cmp->set_cmp_func(this, (Item**)&arg_cache, (Item**)&value, FALSE);
+  DBUG_VOID_RETURN;
 }
 
 
 Field *Item_sum_hybrid::create_tmp_field(bool group, TABLE *table)
 {
+  DBUG_ENTER("Item_sum_hybrid::create_tmp_field");
+
   if (args[0]->type() == Item::FIELD_ITEM)
   {
     Field *field= ((Item_field*) args[0])->field;
     if ((field= create_tmp_field_from_field(table->in_use, field, &name,
                                             table, NULL)))
       field->flags&= ~NOT_NULL_FLAG;
-    return field;
+    DBUG_RETURN(field);
   }
-  return tmp_table_field_from_field_type(table);
+  DBUG_RETURN(tmp_table_field_from_field_type(table));
+}
+
+/***********************************************************************
+** Item_sum_sp class
+***********************************************************************/
+
+Item_sum_sp::Item_sum_sp(THD *thd, Name_resolution_context *context_arg,
+                           sp_name *name_arg, sp_head *sp, List<Item> &list)
+  :Item_sum(thd, list), Item_sp(thd, context_arg, name_arg)
+{
+  maybe_null= 1;
+  quick_group= 0;
+  m_sp= sp;
+}
+
+Item_sum_sp::Item_sum_sp(THD *thd, Name_resolution_context *context_arg,
+                           sp_name *name_arg, sp_head *sp)
+  :Item_sum(thd), Item_sp(thd, context_arg, name_arg)
+{
+  maybe_null= 1;
+  quick_group= 0;
+  m_sp= sp;
 }
 
 
+bool
+Item_sum_sp::fix_fields(THD *thd, Item **ref)
+{
+  DBUG_ASSERT(fixed == 0);
+  if (init_sum_func_check(thd))
+    return TRUE;
+  decimals= 0;
+
+  m_sp= m_sp ? m_sp : sp_handler_function.sp_find_routine(thd, m_name, true);
+
+  if (!m_sp)
+  {
+    my_missing_function_error(m_name->m_name, ErrConvDQName(m_name).ptr());
+    context->process_error(thd);
+    return TRUE;
+  }
+
+  if (init_result_field(thd, max_length, maybe_null, &null_value, &name))
+    return TRUE;
+
+  for (uint i= 0 ; i < arg_count ; i++)
+  {
+    if (args[i]->fix_fields(thd, args + i) || args[i]->check_cols(1))
+      return TRUE;
+    set_if_bigger(decimals, args[i]->decimals);
+    m_with_subquery|= args[i]->with_subquery();
+    with_window_func|= args[i]->with_window_func;
+  }
+  result_field= NULL;
+  max_length= float_length(decimals);
+  null_value= 1;
+  fix_length_and_dec();
+
+  if (check_sum_func(thd, ref))
+    return TRUE;
+
+  memcpy(orig_args, args, sizeof(Item *) * arg_count);
+  fixed= 1;
+  return FALSE;
+}
+
+/**
+  Execute function to store value in result field.
+  This is called when we need the value to be returned for the function.
+  Here we send a signal in form of the server status that all rows have been
+  fetched and now we have to exit from the function with the return value.
+  @return Function returns error status.
+  @retval FALSE on success.
+  @retval TRUE if an error occurred.
+*/
+
+bool
+Item_sum_sp::execute()
+{
+  THD *thd= current_thd;
+  bool res;
+  uint old_server_status= thd->server_status;
+
+  /* We set server status so we can send a signal to exit from the
+     function with the return value. */
+
+  thd->server_status= SERVER_STATUS_LAST_ROW_SENT;
+  res= Item_sp::execute(thd, &null_value, args, arg_count);
+  thd->server_status= old_server_status;
+  return res;
+}
+
+/**
+  Handles the aggregation of the values.
+  @note: See class description for more details on how and why this is done.
+  @return The error state.
+  @retval FALSE on success.
+  @retval TRUE if an error occurred.
+*/
+
+bool
+Item_sum_sp::add()
+{
+  return execute_impl(current_thd, args, arg_count);
+}
+
+
+void
+Item_sum_sp::clear()
+{
+  delete func_ctx;
+  func_ctx= NULL;
+  sp_query_arena->free_items();
+  free_root(&sp_mem_root, MYF(0));
+}
+
+const Type_handler *Item_sum_sp::type_handler() const
+{
+  DBUG_ENTER("Item_sum_sp::type_handler");
+  DBUG_PRINT("info", ("m_sp = %p", (void *) m_sp));
+  DBUG_ASSERT(sp_result_field);
+  // This converts ENUM/SET to STRING
+  const Type_handler *handler= sp_result_field->type_handler();
+  DBUG_RETURN(handler->type_handler_for_item_field());
+}
+
+void
+Item_sum_sp::cleanup()
+{
+  Item_sp::cleanup();
+  Item_sum::cleanup();
+}
+
+/**
+  Initialize local members with values from the Field interface.
+  @note called from Item::fix_fields.
+*/
+
+void
+Item_sum_sp::fix_length_and_dec()
+{
+  DBUG_ENTER("Item_sum_sp::fix_length_and_dec");
+  DBUG_ASSERT(sp_result_field);
+  Type_std_attributes::set(sp_result_field);
+  Item_sum::fix_length_and_dec();
+  DBUG_VOID_RETURN;
+}
+
+const char *
+Item_sum_sp::func_name() const
+{
+  THD *thd= current_thd;
+  return Item_sp::func_name(thd);
+}
+
 /***********************************************************************
 ** reset and add of sum_func
 ***********************************************************************/
@@ -1245,6 +1407,7 @@ Field *Item_sum_hybrid::create_tmp_field(bool group, TABLE *table)
 Item_sum_sum::Item_sum_sum(THD *thd, Item_sum_sum *item) 
   :Item_sum_num(thd, item),
    Type_handler_hybrid_field_type(item),
+   direct_added(FALSE), direct_reseted_field(FALSE),
    curr_dec_buff(item->curr_dec_buff),
    count(item->count)
 {
@@ -1264,6 +1427,15 @@ Item *Item_sum_sum::copy_or_same(THD* thd)
 }
 
 
+void Item_sum_sum::cleanup()
+{
+  DBUG_ENTER("Item_sum_sum::cleanup");
+  direct_added= direct_reseted_field= FALSE;
+  Item_sum_num::cleanup();
+  DBUG_VOID_RETURN;
+}
+
+
 void Item_sum_sum::clear()
 {
   DBUG_ENTER("Item_sum_sum::clear");
@@ -1313,6 +1485,38 @@ void Item_sum_sum::fix_length_and_dec()
 }
 
 
+void Item_sum_sum::direct_add(my_decimal *add_sum_decimal)
+{
+  DBUG_ENTER("Item_sum_sum::direct_add");
+  DBUG_PRINT("info", ("add_sum_decimal: %p", add_sum_decimal));
+  direct_added= TRUE;
+  direct_reseted_field= FALSE;
+  if (add_sum_decimal)
+  {
+    direct_sum_is_null= FALSE;
+    direct_sum_decimal= *add_sum_decimal;
+  }
+  else
+  {
+    direct_sum_is_null= TRUE;
+    direct_sum_decimal= decimal_zero;
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+void Item_sum_sum::direct_add(double add_sum_real, bool add_sum_is_null)
+{
+  DBUG_ENTER("Item_sum_sum::direct_add");
+  DBUG_PRINT("info", ("add_sum_real: %f", add_sum_real));
+  direct_added= TRUE;
+  direct_reseted_field= FALSE;
+  direct_sum_is_null= add_sum_is_null;
+  direct_sum_real= add_sum_real;
+  DBUG_VOID_RETURN;
+}
+
+
 bool Item_sum_sum::add()
 {
   DBUG_ENTER("Item_sum_sum::add");
@@ -1326,50 +1530,84 @@ void Item_sum_sum::add_helper(bool perform_removal)
 
   if (result_type() == DECIMAL_RESULT)
   {
-    my_decimal value;
-    const my_decimal *val= aggr->arg_val_decimal(&value);
-    if (!aggr->arg_is_null(true))
+    if (unlikely(direct_added))
     {
-      if (perform_removal)
+      /* Add value stored by Item_sum_sum::direct_add */
+      DBUG_ASSERT(!perform_removal);
+
+      direct_added= FALSE;
+      if (likely(!direct_sum_is_null))
       {
-        if (count > 0)
+        my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
+                       &direct_sum_decimal, dec_buffs + curr_dec_buff);
+        curr_dec_buff^= 1;
+        null_value= 0;
+      }
+    }
+    else
+    {
+      direct_reseted_field= FALSE;
+      my_decimal value;
+      const my_decimal *val= aggr->arg_val_decimal(&value);
+      if (!aggr->arg_is_null(true))
+      {
+        if (perform_removal)
         {
-          my_decimal_sub(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff ^ 1),
-                         dec_buffs + curr_dec_buff, val);
-          count--;
+          if (count > 0)
+          {
+            my_decimal_sub(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff ^ 1),
+              dec_buffs + curr_dec_buff, val);
+            count--;
+          }
+          else
+            DBUG_VOID_RETURN;
         }
         else
-          DBUG_VOID_RETURN;
-      }
-      else
-      {
-        count++;
-        my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff ^ 1),
-                       val, dec_buffs + curr_dec_buff);
+        {
+          count++;
+          my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff ^ 1),
+            val, dec_buffs + curr_dec_buff);
+        }
+        curr_dec_buff^= 1;
+        null_value= (count > 0) ? 0 : 1;
       }
-      curr_dec_buff^= 1;
-      null_value= (count > 0) ? 0 : 1;
     }
   }
   else
   {
-    if (perform_removal && count > 0)
-      sum-= aggr->arg_val_real();
+    if (unlikely(direct_added))
+    {
+      /* Add value stored by Item_sum_sum::direct_add */
+      DBUG_ASSERT(!perform_removal);
+
+      direct_added= FALSE;
+      if (!direct_sum_is_null)
+      {
+        sum+= direct_sum_real;
+        null_value= 0;
+      }
+    }
     else
-      sum+= aggr->arg_val_real();
-    if (!aggr->arg_is_null(true))
     {
-      if (perform_removal)
+      direct_reseted_field= FALSE;
+      if (perform_removal && count > 0)
+        sum-= aggr->arg_val_real();
+      else
+        sum+= aggr->arg_val_real();
+      if (!aggr->arg_is_null(true))
       {
-        if (count > 0)
+        if (perform_removal)
         {
-          count--;
+          if (count > 0)
+          {
+            count--;
+          }
         }
-      }
-      else
-        count++;
+        else
+          count++;
 
-      null_value= (count > 0) ? 0 : 1;
+        null_value= (count > 0) ? 0 : 1;
+      }
     }
   }
   DBUG_VOID_RETURN;
@@ -1556,22 +1794,46 @@ bool Aggregator_distinct::arg_is_null(bool use_null_value)
 
 Item *Item_sum_count::copy_or_same(THD* thd)
 {
-  return new (thd->mem_root) Item_sum_count(thd, this);
+  DBUG_ENTER("Item_sum_count::copy_or_same");
+  DBUG_RETURN(new (thd->mem_root) Item_sum_count(thd, this));
+}
+
+
+void Item_sum_count::direct_add(longlong add_count)
+{
+  DBUG_ENTER("Item_sum_count::direct_add");
+  DBUG_PRINT("info", ("add_count: %lld", add_count));
+  direct_counted= TRUE;
+  direct_reseted_field= FALSE;
+  direct_count= add_count;
+  DBUG_VOID_RETURN;
 }
 
 
 void Item_sum_count::clear()
 {
+  DBUG_ENTER("Item_sum_count::clear");
   count= 0;
+  DBUG_VOID_RETURN;
 }
 
 
 bool Item_sum_count::add()
 {
-  if (aggr->arg_is_null(false))
-    return 0;
-  count++;
-  return 0;
+  DBUG_ENTER("Item_sum_count::add");
+  if (direct_counted)
+  {
+    direct_counted= FALSE;
+    count+= direct_count;
+  }
+  else
+  {
+    direct_reseted_field= FALSE;
+    if (aggr->arg_is_null(false))
+      DBUG_RETURN(0);
+    count++;
+  }
+  DBUG_RETURN(0);
 }
 
 
@@ -1590,10 +1852,11 @@ void Item_sum_count::remove()
 
 longlong Item_sum_count::val_int()
 {
+  DBUG_ENTER("Item_sum_count::val_int");
   DBUG_ASSERT(fixed == 1);
   if (aggr)
     aggr->endup();
-  return (longlong) count;
+  DBUG_RETURN((longlong)count);
 }
 
 
@@ -1601,6 +1864,8 @@ void Item_sum_count::cleanup()
 {
   DBUG_ENTER("Item_sum_count::cleanup");
   count= 0;
+  direct_counted= FALSE;
+  direct_reseted_field= FALSE;
   Item_sum_int::cleanup();
   DBUG_VOID_RETURN;
 }
@@ -2015,10 +2280,13 @@ Item *Item_sum_variance::result_item(THD *thd, Field *field)
 
 void Item_sum_hybrid::clear()
 {
+  DBUG_ENTER("Item_sum_hybrid::clear");
   value->clear();
   null_value= 1;
+  DBUG_VOID_RETURN;
 }
 
+
 bool
 Item_sum_hybrid::get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
 {
@@ -2031,51 +2299,66 @@ Item_sum_hybrid::get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
   return retval;
 }
 
+
+void Item_sum_hybrid::direct_add(Item *item)
+{
+  DBUG_ENTER("Item_sum_hybrid::direct_add");
+  DBUG_PRINT("info", ("item: %p", item));
+  direct_added= TRUE;
+  direct_item= item;
+  DBUG_VOID_RETURN;
+}
+
+
 double Item_sum_hybrid::val_real()
 {
+  DBUG_ENTER("Item_sum_hybrid::val_real");
   DBUG_ASSERT(fixed == 1);
   if (null_value)
-    return 0.0;
+    DBUG_RETURN(0.0);
   double retval= value->val_real();
   if ((null_value= value->null_value))
     DBUG_ASSERT(retval == 0.0);
-  return retval;
+  DBUG_RETURN(retval);
 }
 
 longlong Item_sum_hybrid::val_int()
 {
+  DBUG_ENTER("Item_sum_hybrid::val_int");
   DBUG_ASSERT(fixed == 1);
   if (null_value)
-    return 0;
+    DBUG_RETURN(0);
   longlong retval= value->val_int();
   if ((null_value= value->null_value))
     DBUG_ASSERT(retval == 0);
-  return retval;
+  DBUG_RETURN(retval);
 }
 
 
 my_decimal *Item_sum_hybrid::val_decimal(my_decimal *val)
 {
+  DBUG_ENTER("Item_sum_hybrid::val_decimal");
   DBUG_ASSERT(fixed == 1);
   if (null_value)
-    return 0;
+    DBUG_RETURN(0);
   my_decimal *retval= value->val_decimal(val);
   if ((null_value= value->null_value))
     DBUG_ASSERT(retval == NULL);
-  return retval;
+  DBUG_RETURN(retval);
 }
 
 
 String *
 Item_sum_hybrid::val_str(String *str)
 {
+  DBUG_ENTER("Item_sum_hybrid::val_str");
   DBUG_ASSERT(fixed == 1);
   if (null_value)
-    return 0;
+    DBUG_RETURN(0);
   String *retval= value->val_str(str);
   if ((null_value= value->null_value))
     DBUG_ASSERT(retval == NULL);
-  return retval;
+  DBUG_RETURN(retval);
 }
 
 
@@ -2099,6 +2382,7 @@ void Item_sum_hybrid::cleanup()
 
 void Item_sum_hybrid::no_rows_in_result()
 {
+  DBUG_ENTER("Item_sum_hybrid::no_rows_in_result");
   /* We may be called here twice in case of ref field in function */
   if (was_values)
   {
@@ -2106,6 +2390,7 @@ void Item_sum_hybrid::no_rows_in_result()
     was_null_value= value->null_value;
     clear();
   }
+  DBUG_VOID_RETURN;
 }
 
 void Item_sum_hybrid::restore_to_before_no_rows_in_result()
@@ -2120,14 +2405,26 @@ void Item_sum_hybrid::restore_to_before_no_rows_in_result()
 
 Item *Item_sum_min::copy_or_same(THD* thd)
 {
+  DBUG_ENTER("Item_sum_min::copy_or_same");
   Item_sum_min *item= new (thd->mem_root) Item_sum_min(thd, this);
   item->setup_hybrid(thd, args[0], value);
-  return item;
+  DBUG_RETURN(item);
 }
 
 
 bool Item_sum_min::add()
 {
+  Item *tmp_item;
+  DBUG_ENTER("Item_sum_min::add");
+  DBUG_PRINT("enter", ("this: %p", this));
+
+  if (unlikely(direct_added))
+  {
+    /* Change to use direct_item */
+    tmp_item= arg_cache->get_item();
+    arg_cache->store(direct_item);
+  }
+  DBUG_PRINT("info", ("null_value: %s", null_value ? "TRUE" : "FALSE"));
   /* args[0] < value */
   arg_cache->cache_value();
   if (!arg_cache->null_value &&
@@ -2137,7 +2434,13 @@ bool Item_sum_min::add()
     value->cache_value();
     null_value= 0;
   }
-  return 0;
+  if (unlikely(direct_added))
+  {
+    /* Restore original item */
+    direct_added= FALSE;
+    arg_cache->store(tmp_item);
+  }
+  DBUG_RETURN(0);
 }
 
 
@@ -2151,8 +2454,19 @@ Item *Item_sum_max::copy_or_same(THD* thd)
 
 bool Item_sum_max::add()
 {
+  Item *tmp_item;
+  DBUG_ENTER("Item_sum_max::add");
+  DBUG_PRINT("enter", ("this: %p", this));
+
+  if (unlikely(direct_added))
+  {
+    /* Change to use direct_item */
+    tmp_item= arg_cache->get_item();
+    arg_cache->store(direct_item);
+  }
   /* args[0] > value */
   arg_cache->cache_value();
+  DBUG_PRINT("info", ("null_value: %s", null_value ? "TRUE" : "FALSE"));
   if (!arg_cache->null_value &&
       (null_value || cmp->compare() > 0))
   {
@@ -2160,7 +2474,13 @@ bool Item_sum_max::add()
     value->cache_value();
     null_value= 0;
   }
-  return 0;
+  if (unlikely(direct_added))
+  {
+    /* Restore original item */
+    direct_added= FALSE;
+    arg_cache->store(tmp_item);
+  }
+  DBUG_RETURN(0);
 }
 
 
@@ -2339,14 +2659,26 @@ void Item_sum_num::reset_field()
 
 void Item_sum_hybrid::reset_field()
 {
+  Item *tmp_item, *arg0;
+  DBUG_ENTER("Item_sum_hybrid::reset_field");
+
+  arg0= args[0];
+  if (unlikely(direct_added))
+  {
+    /* Switch to use direct item */
+    tmp_item= value->get_item();
+    value->store(direct_item);
+    arg0= direct_item;
+  }
+
   switch(result_type()) {
   case STRING_RESULT:
   {
     char buff[MAX_FIELD_WIDTH];
     String tmp(buff,sizeof(buff),result_field->charset()),*res;
 
-    res=args[0]->val_str(&tmp);
-    if (args[0]->null_value)
+    res= arg0->val_str(&tmp);
+    if (arg0->null_value)
     {
       result_field->set_null();
       result_field->reset();
@@ -2360,11 +2692,11 @@ void Item_sum_hybrid::reset_field()
   }
   case INT_RESULT:
   {
-    longlong nr=args[0]->val_int();
+    longlong nr= arg0->val_int();
 
     if (maybe_null)
     {
-      if (args[0]->null_value)
+      if (arg0->null_value)
       {
 	nr=0;
 	result_field->set_null();
@@ -2372,16 +2704,17 @@ void Item_sum_hybrid::reset_field()
       else
 	result_field->set_notnull();
     }
+    DBUG_PRINT("info", ("nr: %lld", nr));
     result_field->store(nr, unsigned_flag);
     break;
   }
   case REAL_RESULT:
   {
-    double nr= args[0]->val_real();
+    double nr= arg0->val_real();
 
     if (maybe_null)
     {
-      if (args[0]->null_value)
+      if (arg0->null_value)
       {
 	nr=0.0;
 	result_field->set_null();
@@ -2394,11 +2727,11 @@ void Item_sum_hybrid::reset_field()
   }
   case DECIMAL_RESULT:
   {
-    my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
+    my_decimal value_buff, *arg_dec= arg0->val_decimal(&value_buff);
 
     if (maybe_null)
     {
-      if (args[0]->null_value)
+      if (arg0->null_value)
         result_field->set_null();
       else
         result_field->set_notnull();
@@ -2416,26 +2749,49 @@ void Item_sum_hybrid::reset_field()
   case TIME_RESULT:
     DBUG_ASSERT(0);
   }
+
+  if (unlikely(direct_added))
+  {
+    direct_added= FALSE;
+    value->store(tmp_item);
+  }
+  DBUG_VOID_RETURN;
 }
 
 
 void Item_sum_sum::reset_field()
 {
+  my_bool null_flag;
   DBUG_ASSERT (aggr->Aggrtype() != Aggregator::DISTINCT_AGGREGATOR);
   if (result_type() == DECIMAL_RESULT)
   {
-    my_decimal value, *arg_val= args[0]->val_decimal(&value);
-    if (!arg_val)                               // Null
-      arg_val= &decimal_zero;
+    my_decimal value, *arg_val;
+    if (unlikely(direct_added))
+      arg_val= &direct_sum_decimal;
+    else
+    {
+      if (!(arg_val= args[0]->val_decimal(&value)))
+        arg_val= &decimal_zero;                 // Null
+    }
     result_field->store_decimal(arg_val);
   }
   else
   {
     DBUG_ASSERT(result_type() == REAL_RESULT);
-    double nr= args[0]->val_real();			// Nulls also return 0
+    double nr= likely(!direct_added) ? args[0]->val_real() : direct_sum_real;
     float8store(result_field->ptr, nr);
   }
-  if (args[0]->null_value)
+
+  if (unlikely(direct_added))
+  {
+    direct_added= FALSE;
+    direct_reseted_field= TRUE;
+    null_flag= direct_sum_is_null;
+  }
+  else
+    null_flag= args[0]->null_value;
+
+  if (null_flag)
     result_field->set_null();
   else
     result_field->set_notnull();
@@ -2444,13 +2800,22 @@ void Item_sum_sum::reset_field()
 
 void Item_sum_count::reset_field()
 {
+  DBUG_ENTER("Item_sum_count::reset_field");
   uchar *res=result_field->ptr;
   longlong nr=0;
   DBUG_ASSERT (aggr->Aggrtype() != Aggregator::DISTINCT_AGGREGATOR);
 
-  if (!args[0]->maybe_null || !args[0]->is_null())
-    nr=1;
+  if (unlikely(direct_counted))
+  {
+    nr= direct_count;
+    direct_counted= FALSE;
+    direct_reseted_field= TRUE;
+  }
+  else if (!args[0]->maybe_null || !args[0]->is_null())
+    nr= 1;
+  DBUG_PRINT("info", ("nr: %lld", nr));
   int8store(res,nr);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2518,13 +2883,26 @@ void Item_sum_sum::update_field()
   DBUG_ASSERT (aggr->Aggrtype() != Aggregator::DISTINCT_AGGREGATOR);
   if (result_type() == DECIMAL_RESULT)
   {
-    my_decimal value, *arg_val= args[0]->val_decimal(&value);
-    if (!args[0]->null_value)
+    my_decimal value, *arg_val;
+    my_bool null_flag;
+    if (unlikely(direct_added || direct_reseted_field))
+    {
+      direct_added= direct_reseted_field= FALSE;
+      arg_val= &direct_sum_decimal;
+      null_flag= direct_sum_is_null;
+    }
+    else
+    {
+      arg_val= args[0]->val_decimal(&value);
+      null_flag= args[0]->null_value;
+    }
+
+    if (!null_flag)
     {
       if (!result_field->is_null())
       {
-        my_decimal field_value,
-                   *field_val= result_field->val_decimal(&field_value);
+        my_decimal field_value;
+        my_decimal *field_val= result_field->val_decimal(&field_value);
         my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
         result_field->store_decimal(dec_buffs);
       }
@@ -2538,11 +2916,22 @@ void Item_sum_sum::update_field()
   else
   {
     double old_nr,nr;
-    uchar *res=result_field->ptr;
+    uchar *res= result_field->ptr;
+    my_bool null_flag;
 
     float8get(old_nr,res);
-    nr= args[0]->val_real();
-    if (!args[0]->null_value)
+    if (unlikely(direct_added || direct_reseted_field))
+    {
+      direct_added= direct_reseted_field= FALSE;
+      null_flag= direct_sum_is_null;
+      nr= direct_sum_real;
+    }
+    else
+    {
+      nr= args[0]->val_real();
+      null_flag= args[0]->null_value;
+    }
+    if (!null_flag)
     {
       old_nr+=nr;
       result_field->set_notnull();
@@ -2554,13 +2943,21 @@ void Item_sum_sum::update_field()
 
 void Item_sum_count::update_field()
 {
+  DBUG_ENTER("Item_sum_count::update_field");
   longlong nr;
   uchar *res=result_field->ptr;
 
   nr=sint8korr(res);
-  if (!args[0]->maybe_null || !args[0]->is_null())
+  if (unlikely(direct_counted || direct_reseted_field))
+  {
+    direct_counted= direct_reseted_field= FALSE;
+    nr+= direct_count;
+  }
+  else if (!args[0]->maybe_null || !args[0]->is_null())
     nr++;
+  DBUG_PRINT("info", ("nr: %lld", nr));
   int8store(res,nr);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2618,6 +3015,13 @@ Item *Item_sum_avg::result_item(THD *thd, Field *field)
 
 void Item_sum_hybrid::update_field()
 {
+  DBUG_ENTER("Item_sum_hybrid::update_field");
+  Item *tmp_item;
+  if (unlikely(direct_added))
+  {
+    tmp_item= args[0];
+    args[0]= direct_item;
+  }
   switch (result_type()) {
   case STRING_RESULT:
     min_max_update_str_field();
@@ -2631,12 +3035,19 @@ void Item_sum_hybrid::update_field()
   default:
     min_max_update_real_field();
   }
+  if (unlikely(direct_added))
+  {
+    direct_added= FALSE;
+    args[0]= tmp_item;
+  }
+  DBUG_VOID_RETURN;
 }
 
 
 void
 Item_sum_hybrid::min_max_update_str_field()
 {
+  DBUG_ENTER("Item_sum_hybrid::min_max_update_str_field");
   DBUG_ASSERT(cmp);
   String *res_str=args[0]->val_str(&cmp->value1);
 
@@ -2649,6 +3060,7 @@ Item_sum_hybrid::min_max_update_str_field()
       result_field->store(res_str->ptr(),res_str->length(),res_str->charset());
     result_field->set_notnull();
   }
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2657,6 +3069,7 @@ Item_sum_hybrid::min_max_update_real_field()
 {
   double nr,old_nr;
 
+  DBUG_ENTER("Item_sum_hybrid::min_max_update_real_field");
   old_nr=result_field->val_real();
   nr= args[0]->val_real();
   if (!args[0]->null_value)
@@ -2669,6 +3082,7 @@ Item_sum_hybrid::min_max_update_real_field()
   else if (result_field->is_null(0))
     result_field->set_null();
   result_field->store(old_nr);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2677,6 +3091,7 @@ Item_sum_hybrid::min_max_update_int_field()
 {
   longlong nr,old_nr;
 
+  DBUG_ENTER("Item_sum_hybrid::min_max_update_int_field");
   old_nr=result_field->val_int();
   nr=args[0]->val_int();
   if (!args[0]->null_value)
@@ -2696,7 +3111,9 @@ Item_sum_hybrid::min_max_update_int_field()
   }
   else if (result_field->is_null(0))
     result_field->set_null();
+  DBUG_PRINT("info", ("nr: %lld", old_nr));
   result_field->store(old_nr, unsigned_flag);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2707,6 +3124,7 @@ Item_sum_hybrid::min_max_update_int_field()
 void
 Item_sum_hybrid::min_max_update_decimal_field()
 {
+  DBUG_ENTER("Item_sum_hybrid::min_max_update_decimal_field");
   my_decimal old_val, nr_val;
   const my_decimal *old_nr;
   const my_decimal *nr= args[0]->val_decimal(&nr_val);
@@ -2727,6 +3145,7 @@ Item_sum_hybrid::min_max_update_decimal_field()
   }
   else if (result_field->is_null(0))
     result_field->set_null();
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2850,7 +3269,7 @@ double Item_sum_udf_float::val_real()
   double res;
   DBUG_ASSERT(fixed == 1);
   DBUG_ENTER("Item_sum_udf_float::val");
-  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
+  DBUG_PRINT("enter",("result_type: %d  arg_count: %d",
 		     args[0]->result_type(), arg_count));
   res= udf.val(&tmp_null_value);
   null_value= tmp_null_value;
@@ -2894,7 +3313,7 @@ my_decimal *Item_sum_udf_decimal::val_decimal(my_decimal *dec_buf)
   my_bool tmp_null_value;
   DBUG_ASSERT(fixed == 1);
   DBUG_ENTER("Item_func_udf_decimal::val_decimal");
-  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
+  DBUG_PRINT("enter",("result_type: %d  arg_count: %d",
                      args[0]->result_type(), arg_count));
 
   res= udf.val_decimal(&tmp_null_value, dec_buf);
@@ -2920,7 +3339,7 @@ longlong Item_sum_udf_int::val_int()
   longlong res;
   DBUG_ASSERT(fixed == 1);
   DBUG_ENTER("Item_sum_udf_int::val_int");
-  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
+  DBUG_PRINT("enter",("result_type: %d  arg_count: %d",
 		     args[0]->result_type(), arg_count));
   res= udf.val_int(&tmp_null_value);
   null_value= tmp_null_value;
@@ -3114,6 +3533,11 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)),
   Item **arg= item->args, **arg_end= item->args + item->arg_count_field;
   uint old_length= result->length();
 
+  ulonglong *offset_limit= &item->copy_offset_limit;
+  ulonglong *row_limit = &item->copy_row_limit;
+  if (item->limit_clause && !(*row_limit))
+    return 1;
+
   if (item->no_appended)
     item->no_appended= FALSE;
   else
@@ -3121,6 +3545,14 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)),
 
   tmp.length(0);
 
+  if (item->limit_clause && (*offset_limit))
+  {
+    item->row_count++;
+    item->no_appended= TRUE;
+    (*offset_limit)--;
+    return 0;
+  }
+
   for (; arg < arg_end; arg++)
   {
     String *res;
@@ -3150,6 +3582,8 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)),
       result->append(*res);
   }
 
+  if (item->limit_clause)
+    (*row_limit)--;
   item->row_count++;
 
   /* stop if length of result more than max_length */
@@ -3198,7 +3632,8 @@ Item_func_group_concat::
 Item_func_group_concat(THD *thd, Name_resolution_context *context_arg,
                        bool distinct_arg, List<Item> *select_list,
                        const SQL_I_List<ORDER> &order_list,
-                       String *separator_arg)
+                       String *separator_arg, bool limit_clause,
+                       Item *row_limit_arg, Item *offset_limit_arg)
   :Item_sum(thd), tmp_table_param(0), separator(separator_arg), tree(0),
    unique_filter(NULL), table(0),
    order(0), context(context_arg),
@@ -3207,7 +3642,9 @@ Item_func_group_concat(THD *thd, Name_resolution_context *context_arg,
    row_count(0),
    distinct(distinct_arg),
    warning_for_row(FALSE),
-   force_copy_fields(0), original(0)
+   force_copy_fields(0), row_limit(NULL),
+   offset_limit(NULL), limit_clause(limit_clause),
+   copy_offset_limit(0), copy_row_limit(0), original(0)
 {
   Item *item_select;
   Item **arg_ptr;
@@ -3249,6 +3686,11 @@ Item_func_group_concat(THD *thd, Name_resolution_context *context_arg,
   /* orig_args is only used for print() */
   orig_args= (Item**) (order + arg_count_order);
   memcpy(orig_args, args, sizeof(Item*) * arg_count);
+  if (limit_clause)
+  {
+    row_limit= row_limit_arg;
+    offset_limit= offset_limit_arg;
+  }
 }
 
 
@@ -3268,7 +3710,9 @@ Item_func_group_concat::Item_func_group_concat(THD *thd,
   warning_for_row(item->warning_for_row),
   always_null(item->always_null),
   force_copy_fields(item->force_copy_fields),
-  original(item)
+  row_limit(item->row_limit), offset_limit(item->offset_limit),
+  limit_clause(item->limit_clause),copy_offset_limit(item->copy_offset_limit),
+  copy_row_limit(item->copy_row_limit), original(item)
 {
   quick_group= item->quick_group;
   result.set_charset(collation.collation);
@@ -3363,6 +3807,10 @@ void Item_func_group_concat::clear()
   null_value= TRUE;
   warning_for_row= FALSE;
   no_appended= TRUE;
+  if (offset_limit)
+    copy_offset_limit= offset_limit->val_int();
+  if (row_limit)
+    copy_row_limit= row_limit->val_int();
   if (tree)
     reset_tree(tree);
   if (unique_filter)
@@ -3447,7 +3895,7 @@ Item_func_group_concat::fix_fields(THD *thd, Item **ref)
          args[i]->fix_fields(thd, args + i)) ||
         args[i]->check_cols(1))
       return TRUE;
-    with_subselect|= args[i]->with_subselect;
+    m_with_subquery|= args[i]->with_subquery();
     with_window_func|= args[i]->with_window_func;
   }
 
@@ -3617,6 +4065,12 @@ bool Item_func_group_concat::setup(THD *thd)
                               (void*)this,
                               tree_key_length,
                               ram_limitation(thd));
+  if ((row_limit && row_limit->cmp_type() != INT_RESULT) ||
+      (offset_limit && offset_limit->cmp_type() != INT_RESULT))
+  {
+    my_error(ER_INVALID_VALUE_TO_LIMIT, MYF(0));
+    DBUG_RETURN(TRUE);
+  }
   
   DBUG_RETURN(FALSE);
 }
diff --git a/sql/item_sum.h b/sql/item_sum.h
index 9822f9e5430..cbf245f3cd3 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -355,7 +355,7 @@ public:
     ROW_NUMBER_FUNC, RANK_FUNC, DENSE_RANK_FUNC, PERCENT_RANK_FUNC,
     CUME_DIST_FUNC, NTILE_FUNC, FIRST_VALUE_FUNC, LAST_VALUE_FUNC,
     NTH_VALUE_FUNC, LEAD_FUNC, LAG_FUNC, PERCENTILE_CONT_FUNC,
-    PERCENTILE_DISC_FUNC
+    PERCENTILE_DISC_FUNC, SP_AGGREGATE_FUNC
   };
 
   Item **ref_by; /* pointer to a ref to the object used to register it */
@@ -521,6 +521,7 @@ public:
   Item *get_arg(uint i) const { return args[i]; }
   Item *set_arg(uint i, THD *thd, Item *new_val);
   uint get_arg_count() const { return arg_count; }
+  virtual Item **get_args() { return fixed ? orig_args : args; }
 
   /* Initialization of distinct related members */
   void init_aggregator()
@@ -757,14 +758,20 @@ class Item_sum_sum :public Item_sum_num,
                    public Type_handler_hybrid_field_type 
 {
 protected:
+  bool direct_added;
+  bool direct_reseted_field;
+  bool direct_sum_is_null;
+  double direct_sum_real;
   double sum;
+  my_decimal direct_sum_decimal;
   my_decimal dec_buffs[2];
   uint curr_dec_buff;
   void fix_length_and_dec();
 
 public:
   Item_sum_sum(THD *thd, Item *item_par, bool distinct):
-    Item_sum_num(thd, item_par)
+    Item_sum_num(thd, item_par), direct_added(FALSE),
+    direct_reseted_field(FALSE)
   {
     set_distinct(distinct);
   }
@@ -773,6 +780,9 @@ public:
   { 
     return has_with_distinct() ? SUM_DISTINCT_FUNC : SUM_FUNC; 
   }
+  void cleanup();
+  void direct_add(my_decimal *add_sum_decimal);
+  void direct_add(double add_sum_real, bool add_sum_is_null);
   void clear();
   bool add();
   double val_real();
@@ -808,6 +818,9 @@ private:
 
 class Item_sum_count :public Item_sum_int
 {
+  bool direct_counted;
+  bool direct_reseted_field;
+  longlong direct_count;
   longlong count;
 
   friend class Aggregator_distinct;
@@ -817,9 +830,10 @@ class Item_sum_count :public Item_sum_int
   void cleanup();
   void remove();
 
-  public:
+public:
   Item_sum_count(THD *thd, Item *item_par):
-    Item_sum_int(thd, item_par), count(0)
+    Item_sum_int(thd, item_par), direct_counted(FALSE),
+    direct_reseted_field(FALSE), count(0)
   {}
 
   /**
@@ -831,12 +845,14 @@ class Item_sum_count :public Item_sum_int
   */
 
   Item_sum_count(THD *thd, List<Item> &list):
-    Item_sum_int(thd, list), count(0)
+    Item_sum_int(thd, list), direct_counted(FALSE),
+    direct_reseted_field(FALSE), count(0)
   {
     set_distinct(TRUE);
   }
   Item_sum_count(THD *thd, Item_sum_count *item):
-    Item_sum_int(thd, item), count(item->count)
+    Item_sum_int(thd, item), direct_counted(FALSE),
+    direct_reseted_field(FALSE), count(item->count)
   {}
   enum Sumfunctype sum_func () const 
   { 
@@ -851,6 +867,7 @@ class Item_sum_count :public Item_sum_int
   longlong val_int();
   void reset_field();
   void update_field();
+  void direct_add(longlong add_count);
   const char *func_name() const 
   { 
     return has_with_distinct() ? "count(distinct " : "count(";
@@ -1009,6 +1026,8 @@ class Item_cache;
 class Item_sum_hybrid :public Item_sum, public Type_handler_hybrid_field_type
 {
 protected:
+  bool direct_added;
+  Item *direct_item;
   Item_cache *value, *arg_cache;
   Arg_comparator *cmp;
   int cmp_sign;
@@ -1019,19 +1038,20 @@ protected:
   Item_sum_hybrid(THD *thd, Item *item_par,int sign):
     Item_sum(thd, item_par),
     Type_handler_hybrid_field_type(&type_handler_longlong),
-    value(0), arg_cache(0), cmp(0),
+    direct_added(FALSE), value(0), arg_cache(0), cmp(0),
     cmp_sign(sign), was_values(TRUE)
   { collation.set(&my_charset_bin); }
   Item_sum_hybrid(THD *thd, Item_sum_hybrid *item)
     :Item_sum(thd, item),
     Type_handler_hybrid_field_type(item),
-    value(item->value), arg_cache(0),
+    direct_added(FALSE), value(item->value), arg_cache(0),
     cmp_sign(item->cmp_sign), was_values(item->was_values)
   { }
   bool fix_fields(THD *, Item **);
   void fix_length_and_dec();
   void setup_hybrid(THD *thd, Item *item, Item *value_arg);
   void clear();
+  void direct_add(Item *item);
   double val_real();
   longlong val_int();
   my_decimal *val_decimal(my_decimal *);
@@ -1204,6 +1224,132 @@ private:
   void set_bits_from_counters();
 };
 
+class sp_head;
+class sp_name;
+class Query_arena;
+struct st_sp_security_context;
+
+/*
+  Item_sum_sp handles STORED AGGREGATE FUNCTIONS
+
+  Each Item_sum_sp represents a custom aggregate function. Inside the
+  function's body, we require at least one occurence of FETCH GROUP NEXT ROW
+  instruction. This cursor is what makes custom stored aggregates possible.
+
+  During computation the function's add method is called. This in turn performs
+  an execution of the function. The function will execute from the current
+  function context (and instruction), if one exists, or from the start if not.
+  See Item_sp for more details.
+
+  Upon encounter of FETCH GROUP NEXT ROW instruction, the function will pause
+  execution. We assume that the user has performed the necessary additions for
+  a row, between two encounters of FETCH GROUP NEXT ROW.
+
+  Example:
+  create aggregate function f1(x INT) returns int
+  begin
+    declare continue handler for not found return s;
+    declare s int default 0
+    loop
+      fetch group next row;
+      set s = s + x;
+    end loop;
+  end
+
+  The function will always stop after an encounter of FETCH GROUP NEXT ROW,
+  except (!) on first encounter, as the value for the first row in the
+  group is already set in the argument x. This behaviour is done so when
+  a user writes a function, he should "logically" include FETCH GROUP NEXT ROW
+  before any "add" instructions in the stored function. This means however that
+  internally, the first occurence doesn't stop the function. See the
+  implementation of FETCH GROUP NEXT ROW for details as to how it happens.
+
+  Either way, one should assume that after calling "Item_sum_sp::add()" that
+  the values for that particular row have been added to the aggregation.
+
+  To produce values for val_xxx methods we need an extra syntactic construct.
+  We require a continue handler when "no more rows are available". val_xxx
+  methods force a function return by executing the function again, while
+  setting a server flag that no more rows have been found. This implies
+  that val_xxx methods should only be called once per group however.
+
+  Example:
+  DECLARE CONTINUE HANDLER FOR NOT FOUND RETURN ret_val;
+*/
+class Item_sum_sp :public Item_sum,
+                   public Item_sp
+{
+ private:
+  bool execute();
+
+public:
+  Item_sum_sp(THD *thd, Name_resolution_context *context_arg, sp_name *name,
+              sp_head *sp);
+
+  Item_sum_sp(THD *thd, Name_resolution_context *context_arg, sp_name *name,
+              sp_head *sp, List<Item> &list);
+
+  enum Sumfunctype sum_func () const
+  {
+    return SP_AGGREGATE_FUNC;
+  }
+  void fix_length_and_dec();
+  bool fix_fields(THD *thd, Item **ref);
+  const char *func_name() const;
+  const Type_handler *type_handler() const;
+  bool add();
+
+  /* val_xx functions */
+  longlong val_int()
+  {
+    if(execute())
+      return 0;
+    return sp_result_field->val_int();
+  }
+
+  double val_real()
+  {
+    if(execute())
+      return 0.0;
+    return sp_result_field->val_real();
+  }
+
+  my_decimal *val_decimal(my_decimal *dec_buf)
+  {
+    if(execute())
+      return NULL;
+    return sp_result_field->val_decimal(dec_buf);
+  }
+
+  String *val_str(String *str)
+  {
+    String buf;
+    char buff[20];
+    buf.set(buff, 20, str->charset());
+    buf.length(0);
+    if (execute())
+      return NULL;
+    /*
+      result_field will set buf pointing to internal buffer
+      of the resul_field. Due to this it will change any time
+      when SP is executed. In order to prevent occasional
+      corruption of returned value, we make here a copy.
+    */
+    sp_result_field->val_str(&buf);
+    str->copy(buf);
+    return str;
+  }
+  void reset_field(){DBUG_ASSERT(0);}
+  void update_field(){DBUG_ASSERT(0);}
+  void clear();
+  void cleanup();
+  inline Field *get_sp_result_field()
+  {
+    return sp_result_field;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_sum_sp>(thd, this); }
+};
 
 /* Items to get the value of a stored sum function */
 
@@ -1601,6 +1747,16 @@ class Item_func_group_concat : public Item_sum
   bool always_null;
   bool force_copy_fields;
   bool no_appended;
+  /** Limits the rows in the result */
+  Item *row_limit;
+  /** Skips a particular number of rows in from the result*/
+  Item *offset_limit;
+  bool limit_clause;
+  /* copy of the offset limit */
+  ulonglong copy_offset_limit;
+  /*copy of the row limit */
+  ulonglong copy_row_limit;
+
   /*
     Following is 0 normal object and pointer to original one for copy
     (to correctly free resources)
@@ -1617,7 +1773,8 @@ class Item_func_group_concat : public Item_sum
 public:
   Item_func_group_concat(THD *thd, Name_resolution_context *context_arg,
                          bool is_distinct, List<Item> *is_select,
-                         const SQL_I_List<ORDER> &is_order, String *is_separator);
+                         const SQL_I_List<ORDER> &is_order, String *is_separator,
+                         bool limit_clause, Item *row_limit, Item *offset_limit);
 
   Item_func_group_concat(THD *thd, Item_func_group_concat *item);
   ~Item_func_group_concat();
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index 3a7684fe7b4..fd170a707c9 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -2434,6 +2434,8 @@ void Item_char_typecast::check_truncation_with_warn(String *src, uint dstlen)
     THD *thd= current_thd;
     char char_type[40];
     ErrConvString err(src);
+    bool save_abort_on_warning= thd->abort_on_warning;
+    thd->abort_on_warning&= !m_suppress_warning_to_error_escalation;
     my_snprintf(char_type, sizeof(char_type), "%s(%lu)",
                 cast_cs == &my_charset_bin ? "BINARY" : "CHAR",
                 (ulong) cast_length);
@@ -2441,6 +2443,7 @@ void Item_char_typecast::check_truncation_with_warn(String *src, uint dstlen)
                         ER_TRUNCATED_WRONG_VALUE,
                         ER_THD(thd, ER_TRUNCATED_WRONG_VALUE), char_type,
                         err.ptr());
+    thd->abort_on_warning= save_abort_on_warning;
   }
 }
 
@@ -2551,7 +2554,7 @@ void Item_char_typecast::fix_length_and_dec_numeric()
 }
 
 
-void Item_char_typecast::fix_length_and_dec_str()
+void Item_char_typecast::fix_length_and_dec_generic()
 {
   fix_length_and_dec_internal(from_cs= args[0]->dynamic_result() ?
                                        0 :
diff --git a/sql/item_timefunc.h b/sql/item_timefunc.h
index bf744cc24cd..adc7b2535a9 100644
--- a/sql/item_timefunc.h
+++ b/sql/item_timefunc.h
@@ -1089,6 +1089,7 @@ class Item_char_typecast :public Item_str_func
   CHARSET_INFO *cast_cs, *from_cs;
   bool charset_conversion;
   String tmp_value;
+  bool m_suppress_warning_to_error_escalation;
   bool has_explicit_length() const { return cast_length != ~0U; }
   String *reuse(String *src, uint32 length);
   String *copy(String *src, CHARSET_INFO *cs);
@@ -1097,14 +1098,20 @@ class Item_char_typecast :public Item_str_func
   void fix_length_and_dec_internal(CHARSET_INFO *fromcs);
 public:
   Item_char_typecast(THD *thd, Item *a, uint length_arg, CHARSET_INFO *cs_arg):
-    Item_str_func(thd, a), cast_length(length_arg), cast_cs(cs_arg) {}
+    Item_str_func(thd, a), cast_length(length_arg), cast_cs(cs_arg),
+    m_suppress_warning_to_error_escalation(false) {}
   enum Functype functype() const { return CHAR_TYPECAST_FUNC; }
   bool eq(const Item *item, bool binary_cmp) const;
   const char *func_name() const { return "cast_as_char"; }
   CHARSET_INFO *cast_charset() const { return cast_cs; }
   String *val_str(String *a);
+  void fix_length_and_dec_generic();
   void fix_length_and_dec_numeric();
-  void fix_length_and_dec_str();
+  void fix_length_and_dec_str()
+  {
+    fix_length_and_dec_generic();
+    m_suppress_warning_to_error_escalation= true;
+  }
   void fix_length_and_dec()
   {
     args[0]->type_handler()->Item_char_typecast_fix_length_and_dec(this);
diff --git a/sql/item_windowfunc.cc b/sql/item_windowfunc.cc
index 8432ab43ad8..cd0fb5058a6 100644
--- a/sql/item_windowfunc.cc
+++ b/sql/item_windowfunc.cc
@@ -334,8 +334,8 @@ bool Item_sum_hybrid_simple::fix_fields(THD *thd, Item **ref)
       return TRUE;
   }
   Type_std_attributes::set(args[0]);
-  for (uint i= 0; i < arg_count && !with_subselect; i++)
-    with_subselect= with_subselect || args[i]->with_subselect;
+  for (uint i= 0; i < arg_count && !m_with_subquery; i++)
+    m_with_subquery|= args[i]->with_subquery();
 
   Item *item2= args[0]->real_item();
   if (item2->type() == Item::FIELD_ITEM)
diff --git a/sql/lex.h b/sql/lex.h
index 25b6b834a55..d31625292e3 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -181,6 +181,7 @@ static SYMBOL symbols[] = {
   { "DELAYED",		SYM(DELAYED_SYM)},
   { "DELAY_KEY_WRITE",	SYM(DELAY_KEY_WRITE_SYM)},
   { "DELETE",		SYM(DELETE_SYM)},
+  { "DELETE_DOMAIN_ID", SYM(DELETE_DOMAIN_ID_SYM)},
   { "DESC",		SYM(DESC)},
   { "DESCRIBE",		SYM(DESCRIBE)},
   { "DES_KEY_FILE",	SYM(DES_KEY_FILE)},
diff --git a/sql/log.cc b/sql/log.cc
index be8b24da8df..e5ff85e4544 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2391,7 +2391,7 @@ File open_binlog(IO_CACHE *log, const char *log_file_name, const char **errmsg)
     *errmsg = "Could not open log file";
     goto err;
   }
-  if (init_io_cache(log, file, binlog_file_cache_size, READ_CACHE, 0, 0,
+  if (init_io_cache(log, file, (size_t)binlog_file_cache_size, READ_CACHE, 0, 0,
                     MYF(MY_WME|MY_DONT_CHECK_FILESIZE)))
   {
     sql_print_error("Failed to create a cache on log (file '%s')",
@@ -4171,14 +4171,6 @@ bool MYSQL_BIN_LOG::reset_logs(THD *thd, bool create_new_log,
     mysql_mutex_unlock(&LOCK_xid_list);
   }
 
-  /*
-    The following mutex is needed to ensure that no threads call
-    'delete thd' as we would then risk missing a 'rollback' from this
-    thread. If the transaction involved MyISAM tables, it should go
-    into binlog even on rollback.
-  */
-  mysql_mutex_lock(&LOCK_thread_count);
-
   /* Save variables so that we can reopen the log */
   save_name=name;
   name=0;					// Protect against free
@@ -4285,7 +4277,6 @@ bool MYSQL_BIN_LOG::reset_logs(THD *thd, bool create_new_log,
 err:
   if (error == 1)
     name= const_cast<char*>(save_name);
-  mysql_mutex_unlock(&LOCK_thread_count);
 
   if (!is_relay_log)
   {
@@ -6674,6 +6665,120 @@ void MYSQL_BIN_LOG::checkpoint_and_purge(ulong binlog_id)
   purge();
 }
 
+
+/**
+  Searches for the first (oldest) binlog file name in in the binlog index.
+
+  @param[in,out]  buf_arg  pointer to a buffer to hold found
+                           the first binary log file name
+  @return         NULL     on success, otherwise error message
+*/
+static const char* get_first_binlog(char* buf_arg)
+{
+  IO_CACHE *index_file;
+  size_t length;
+  char fname[FN_REFLEN];
+  const char* errmsg= NULL;
+
+  DBUG_ENTER("get_first_binlog");
+
+  DBUG_ASSERT(mysql_bin_log.is_open());
+
+  mysql_bin_log.lock_index();
+
+  index_file=mysql_bin_log.get_index_file();
+  if (reinit_io_cache(index_file, READ_CACHE, (my_off_t) 0, 0, 0))
+  {
+    errmsg= "failed to create a cache on binlog index";
+    goto end;
+  }
+  /* The file ends with EOF or empty line */
+  if ((length=my_b_gets(index_file, fname, sizeof(fname))) <= 1)
+  {
+    errmsg= "empty binlog index";
+    goto end;
+  }
+  else
+  {
+    fname[length-1]= 0;                         // Remove end \n
+  }
+  if (normalize_binlog_name(buf_arg, fname, false))
+  {
+    errmsg= "cound not normalize the first file name in the binlog index";
+    goto end;
+  }
+end:
+  mysql_bin_log.unlock_index();
+
+  DBUG_RETURN(errmsg);
+}
+
+/**
+  Check weather the gtid binlog state can safely remove gtid
+  domains passed as the argument. A safety condition is satisfied when
+  there are no events from the being deleted domains in the currently existing
+  binlog files. Upon successful check the supplied domains are removed
+  from @@gtid_binlog_state. The caller is supposed to rotate binlog so that
+  the active latest file won't have the deleted domains in its Gtid_list header.
+
+  @param  domain_drop_lex  gtid domain id sequence from lex.
+                           Passed as a pointer to dynamic array must be not empty
+                           unless pointer value NULL.
+  @retval zero             on success
+  @retval > 0              ineffective call none from the *non* empty
+                           gtid domain sequence is deleted
+  @retval < 0              on error
+*/
+static int do_delete_gtid_domain(DYNAMIC_ARRAY *domain_drop_lex)
+{
+  int rc= 0;
+  Gtid_list_log_event *glev= NULL;
+  char buf[FN_REFLEN];
+  File file;
+  IO_CACHE cache;
+  const char* errmsg= NULL;
+  char errbuf[MYSQL_ERRMSG_SIZE]= {0};
+
+  if (!domain_drop_lex)
+    return 0; // still "effective" having empty domain sequence to delete
+
+  DBUG_ASSERT(domain_drop_lex->elements > 0);
+  mysql_mutex_assert_owner(mysql_bin_log.get_log_lock());
+
+  if ((errmsg= get_first_binlog(buf)) != NULL)
+    goto end;
+  bzero((char*) &cache, sizeof(cache));
+  if ((file= open_binlog(&cache, buf, &errmsg)) == (File) -1)
+    goto end;
+  errmsg= get_gtid_list_event(&cache, &glev);
+  end_io_cache(&cache);
+  mysql_file_close(file, MYF(MY_WME));
+
+  DBUG_EXECUTE_IF("inject_binlog_delete_domain_init_error",
+                  errmsg= "injected error";);
+  if (errmsg)
+    goto end;
+  errmsg= rpl_global_gtid_binlog_state.drop_domain(domain_drop_lex,
+                                                   glev, errbuf);
+
+end:
+  if (errmsg)
+  {
+    if (strlen(errmsg) > 0)
+    {
+      my_error(ER_BINLOG_CANT_DELETE_GTID_DOMAIN, MYF(0), errmsg);
+      rc= -1;
+    }
+    else
+    {
+      rc= 1;
+    }
+  }
+  delete glev;
+
+  return rc;
+}
+
 /**
   The method is a shortcut of @c rotate() and @c purge().
   LOCK_log is acquired prior to rotate and is released after it.
@@ -6683,16 +6788,24 @@ void MYSQL_BIN_LOG::checkpoint_and_purge(ulong binlog_id)
   @retval
     nonzero - error in rotating routine.
 */
-int MYSQL_BIN_LOG::rotate_and_purge(bool force_rotate)
+int MYSQL_BIN_LOG::rotate_and_purge(bool force_rotate,
+                                    DYNAMIC_ARRAY *domain_drop_lex)
 {
-  int error= 0;
+  int err_gtid=0, error= 0;
   ulong prev_binlog_id;
   DBUG_ENTER("MYSQL_BIN_LOG::rotate_and_purge");
   bool check_purge= false;
 
   mysql_mutex_lock(&LOCK_log);
   prev_binlog_id= current_binlog_id;
-  if ((error= rotate(force_rotate, &check_purge)))
+
+  if ((err_gtid= do_delete_gtid_domain(domain_drop_lex)))
+  {
+    // inffective attempt to delete merely skips rotate and purge
+    if (err_gtid < 0)
+      error= 1; // otherwise error is propagated the user
+  }
+  else if ((error= rotate(force_rotate, &check_purge)))
     check_purge= false;
   /*
     NOTE: Run purge_logs wo/ holding LOCK_log because it does not need
@@ -7096,8 +7209,15 @@ MYSQL_BIN_LOG::write_transaction_to_binlog(THD *thd,
     mode. Also, do not write the cached updates to binlog if binary logging is
     disabled (log-bin/sql_log_bin).
   */
-  if (wsrep_emulate_bin_log || !(thd->variables.option_bits & OPTION_BIN_LOG))
+  if (wsrep_emulate_bin_log)
+  {
     DBUG_RETURN(0);
+  }
+  else if (!(thd->variables.option_bits & OPTION_BIN_LOG))
+  {
+    cache_mngr->need_unlog= false;
+    DBUG_RETURN(0);
+  }
 
   entry.thd= thd;
   entry.cache_mngr= cache_mngr;
@@ -9398,11 +9518,19 @@ TC_LOG_BINLOG::log_and_order(THD *thd, my_xid xid, bool all,
 
   if (err)
     DBUG_RETURN(0);
+
+  bool need_unlog= cache_mngr->need_unlog;
+  /*
+    The transaction won't need the flag anymore.
+    Todo/fixme: consider to move the statement into cache_mngr->reset()
+                relocated to the current or later point.
+  */
+  cache_mngr->need_unlog= false;
   /*
     If using explicit user XA, we will not have XID. We must still return a
     non-zero cookie (as zero cookie signals error).
   */
-  if (!xid || !cache_mngr->need_unlog)
+  if (!xid || !need_unlog)
     DBUG_RETURN(BINLOG_COOKIE_DUMMY(cache_mngr->delayed_error));
   else
     DBUG_RETURN(BINLOG_COOKIE_MAKE(cache_mngr->binlog_id,
@@ -9475,6 +9603,9 @@ TC_LOG_BINLOG::mark_xid_done(ulong binlog_id, bool write_checkpoint)
     if (b->binlog_id == binlog_id)
     {
       --b->xid_count;
+
+      DBUG_ASSERT(b->xid_count >= 0); // catch unmatched (++) decrement
+
       break;
     }
     first= false;
@@ -10248,6 +10379,73 @@ TC_LOG_BINLOG::set_status_variables(THD *thd)
   }
 }
 
+
+/*
+  Find the Gtid_list_log_event at the start of a binlog.
+
+  NULL for ok, non-NULL error message for error.
+
+  If ok, then the event is returned in *out_gtid_list. This can be NULL if we
+  get back to binlogs written by old server version without GTID support. If
+  so, it means we have reached the point to start from, as no GTID events can
+  exist in earlier binlogs.
+*/
+const char *
+get_gtid_list_event(IO_CACHE *cache, Gtid_list_log_event **out_gtid_list)
+{
+  Format_description_log_event init_fdle(BINLOG_VERSION);
+  Format_description_log_event *fdle;
+  Log_event *ev;
+  const char *errormsg = NULL;
+
+  *out_gtid_list= NULL;
+
+  if (!(ev= Log_event::read_log_event(cache, 0, &init_fdle,
+                                      opt_master_verify_checksum)) ||
+      ev->get_type_code() != FORMAT_DESCRIPTION_EVENT)
+  {
+    if (ev)
+      delete ev;
+    return "Could not read format description log event while looking for "
+      "GTID position in binlog";
+  }
+
+  fdle= static_cast<Format_description_log_event *>(ev);
+
+  for (;;)
+  {
+    Log_event_type typ;
+
+    ev= Log_event::read_log_event(cache, 0, fdle, opt_master_verify_checksum);
+    if (!ev)
+    {
+      errormsg= "Could not read GTID list event while looking for GTID "
+        "position in binlog";
+      break;
+    }
+    typ= ev->get_type_code();
+    if (typ == GTID_LIST_EVENT)
+      break;                                    /* Done, found it */
+    if (typ == START_ENCRYPTION_EVENT)
+    {
+      if (fdle->start_decryption((Start_encryption_log_event*) ev))
+        errormsg= "Could not set up decryption for binlog.";
+    }
+    delete ev;
+    if (typ == ROTATE_EVENT || typ == STOP_EVENT ||
+        typ == FORMAT_DESCRIPTION_EVENT || typ == START_ENCRYPTION_EVENT)
+      continue;                                 /* Continue looking */
+
+    /* We did not find any Gtid_list_log_event, must be old binlog. */
+    ev= NULL;
+    break;
+  }
+
+  delete fdle;
+  *out_gtid_list= static_cast<Gtid_list_log_event *>(ev);
+  return errormsg;
+}
+
 struct st_mysql_storage_engine binlog_storage_engine=
 { MYSQL_HANDLERTON_INTERFACE_VERSION };
 
diff --git a/sql/log.h b/sql/log.h
index 30829bdb33c..dffb6a80d54 100644
--- a/sql/log.h
+++ b/sql/log.h
@@ -759,7 +759,7 @@ public:
   int update_log_index(LOG_INFO* linfo, bool need_update_threads);
   int rotate(bool force_rotate, bool* check_purge);
   void checkpoint_and_purge(ulong binlog_id);
-  int rotate_and_purge(bool force_rotate);
+  int rotate_and_purge(bool force_rotate, DYNAMIC_ARRAY* drop_gtid_domain= NULL);
   /**
      Flush binlog cache and synchronize to disk.
 
@@ -1169,4 +1169,9 @@ static inline TC_LOG *get_tc_log_implementation()
   return &tc_log_mmap;
 }
 
+
+class Gtid_list_log_event;
+const char *
+get_gtid_list_event(IO_CACHE *cache, Gtid_list_log_event **out_gtid_list);
+
 #endif /* LOG_H */
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index e77184999dc..ad76d043cc7 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -446,6 +446,7 @@ my_bool opt_replicate_annotate_row_events= 0;
 my_bool opt_mysql56_temporal_format=0, strict_password_validation= 1;
 my_bool opt_explicit_defaults_for_timestamp= 0;
 char *opt_slave_skip_errors;
+char *opt_slave_transaction_retry_errors;
 
 /*
   Legacy global handlerton. These will be removed (please do not add more).
@@ -501,6 +502,7 @@ ulong what_to_log;
 ulong slow_launch_time;
 ulong open_files_limit, max_binlog_size;
 ulong slave_trans_retries;
+ulong slave_trans_retry_interval;
 uint  slave_net_timeout;
 ulong slave_exec_mode_options;
 ulong slave_run_triggers_for_rbr= 0;
@@ -2178,6 +2180,9 @@ static void mysqld_exit(int exit_code)
             (long) global_status_var.global_memory_used);
   if (!opt_debugging && !my_disable_leak_check && exit_code == 0)
   {
+#ifdef SAFEMALLOC
+    sf_report_leaked_memory(0);
+#endif
     DBUG_SLOW_ASSERT(global_status_var.global_memory_used == 0);
   }
   cleanup_tls();
@@ -5953,9 +5958,6 @@ int mysqld_main(int argc, char **argv)
 #ifdef __WIN__
   if (!opt_console)
   {
-    if (reopen_fstreams(log_error_file, stdout, stderr))
-      unireg_abort(1);
-    setbuf(stderr, NULL);
     FreeConsole();				// Remove window
   }
 
@@ -7800,6 +7802,7 @@ struct my_option my_long_options[]=
   MYSQL_SUGGEST_ANALOG_OPTION("max-binlog-dump-events", "--debug-max-binlog-dump-events"),
   MYSQL_SUGGEST_ANALOG_OPTION("sporadic-binlog-dump-fail", "--debug-sporadic-binlog-dump-fail"),
   MYSQL_COMPATIBILITY_OPTION("new"),
+  MYSQL_COMPATIBILITY_OPTION("show_compatibility_56"),
 
   /* The following options were added after 5.6.10 */
   MYSQL_TO_BE_IMPLEMENTED_OPTION("rpl-stop-slave-timeout"),
@@ -9085,12 +9088,12 @@ mysqld_get_one_option(int optid, const struct my_option *opt, char *argument)
                       opt->name);
     break;
   case OPT_MYSQL_COMPATIBILITY:
-    sql_print_warning("'%s' is MySQL 5.6 compatible option. Not used or needed "
-                      "in MariaDB.", opt->name);
+    sql_print_warning("'%s' is MySQL 5.6 / 5.7 compatible option. Not used or "
+                      "needed in MariaDB.", opt->name);
     break;
   case OPT_MYSQL_TO_BE_IMPLEMENTED:
-    sql_print_warning("'%s' is MySQL 5.6 compatible option. To be implemented "
-                      "in later versions.", opt->name);
+    sql_print_warning("'%s' is MySQL 5.6 / 5.7 compatible option. To be "
+                      "implemented in later versions.", opt->name);
     break;
   case 'a':
     SYSVAR_AUTOSIZE(global_system_variables.sql_mode, MODE_ANSI);
@@ -9678,8 +9681,10 @@ static int get_options(int *argc_ptr, char ***argv_ptr)
     flush_time= 0;
 
 #ifdef HAVE_REPLICATION
-  if (opt_slave_skip_errors)
-    init_slave_skip_errors(opt_slave_skip_errors);
+  if (init_slave_skip_errors(opt_slave_skip_errors))
+    return 1;
+  if (init_slave_transaction_retry_errors(opt_slave_transaction_retry_errors))
+    return 1;
 #endif
 
   if (global_system_variables.max_join_size == HA_POS_ERROR)
diff --git a/sql/mysqld.h b/sql/mysqld.h
index 4aaadcc618e..5c389e60e17 100644
--- a/sql/mysqld.h
+++ b/sql/mysqld.h
@@ -246,6 +246,7 @@ extern my_bool slave_allow_batching;
 extern my_bool allow_slave_start;
 extern LEX_CSTRING reason_slave_blocked;
 extern ulong slave_trans_retries;
+extern ulong slave_trans_retry_interval;
 extern uint  slave_net_timeout;
 extern int max_user_connections;
 extern volatile ulong cached_thread_count;
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index f261c5731cf..fba449e7ce2 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -1236,7 +1236,8 @@ QUICK_SELECT_I::QUICK_SELECT_I()
 QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr,
                                        bool no_alloc, MEM_ROOT *parent_alloc,
                                        bool *create_error)
-  :free_file(0),cur_range(NULL),last_range(0),dont_free(0)
+  :thd(thd), no_alloc(no_alloc), parent_alloc(parent_alloc),
+   free_file(0),cur_range(NULL),last_range(0),dont_free(0)
 {
   my_bitmap_map *bitmap;
   DBUG_ENTER("QUICK_RANGE_SELECT::QUICK_RANGE_SELECT");
diff --git a/sql/opt_range.h b/sql/opt_range.h
index b3eb25e5f65..bd85a12d4a1 100644
--- a/sql/opt_range.h
+++ b/sql/opt_range.h
@@ -1047,6 +1047,10 @@ bool quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
 class QUICK_RANGE_SELECT : public QUICK_SELECT_I
 {
 protected:
+  THD *thd;
+  bool no_alloc;
+  MEM_ROOT *parent_alloc;
+
   /* true if we enabled key only reads */
   handler *file;
 
@@ -1085,6 +1089,9 @@ public:
   QUICK_RANGE_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc,
                      MEM_ROOT *parent_alloc, bool *create_err);
   ~QUICK_RANGE_SELECT();
+  virtual QUICK_RANGE_SELECT *clone(bool *create_error)
+    { return new QUICK_RANGE_SELECT(thd, head, index, no_alloc, parent_alloc,
+                                    create_error); }
   
   void need_sorted_output();
   int init();
@@ -1155,6 +1162,12 @@ public:
     :QUICK_RANGE_SELECT(thd, table, index_arg, no_alloc, parent_alloc,
     create_err)
     {};
+  virtual QUICK_RANGE_SELECT *clone(bool *create_error)
+    {
+      DBUG_ASSERT(0);
+      return new QUICK_RANGE_SELECT_GEOM(thd, head, index, no_alloc,
+                                         parent_alloc, create_error);
+    }
   virtual int get_next();
 };
 
@@ -1584,6 +1597,8 @@ class QUICK_SELECT_DESC: public QUICK_RANGE_SELECT
 {
 public:
   QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint used_key_parts);
+  virtual QUICK_RANGE_SELECT *clone(bool *create_error)
+    { DBUG_ASSERT(0); return new QUICK_SELECT_DESC(this, used_key_parts); }
   int get_next();
   bool reverse_sorted() { return 1; }
   int get_type() { return QS_TYPE_RANGE_DESC; }
@@ -1690,6 +1705,8 @@ public:
       QUICK_RANGE_SELECT (thd, table, key, 1, NULL, create_err) 
   { (void) init(); }
   ~FT_SELECT() { file->ft_end(); }
+  virtual QUICK_RANGE_SELECT *clone(bool *create_error)
+    { DBUG_ASSERT(0); return new FT_SELECT(thd, head, index, create_error); }
   int init() { return file->ft_init(); }
   int reset() { return 0; }
   int get_next() { return file->ha_ft_read(record); }
diff --git a/sql/opt_subselect.cc b/sql/opt_subselect.cc
index 72da68816ad..9cd2eedb55d 100644
--- a/sql/opt_subselect.cc
+++ b/sql/opt_subselect.cc
@@ -1631,7 +1631,7 @@ static bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)
 
   // The subqueries were replaced for Item_int(1) earlier
   subq_pred->reset_strategy(SUBS_SEMI_JOIN);       // for subsequent executions
-  /*TODO: also reset the 'with_subselect' there. */
+  /*TODO: also reset the 'm_with_subquery' there. */
 
   /* n. Adjust the parent_join->table_count counter */
   uint table_no= parent_join->table_count;
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index 72b28473e15..43d1c2de7ad 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -398,6 +398,8 @@ int opt_sum_query(THD *thd,
             const_result= 0;
             break;
           }
+          longlong info_limit= 1;
+          table->file->info_push(INFO_KIND_FORCE_LIMIT_BEGIN, &info_limit);
           if (!(error= table->file->ha_index_init((uint) ref.key, 1)))
             error= (is_max ? 
                     get_index_max_value(table, &ref, range_fl) :
@@ -410,6 +412,7 @@ int opt_sum_query(THD *thd,
 	    error= HA_ERR_KEY_NOT_FOUND;
           table->file->ha_end_keyread();
           table->file->ha_index_end();
+          table->file->info_push(INFO_KIND_FORCE_LIMIT_END, NULL);
           if (error)
 	  {
 	    if (error == HA_ERR_KEY_NOT_FOUND || error == HA_ERR_END_OF_FILE)
diff --git a/sql/opt_table_elimination.cc b/sql/opt_table_elimination.cc
index 390afc575ca..ef9b07cca47 100644
--- a/sql/opt_table_elimination.cc
+++ b/sql/opt_table_elimination.cc
@@ -1810,6 +1810,7 @@ static void mark_as_eliminated(JOIN *join, TABLE_LIST *tbl)
     {
       DBUG_PRINT("info", ("Eliminated table %s", table->alias.c_ptr()));
       tab->type= JT_CONST;
+      tab->table->const_table= 1;
       join->eliminated_tables |= table->map;
       join->const_table_map|= table->map;
       set_position(join, join->const_tables++, tab, (KEYUSE*)0);
diff --git a/sql/protocol.cc b/sql/protocol.cc
index dbaa8ae6a1e..fae399e66e2 100644
--- a/sql/protocol.cc
+++ b/sql/protocol.cc
@@ -1327,6 +1327,7 @@ bool Protocol_text::send_out_parameters(List<Item_param> *sp_params)
       continue;
     }
 
+    DBUG_ASSERT(sparam->get_item_param() == NULL);
     sparam->set_value(thd, thd->spcont, reinterpret_cast<Item **>(&item_param));
   }
 
diff --git a/sql/rpl_gtid.cc b/sql/rpl_gtid.cc
index d58a2ea4d3e..369b072ab47 100644
--- a/sql/rpl_gtid.cc
+++ b/sql/rpl_gtid.cc
@@ -26,7 +26,7 @@
 #include "rpl_gtid.h"
 #include "rpl_rli.h"
 #include "slave.h"
-
+#include "log_event.h"
 
 const LEX_STRING rpl_gtid_slave_state_table_name=
   { C_STRING_WITH_LEN("gtid_slave_pos") };
@@ -1940,6 +1940,155 @@ end:
   return res;
 }
 
+/**
+  Remove domains supplied by the first argument from binlog state.
+  Removal is done for any domain whose last gtids (from all its servers) match
+  ones in Gtid list event of the 2nd argument.
+
+  @param  ids               gtid domain id sequence, may contain dups
+  @param  glev              pointer to Gtid list event describing
+                            the match condition
+  @param  errbuf [out]      pointer to possible error message array
+
+  @retval NULL              as success when at least one domain is removed
+  @retval ""                empty string to indicate ineffective call
+                            when no domains removed
+  @retval NOT EMPTY string  otherwise an error message
+*/
+const char*
+rpl_binlog_state::drop_domain(DYNAMIC_ARRAY *ids,
+                              Gtid_list_log_event *glev,
+                              char* errbuf)
+{
+  DYNAMIC_ARRAY domain_unique; // sequece (unsorted) of unique element*:s
+  rpl_binlog_state::element* domain_unique_buffer[16];
+  ulong k, l;
+  const char* errmsg= NULL;
+
+  DBUG_ENTER("rpl_binlog_state::drop_domain");
+
+  my_init_dynamic_array2(&domain_unique,
+                         sizeof(element*), domain_unique_buffer,
+                         sizeof(domain_unique_buffer) / sizeof(element*), 4, 0);
+
+  mysql_mutex_lock(&LOCK_binlog_state);
+
+  /*
+    Gtid list is supposed to come from a binlog's Gtid_list event and
+    therefore should be a subset of the current binlog state. That is
+    for every domain in the list the binlog state contains a gtid with
+    sequence number not less than that of the list.
+    Exceptions of this inclusion rule are:
+      A. the list may still refer to gtids from already deleted domains.
+         Files containing them must have been purged whereas the file
+         with the list is not yet.
+      B. out of order groups were injected
+      C. manually build list of binlog files violating the inclusion
+         constraint.
+    While A is a normal case (not necessarily distinguishable from C though),
+    B and C may require the user's attention so any (incl the A's suspected)
+    inconsistency is diagnosed and *warned*.
+  */
+  for (l= 0, errbuf[0]= 0; l < glev->count; l++, errbuf[0]= 0)
+  {
+    rpl_gtid* rb_state_gtid= find_nolock(glev->list[l].domain_id,
+                                         glev->list[l].server_id);
+    if (!rb_state_gtid)
+      sprintf(errbuf,
+              "missing gtids from the '%u-%u' domain-server pair which is "
+              "referred to in the gtid list describing an earlier state. Ignore "
+              "if the domain ('%u') was already explicitly deleted",
+              glev->list[l].domain_id, glev->list[l].server_id,
+              glev->list[l].domain_id);
+    else if (rb_state_gtid->seq_no < glev->list[l].seq_no)
+      sprintf(errbuf,
+              "having a gtid '%u-%u-%llu' which is less than "
+              "the '%u-%u-%llu' of the gtid list describing an earlier state. "
+              "The state may have been affected by manually injecting "
+              "a lower sequence number gtid or via replication",
+              rb_state_gtid->domain_id, rb_state_gtid->server_id,
+              rb_state_gtid->seq_no, glev->list[l].domain_id,
+              glev->list[l].server_id, glev->list[l].seq_no);
+    if (strlen(errbuf)) // use strlen() as cheap flag
+      push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_BINLOG_CANT_DELETE_GTID_DOMAIN,
+                          "The current gtid binlog state is incompatible with "
+                          "a former one %s.", errbuf);
+  }
+
+  /*
+    For each domain_id from ids
+      when no such domain in binlog state
+        warn && continue
+      For each domain.server's last gtid
+        when not locate the last gtid in glev.list
+          error out binlog state can't change
+        otherwise continue
+  */
+  for (ulong i= 0; i < ids->elements; i++)
+  {
+    rpl_binlog_state::element *elem= NULL;
+    ulong *ptr_domain_id;
+    bool not_match;
+
+    ptr_domain_id= (ulong*) dynamic_array_ptr(ids, i);
+    elem= (rpl_binlog_state::element *)
+      my_hash_search(&hash, (const uchar *) ptr_domain_id, 0);
+    if (!elem)
+    {
+      push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_BINLOG_CANT_DELETE_GTID_DOMAIN,
+                          "The gtid domain being deleted ('%lu') is not in "
+                          "the current binlog state", *ptr_domain_id);
+      continue;
+    }
+
+    for (not_match= true, k= 0; k < elem->hash.records; k++)
+    {
+      rpl_gtid *d_gtid= (rpl_gtid *)my_hash_element(&elem->hash, k);
+      for (ulong l= 0; l < glev->count && not_match; l++)
+        not_match= !(*d_gtid == glev->list[l]);
+    }
+
+    if (not_match)
+    {
+      sprintf(errbuf, "binlog files may contain gtids from the domain ('%lu') "
+              "being deleted. Make sure to first purge those files",
+              *ptr_domain_id);
+      errmsg= errbuf;
+      goto end;
+    }
+    // compose a sequence of unique pointers to domain object
+    for (k= 0; k < domain_unique.elements; k++)
+    {
+      if ((rpl_binlog_state::element*) dynamic_array_ptr(&domain_unique, k)
+          == elem)
+        break; // domain_id's elem has been already in
+    }
+    if (k == domain_unique.elements) // proven not to have duplicates
+      insert_dynamic(&domain_unique, (uchar*) &elem);
+  }
+
+  // Domain removal from binlog state
+  for (k= 0; k < domain_unique.elements; k++)
+  {
+    rpl_binlog_state::element *elem= *(rpl_binlog_state::element**)
+      dynamic_array_ptr(&domain_unique, k);
+    my_hash_free(&elem->hash);
+    my_hash_delete(&hash, (uchar*) elem);
+  }
+
+  DBUG_ASSERT(strlen(errbuf) == 0);
+
+  if (domain_unique.elements == 0)
+    errmsg= "";
+
+end:
+  mysql_mutex_unlock(&LOCK_binlog_state);
+  delete_dynamic(&domain_unique);
+
+  DBUG_RETURN(errmsg);
+}
 
 slave_connection_state::slave_connection_state()
 {
diff --git a/sql/rpl_gtid.h b/sql/rpl_gtid.h
index c473ff40ee9..d30bfa64b87 100644
--- a/sql/rpl_gtid.h
+++ b/sql/rpl_gtid.h
@@ -34,6 +34,13 @@ struct rpl_gtid
   uint64 seq_no;
 };
 
+inline bool operator==(const rpl_gtid& lhs, const rpl_gtid& rhs)
+{
+  return
+    lhs.domain_id == rhs.domain_id &&
+    lhs.server_id == rhs.server_id &&
+    lhs.seq_no    == rhs.seq_no;
+};
 
 enum enum_gtid_skip_type {
   GTID_SKIP_NOT, GTID_SKIP_STANDALONE, GTID_SKIP_TRANSACTION
@@ -93,6 +100,7 @@ struct gtid_waiting {
 
 class Relay_log_info;
 struct rpl_group_info;
+class Gtid_list_log_event;
 
 /*
   Replication slave state.
@@ -315,6 +323,7 @@ struct rpl_binlog_state
   rpl_gtid *find_nolock(uint32 domain_id, uint32 server_id);
   rpl_gtid *find(uint32 domain_id, uint32 server_id);
   rpl_gtid *find_most_recent(uint32 domain_id);
+  const char* drop_domain(DYNAMIC_ARRAY *ids, Gtid_list_log_event *glev, char*);
 };
 
 
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index 774f582b4b9..9c1892e0c6c 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -141,10 +141,10 @@ max_display_length_for_field(enum_field_types sql_type, unsigned int metadata)
     */
 
   case MYSQL_TYPE_TINY_BLOB:
-    return my_set_bits(1 * 8);
+    return (uint32)my_set_bits(1 * 8);
 
   case MYSQL_TYPE_MEDIUM_BLOB:
-    return my_set_bits(3 * 8);
+    return (uint32)my_set_bits(3 * 8);
 
   case MYSQL_TYPE_BLOB:
   case MYSQL_TYPE_BLOB_COMPRESSED:
@@ -153,11 +153,11 @@ max_display_length_for_field(enum_field_types sql_type, unsigned int metadata)
       blobs are of type MYSQL_TYPE_BLOB. In that case, we have to look
       at the length instead to decide what the max display size is.
      */
-    return my_set_bits(metadata * 8);
+    return (uint32)my_set_bits(metadata * 8);
 
   case MYSQL_TYPE_LONG_BLOB:
   case MYSQL_TYPE_GEOMETRY:
-    return my_set_bits(4 * 8);
+    return (uint32)my_set_bits(4 * 8);
 
   default:
     return ~(uint32) 0;
diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt
index cf0a673cb20..e12f6cb258b 100644
--- a/sql/share/errmsg-utf8.txt
+++ b/sql/share/errmsg-utf8.txt
@@ -1801,8 +1801,8 @@ ER_WRONG_AUTO_KEY 42000 S1009
         spa "Puede ser solamente un campo automatico y este debe ser definido como una clave"
         swe "Det får finnas endast ett AUTO_INCREMENT-fält och detta måste vara en nyckel"
         ukr "Невірне визначення таблиці; Може бути лише один автоматичний стовбець, що повинен бути визначений як ключ"
-ER_UNUSED_9
-        eng "You should never see it"
+ER_BINLOG_CANT_DELETE_GTID_DOMAIN
+	eng "Could not delete gtid domain. Reason: %s."
 ER_NORMAL_SHUTDOWN  
         cze "%s (%s): normální ukončení\n"
         dan "%s (%s): Normal nedlukning\n"
@@ -7330,7 +7330,7 @@ ER_SUBQUERIES_NOT_SUPPORTED 42000
         eng "%s does not support subqueries or stored functions"
 ER_SET_STATEMENT_NOT_SUPPORTED 42000
         eng "The system variable %.200s cannot be set in SET STATEMENT." 
-ER_UNUSED_17
+ER_UNUSED_9
         eng "You should never see it"
 ER_USER_CREATE_EXISTS
         eng "Can't create user '%-.64s'@'%-.64s'; it already exists"
@@ -7747,6 +7747,9 @@ ER_SUM_FUNC_WITH_WINDOW_FUNC_AS_ARG
 ER_NET_OK_PACKET_TOO_LARGE
   eng "OK packet too large"
 
+ER_GEOJSON_EMPTY_COORDINATES
+        eng "Incorrect GeoJSON format - empty 'coordinates' array."
+
 ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
         eng "Illegal parameter data types %s and %s for operation '%s'"
 ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
@@ -7800,6 +7803,12 @@ ER_ARGUMENT_OUT_OF_RANGE
         eng "Argument to the %s function does not belong to the range [0,1]"
 ER_WRONG_TYPE_OF_ARGUMENT
         eng "%s function only accepts arguments that can be converted to numerical types"
+ER_NOT_AGGREGATE_FUNCTION
+        eng "Non-aggregate function contains aggregate specific instructions: (FETCH GROUP NEXT ROW)"
+ER_INVALID_AGGREGATE_FUNCTION
+        eng "Aggregate specific instruction(FETCH GROUP NEXT ROW) missing from the aggregate function"
+ER_INVALID_VALUE_TO_LIMIT
+        eng "Limit only accepts integer values"
 
 # MariaDB error numbers related to System Versioning
 
diff --git a/sql/slave.cc b/sql/slave.cc
index 94e35bec4f8..1ee745ced6a 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -72,6 +72,9 @@
 bool use_slave_mask = 0;
 MY_BITMAP slave_error_mask;
 char slave_skip_error_names[SHOW_VAR_FUNC_BUFF_SIZE];
+uint *slave_transaction_retry_errors;
+uint slave_transaction_retry_error_length= 0;
+char slave_transaction_retry_error_names[SHOW_VAR_FUNC_BUFF_SIZE];
 
 char* slave_load_tmpdir = 0;
 Master_info *active_mi= 0;
@@ -156,7 +159,8 @@ static bool wait_for_relay_log_space(Relay_log_info* rli);
 static bool io_slave_killed(Master_info* mi);
 static bool sql_slave_killed(rpl_group_info *rgi);
 static int init_slave_thread(THD*, Master_info *, SLAVE_THD_TYPE);
-static void print_slave_skip_errors(void);
+static void make_slave_skip_errors_printable(void);
+static void make_slave_transaction_retry_errors_printable(void);
 static int safe_connect(THD* thd, MYSQL* mysql, Master_info* mi);
 static int safe_reconnect(THD*, MYSQL*, Master_info*, bool);
 static int connect_to_master(THD*, MYSQL*, Master_info*, bool, bool);
@@ -635,7 +639,6 @@ start_slave_background_thread()
     sql_print_error("Failed to create thread while initialising slave");
     return 1;
   }
-
   mysql_mutex_lock(&LOCK_slave_background);
   while (!slave_background_thread_gtid_loaded)
     mysql_cond_wait(&COND_slave_background, &LOCK_slave_background);
@@ -707,15 +710,6 @@ int init_slave()
   }
 
   /*
-    If --slave-skip-errors=... was not used, the string value for the
-    system variable has not been set up yet. Do it now.
-  */
-  if (!use_slave_mask)
-  {
-    print_slave_skip_errors();
-  }
-
-  /*
     If master_host is not specified, try to read it from the master_info file.
     If master_host is specified, create the master_info file if it doesn't
     exists.
@@ -812,12 +806,12 @@ int init_recovery(Master_info* mi, const char** errmsg)
   DBUG_RETURN(0);
 }
 
- 
+
 /**
   Convert slave skip errors bitmap into a printable string.
 */
 
-static void print_slave_skip_errors(void)
+static void make_slave_skip_errors_printable(void)
 {
   /*
     To be safe, we want 10 characters of room in the buffer for a number
@@ -826,7 +820,7 @@ static void print_slave_skip_errors(void)
     plus a NUL terminator. That is a max 6 digit number.
   */
   const size_t MIN_ROOM= 10;
-  DBUG_ENTER("print_slave_skip_errors");
+  DBUG_ENTER("make_slave_skip_errors_printable");
   DBUG_ASSERT(sizeof(slave_skip_error_names) > MIN_ROOM);
   DBUG_ASSERT(MAX_SLAVE_ERROR <= 999999); // 6 digits
 
@@ -848,14 +842,14 @@ static void print_slave_skip_errors(void)
   else
   {
     char *buff= slave_skip_error_names;
-    char *bend= buff + sizeof(slave_skip_error_names);
+    char *bend= buff + sizeof(slave_skip_error_names) - MIN_ROOM;
     int  errnum;
 
     for (errnum= 0; errnum < MAX_SLAVE_ERROR; errnum++)
     {
       if (bitmap_is_set(&slave_error_mask, errnum))
       {
-        if (buff + MIN_ROOM >= bend)
+        if (buff >= bend)
           break; /* purecov: tested */
         buff= int10_to_str(errnum, buff, 10);
         *buff++= ',';
@@ -885,24 +879,24 @@ static void print_slave_skip_errors(void)
     Called from get_options() in mysqld.cc on start-up
 */
 
-void init_slave_skip_errors(const char* arg)
+bool init_slave_skip_errors(const char* arg)
 {
   const char *p;
   DBUG_ENTER("init_slave_skip_errors");
 
+  if (!arg || !*arg)                            // No errors defined
+    goto end;
+
   if (my_bitmap_init(&slave_error_mask,0,MAX_SLAVE_ERROR,0))
-  {
-    fprintf(stderr, "Badly out of memory, please check your system status\n");
-    exit(1);
-  }
-  use_slave_mask = 1;
+    DBUG_RETURN(1);
+
+  use_slave_mask= 1;
   for (;my_isspace(system_charset_info,*arg);++arg)
     /* empty */;
   if (!my_strnncoll(system_charset_info,(uchar*)arg,4,(const uchar*)"all",4))
   {
     bitmap_set_all(&slave_error_mask);
-    print_slave_skip_errors();
-    DBUG_VOID_RETURN;
+    goto end;
   }
   for (p= arg ; *p; )
   {
@@ -914,11 +908,109 @@ void init_slave_skip_errors(const char* arg)
     while (!my_isdigit(system_charset_info,*p) && *p)
       p++;
   }
-  /* Convert slave skip errors bitmap into a printable string. */
-  print_slave_skip_errors();
+
+end:
+  make_slave_skip_errors_printable();
+  DBUG_RETURN(0);
+}
+
+/**
+  Make printable version if slave_transaction_retry_errors
+  This is never empty as at least ER_LOCK_DEADLOCK and ER_LOCK_WAIT_TIMEOUT
+  will be there
+*/
+
+static void make_slave_transaction_retry_errors_printable(void)
+{
+  /*
+    To be safe, we want 10 characters of room in the buffer for a number
+    plus terminators. Also, we need some space for constant strings.
+    10 characters must be sufficient for a number plus {',' | '...'}
+    plus a NUL terminator. That is a max 6 digit number.
+  */
+  const size_t MIN_ROOM= 10;
+  char *buff= slave_transaction_retry_error_names;
+  char *bend= buff + sizeof(slave_transaction_retry_error_names) - MIN_ROOM;
+  uint  i;
+  DBUG_ENTER("make_slave_transaction_retry_errors_printable");
+  DBUG_ASSERT(sizeof(slave_transaction_retry_error_names) > MIN_ROOM);
+
+  /* Make @@slave_transaction_retry_errors show a human-readable value */
+  opt_slave_transaction_retry_errors= slave_transaction_retry_error_names;
+
+  for (i= 0; i < slave_transaction_retry_error_length && buff < bend; i++)
+  {
+    buff= int10_to_str(slave_transaction_retry_errors[i], buff, 10);
+    *buff++= ',';
+  }
+  if (buff != slave_transaction_retry_error_names)
+    buff--; // Remove last ','
+  if (i < slave_transaction_retry_error_length)
+  {
+    /* Couldn't show all errors */
+    buff= strmov(buff, "..."); /* purecov: tested */
+  }
+  *buff=0;
+  DBUG_PRINT("exit", ("error_names: '%s'",
+                      slave_transaction_retry_error_names));
   DBUG_VOID_RETURN;
 }
 
+
+bool init_slave_transaction_retry_errors(const char* arg)
+{
+  const char *p;
+  long err_code;
+  uint i;
+  DBUG_ENTER("init_slave_transaction_retry_errors");
+
+  /* Handle empty strings */
+  if (!arg)
+    arg= "";
+
+  slave_transaction_retry_error_length= 2;
+  for (;my_isspace(system_charset_info,*arg);++arg)
+    /* empty */;
+  for (p= arg; *p; )
+  {
+    if (!(p= str2int(p, 10, 0, LONG_MAX, &err_code)))
+      break;
+    slave_transaction_retry_error_length++;
+    while (!my_isdigit(system_charset_info,*p) && *p)
+      p++;
+  }
+
+  if (!(slave_transaction_retry_errors=
+        (uint *) my_once_alloc(sizeof(int) *
+                               slave_transaction_retry_error_length,
+                               MYF(MY_WME))))
+    DBUG_RETURN(1);
+
+  /*
+    Temporary error codes:
+    currently, InnoDB deadlock detected by InnoDB or lock
+    wait timeout (innodb_lock_wait_timeout exceeded
+  */
+  slave_transaction_retry_errors[0]= ER_LOCK_DEADLOCK;
+  slave_transaction_retry_errors[1]= ER_LOCK_WAIT_TIMEOUT;
+
+  /* Add user codes after this */
+  for (p= arg, i= 2; *p; )
+  {
+    if (!(p= str2int(p, 10, 0, LONG_MAX, &err_code)))
+      break;
+    if (err_code > 0 && err_code < ER_ERROR_LAST)
+      slave_transaction_retry_errors[i++]= (uint) err_code;
+    while (!my_isdigit(system_charset_info,*p) && *p)
+      p++;
+  }
+  slave_transaction_retry_error_length= i;
+
+  make_slave_transaction_retry_errors_printable();
+  DBUG_RETURN(0);
+}
+
+
 int terminate_slave_threads(Master_info* mi,int thread_mask,bool skip_lock)
 {
   DBUG_ENTER("terminate_slave_threads");
@@ -987,7 +1079,7 @@ int terminate_slave_threads(Master_info* mi,int thread_mask,bool skip_lock)
 
     mysql_mutex_unlock(log_lock);
   }
-  DBUG_RETURN(retval); 
+  DBUG_RETURN(retval);
 }
 
 
@@ -3598,14 +3690,20 @@ static ulong read_event(MYSQL* mysql, Master_info *mi, bool* suppress_warnings,
   DBUG_RETURN(len - 1);
 }
 
-/*
+
+/**
   Check if the current error is of temporary nature of not.
   Some errors are temporary in nature, such as
   ER_LOCK_DEADLOCK and ER_LOCK_WAIT_TIMEOUT.
+
+  @retval 0 if fatal error
+  @retval 1 temporary error, do retry
 */
+
 int
 has_temporary_error(THD *thd)
 {
+  uint current_errno;
   DBUG_ENTER("has_temporary_error");
 
   DBUG_EXECUTE_IF("all_errors_are_temporary_errors",
@@ -3623,14 +3721,12 @@ has_temporary_error(THD *thd)
   if (!thd->is_error())
     DBUG_RETURN(0);
 
-  /*
-    Temporary error codes:
-    currently, InnoDB deadlock detected by InnoDB or lock
-    wait timeout (innodb_lock_wait_timeout exceeded
-  */
-  if (thd->get_stmt_da()->sql_errno() == ER_LOCK_DEADLOCK ||
-      thd->get_stmt_da()->sql_errno() == ER_LOCK_WAIT_TIMEOUT)
-    DBUG_RETURN(1);
+  current_errno= thd->get_stmt_da()->sql_errno();
+  for (uint i= 0; i < slave_transaction_retry_error_length; i++)
+  {
+    if (current_errno == slave_transaction_retry_errors[i])
+      DBUG_RETURN(1);
+  }
 
   DBUG_RETURN(0);
 }
@@ -4281,8 +4377,9 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli,
             exec_res= 0;
             serial_rgi->cleanup_context(thd, 1);
             /* chance for concurrent connection to get more locks */
-            slave_sleep(thd, MY_MIN(serial_rgi->trans_retries,
+            slave_sleep(thd, MY_MAX(MY_MIN(serial_rgi->trans_retries,
                                     MAX_SLAVE_RETRY_PAUSE),
+                                    slave_trans_retry_interval),
                        sql_slave_killed, serial_rgi);
             serial_rgi->trans_retries++;
             mysql_mutex_lock(&rli->data_lock); // because of SHOW STATUS
@@ -4367,7 +4464,7 @@ static bool check_io_slave_killed(Master_info *mi, const char *info)
   @param[in]     mysql               MySQL connection.
   @param[in]     mi                  Master connection information.
   @param[in,out] retry_count         Number of attempts to reconnect.
-  @param[in]     suppress_warnings   TRUE when a normal net read timeout 
+  @param[in]     suppress_warnings   TRUE when a normal net read timeout
                                      has caused to reconnecting.
   @param[in]     messages            Messages to print/log, see 
                                      reconnect_messages[] array.
@@ -4870,9 +4967,7 @@ err_during_init:
   // TODO: make rpl_status part of Master_info
   change_rpl_status(RPL_ACTIVE_SLAVE,RPL_IDLE_SLAVE);
 
-  mysql_mutex_lock(&LOCK_thread_count);
-  thd->unlink();
-  mysql_mutex_unlock(&LOCK_thread_count);
+  thd->assert_not_linked();
   delete thd;
   thread_safe_decrement32(&service_thread_count);
   signal_thd_deleted();
@@ -5551,11 +5646,7 @@ err_during_init:
 
   rpl_parallel_resize_pool_if_no_slaves();
 
-  /* TODO: Check if this lock is needed */
-  mysql_mutex_lock(&LOCK_thread_count);
   delete serial_rgi;
-  mysql_mutex_unlock(&LOCK_thread_count);
-
   delete thd;
   thread_safe_decrement32(&service_thread_count);
   signal_thd_deleted();
diff --git a/sql/slave.h b/sql/slave.h
index c856a6989ed..74bb4356dfb 100644
--- a/sql/slave.h
+++ b/sql/slave.h
@@ -132,6 +132,9 @@ extern ulong master_retry_count;
 extern MY_BITMAP slave_error_mask;
 extern char slave_skip_error_names[];
 extern bool use_slave_mask;
+extern char slave_transaction_retry_error_names[];
+extern uint *slave_transaction_retry_errors;
+extern uint slave_transaction_retry_error_length;
 extern char *slave_load_tmpdir;
 extern char *master_info_file;
 extern MYSQL_PLUGIN_IMPORT char *relay_log_info_file;
@@ -139,6 +142,7 @@ extern char *opt_relay_logname, *opt_relaylog_index_name;
 extern my_bool opt_skip_slave_start, opt_reckless_slave;
 extern my_bool opt_log_slave_updates;
 extern char *opt_slave_skip_errors;
+extern char *opt_slave_transaction_retry_errors;
 extern my_bool opt_replicate_annotate_row_events;
 extern ulonglong relay_log_space_limit;
 extern ulonglong opt_read_binlog_speed_limit;
@@ -184,7 +188,8 @@ extern const char *relay_log_basename;
 
 int init_slave();
 int init_recovery(Master_info* mi, const char** errmsg);
-void init_slave_skip_errors(const char* arg);
+bool init_slave_skip_errors(const char* arg);
+bool init_slave_transaction_retry_errors(const char* arg);
 int register_slave_on_master(MYSQL* mysql);
 int terminate_slave_threads(Master_info* mi, int thread_mask,
 			     bool skip_lock = 0);
diff --git a/sql/sp.cc b/sql/sp.cc
index e02283d1f17..58dd8cfee3d 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -201,6 +201,11 @@ TABLE_FIELD_TYPE proc_table_fields[MYSQL_PROC_FIELD_COUNT] =
     { C_STRING_WITH_LEN("body_utf8") },
     { C_STRING_WITH_LEN("longblob") },
     { NULL, 0 }
+  },
+  {
+    { C_STRING_WITH_LEN("aggregate") },
+    { C_STRING_WITH_LEN("enum('NONE','GROUP')") },
+    { NULL, 0 }
   }
 };
 
@@ -583,6 +588,22 @@ bool st_sp_chistics::read_from_mysql_proc_row(THD *thd, TABLE *table)
     return true;
   suid= str.str[0] == 'I' ? SP_IS_NOT_SUID : SP_IS_SUID;
 
+  if (table->field[MYSQL_PROC_FIELD_AGGREGATE]->val_str_nopad(thd->mem_root,
+                                                              &str))
+    return true;
+
+  switch (str.str[0]) {
+  case 'N':
+    agg_type= NOT_AGGREGATE;
+    break;
+  case 'G':
+    agg_type= GROUP_AGGREGATE;
+    break;
+  default:
+    agg_type= DEFAULT_AGGREGATE;
+  }
+
+
   if (table->field[MYSQL_PROC_FIELD_COMMENT]->val_str_nopad(thd->mem_root,
                                                             &comment))
     return true;
@@ -1183,6 +1204,13 @@ Sp_handler::sp_create_routine(THD *thd, const sp_head *sp) const
       table->field[MYSQL_PROC_FIELD_NAME]->
         store(sp->m_name, system_charset_info);
 
+    if (sp->agg_type() != DEFAULT_AGGREGATE)
+    {
+      store_failed= store_failed ||
+        table->field[MYSQL_PROC_FIELD_AGGREGATE]->
+          store((longlong)sp->agg_type(),TRUE);
+    }
+
     store_failed= store_failed ||
       table->field[MYSQL_PROC_MYSQL_TYPE]->
         store((longlong) type(), true);
@@ -1494,6 +1522,9 @@ Sp_handler::sp_update_routine(THD *thd, const Database_qualified_name *name,
     if (chistics->comment.str)
       table->field[MYSQL_PROC_FIELD_COMMENT]->store(chistics->comment,
 						    system_charset_info);
+    if (chistics->agg_type != DEFAULT_AGGREGATE)
+      table->field[MYSQL_PROC_FIELD_AGGREGATE]->
+         store((longlong)chistics->agg_type, TRUE);
     if ((ret= table->file->ha_update_row(table->record[1],table->record[0])) &&
         ret != HA_ERR_RECORD_IS_THE_SAME)
       ret= SP_WRITE_ROW_FAILED;
@@ -2238,11 +2269,12 @@ Sp_handler::show_create_sp(THD *thd, String *buf,
                            sql_mode_t sql_mode) const
 {
   sql_mode_t old_sql_mode= thd->variables.sql_mode;
+  size_t agglen= (chistics.agg_type == GROUP_AGGREGATE)? 10 : 0;
   /* Make some room to begin with */
   if (buf->alloc(100 + db.length + 1 + name.length +
                  params.length + returns.length +
-		 chistics.comment.length + 10 /* length of " DEFINER= "*/ +
-                 USER_HOST_BUFF_SIZE))
+                 chistics.comment.length + 10 /* length of " DEFINER= "*/ +
+                 agglen + USER_HOST_BUFF_SIZE))
     return true;
 
   thd->variables.sql_mode= sql_mode;
@@ -2250,6 +2282,8 @@ Sp_handler::show_create_sp(THD *thd, String *buf,
   if (ddl_options.or_replace())
     buf->append(STRING_WITH_LEN("OR REPLACE "));
   append_definer(thd, buf, &definer.user, &definer.host);
+  if (chistics.agg_type == GROUP_AGGREGATE)
+    buf->append(STRING_WITH_LEN("AGGREGATE "));
   buf->append(type_lex_cstring());
   buf->append(STRING_WITH_LEN(" "));
   if (ddl_options.if_not_exists())
diff --git a/sql/sp.h b/sql/sp.h
index ab307a3064e..42b7fcb2c5c 100644
--- a/sql/sp.h
+++ b/sql/sp.h
@@ -370,6 +370,7 @@ enum
   MYSQL_PROC_FIELD_COLLATION_CONNECTION,
   MYSQL_PROC_FIELD_DB_COLLATION,
   MYSQL_PROC_FIELD_BODY_UTF8,
+  MYSQL_PROC_FIELD_AGGREGATE,
   MYSQL_PROC_FIELD_COUNT
 };
 
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index bd02762f5ab..28e4442dd0c 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -999,6 +999,12 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
   bool err_status= FALSE;
   uint ip= 0;
   sql_mode_t save_sql_mode;
+
+  // TODO(cvicentiu) See if you can drop this bit. This is used to resume
+  // execution from where we left off.
+  if (m_chistics.agg_type == GROUP_AGGREGATE)
+    ip= thd->spcont->instr_ptr;
+
   bool save_abort_on_warning;
   Query_arena *old_arena;
   /* per-instruction arena */
@@ -1022,6 +1028,19 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
   if (check_stack_overrun(thd, 7 * STACK_MIN_SIZE, (uchar*)&old_packet))
     DBUG_RETURN(TRUE);
 
+  /*
+     Normally the counter is not reset between parsing and first execution,
+     but it is possible in case of error to have parsing on one CALL and
+     first execution (where VIEW will be parsed and added). So we store the
+     counter after parsing and restore it before execution just to avoid
+     repeating SELECT numbers.
+
+     Other problem is that it can be more SELECTs parsed in case of fixing
+     error causes previous interruption of the SP. So it is save not just
+     assign old value but add it.
+   */
+  thd->select_number+= m_select_number;
+
   /* init per-instruction memroot */
   init_sql_alloc(&execute_mem_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(0));
 
@@ -1163,6 +1182,7 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
 #if defined(ENABLED_PROFILING)
       thd->profiling.discard_current_query();
 #endif
+      thd->spcont->quit_func= TRUE;
       break;
     }
 
@@ -1232,7 +1252,8 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
     /* Reset sp_rcontext::end_partial_result_set flag. */
     ctx->end_partial_result_set= FALSE;
 
-  } while (!err_status && !thd->killed && !thd->is_fatal_error);
+  } while (!err_status && !thd->killed && !thd->is_fatal_error &&
+           !thd->spcont->pause_state);
 
 #if defined(ENABLED_PROFILING)
   thd->profiling.finish_current_query();
@@ -1248,9 +1269,14 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
 
   thd->restore_active_arena(&execute_arena, &backup_arena);
 
-  thd->spcont->pop_all_cursors(); // To avoid memory leaks after an error
+  /* Only pop cursors when we're done with group aggregate running. */
+  if (m_chistics.agg_type != GROUP_AGGREGATE ||
+      (m_chistics.agg_type == GROUP_AGGREGATE && thd->spcont->quit_func))
+    thd->spcont->pop_all_cursors(); // To avoid memory leaks after an error
 
   /* Restore all saved */
+  if (m_chistics.agg_type == GROUP_AGGREGATE)
+    thd->spcont->instr_ptr= ip;
   thd->server_status= (thd->server_status & ~status_backup_mask) | old_server_status;
   old_packet.swap(thd->packet);
   DBUG_ASSERT(thd->change_list.is_empty());
@@ -1361,6 +1387,16 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
                m_recursion_level + 1));
   m_first_instance->m_first_free_instance= this;
 
+  /*
+     This execution of the SP was aborted with an error (e.g. "Table not
+     found").  However it might still have consumed some numbers from the
+     thd->select_number counter.  The next sp->exec() call must not use the
+     consumed numbers, so we remember the first free number (We know that
+     nobody will use it as this execution has stopped with an error).
+   */
+  if (err_status)
+    set_select_number(thd->select_number);
+
   DBUG_RETURN(err_status);
 }
 
@@ -1652,18 +1688,16 @@ err_with_cleanup:
 
 bool
 sp_head::execute_function(THD *thd, Item **argp, uint argcount,
-                          Field *return_value_fld)
+                          Field *return_value_fld, sp_rcontext **func_ctx,
+                          Query_arena *call_arena)
 {
   ulonglong UNINIT_VAR(binlog_save_options);
   bool need_binlog_call= FALSE;
   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::STMT_INITIALIZED_FOR_SP);
   Query_arena backup_arena;
   DBUG_ENTER("sp_head::execute_function");
   DBUG_PRINT("info", ("function %s", m_name.str));
@@ -1696,23 +1730,25 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     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, MYF(0));
-  thd->set_n_backup_active_arena(&call_arena, &backup_arena);
-
-  if (!(nctx= rcontext_create(thd, return_value_fld, argp, argcount)))
+  if (!(*func_ctx))
   {
-    thd->restore_active_arena(&call_arena, &backup_arena);
-    err_status= TRUE;
-    goto err_with_cleanup;
-  }
+    thd->set_n_backup_active_arena(call_arena, &backup_arena);
 
-  /*
-    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);
+    if (!(*func_ctx= rcontext_create(thd, return_value_fld, argp, argcount)))
+    {
+      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);
+  }
 
   /* Pass arguments. */
   for (arg_no= 0; arg_no < argcount; arg_no++)
@@ -1720,7 +1756,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     /* Arguments must be fixed in Item_func_sp::fix_fields */
     DBUG_ASSERT(argp[arg_no]->fixed);
 
-    if ((err_status= nctx->set_variable(thd, arg_no, &(argp[arg_no]))))
+    if ((err_status= (*func_ctx)->set_variable(thd, arg_no, &(argp[arg_no]))))
       goto err_with_cleanup;
   }
 
@@ -1752,7 +1788,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
       if (arg_no)
         binlog_buf.append(',');
 
-      Item *item= nctx->get_item(arg_no);
+      Item *item= (*func_ctx)->get_item(arg_no);
       str_value= item->type_handler()->print_item_value(thd, item,
                                                         &str_value_holder);
       if (str_value)
@@ -1762,7 +1798,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     }
     binlog_buf.append(')');
   }
-  thd->spcont= nctx;
+  thd->spcont= *func_ctx;
 
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
   Security_context *save_security_ctx;
@@ -1803,11 +1839,11 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
           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);
+  thd->set_n_backup_active_arena(call_arena, &backup_arena);
 
   err_status= execute(thd, TRUE);
 
-  thd->restore_active_arena(&call_arena, &backup_arena);
+  thd->restore_active_arena(call_arena, &backup_arena);
 
   if (need_binlog_call)
   {
@@ -1833,11 +1869,11 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
     }
   }
 
-  if (!err_status)
+  if (!err_status && thd->spcont->quit_func)
   {
     /* We need result only in function but not in trigger */
 
-    if (!nctx->is_return_value_set())
+    if (!(*func_ctx)->is_return_value_set())
     {
       my_error(ER_SP_NORETURNEND, MYF(0), m_name.str);
       err_status= TRUE;
@@ -1849,9 +1885,6 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
 #endif
 
 err_with_cleanup:
-  delete nctx;
-  call_arena.free_items();
-  free_root(&call_mem_root, MYF(0));
   thd->spcont= octx;
 
   /*
@@ -2065,26 +2098,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
 
   if (!err_status)
   {
-    /*
-      Normally the counter is not reset between parsing and first execution,
-      but it is possible in case of error to have parsing on one CALL and
-      first execution (where VIEW will be parsed and added). So we store the
-      counter after parsing and restore it before execution just to avoid
-      repeating SELECT numbers.
-    */
-    thd->select_number= m_select_number;
-
     err_status= execute(thd, TRUE);
-    DBUG_PRINT("info", ("execute returned %d", (int) err_status));
-    /*
-      This execution of the SP was aborted with an error (e.g. "Table not
-      found").  However it might still have consumed some numbers from the
-      thd->select_number counter.  The next sp->exec() call must not use the
-      consumed numbers, so we remember the first free number (We know that
-      nobody will use it as this execution has stopped with an error).
-    */
-    if (err_status)
-      set_select_number(thd->select_number);
   }
 
   if (save_log_general)
@@ -2481,7 +2495,6 @@ sp_head::set_chistics(const st_sp_chistics &chistics)
                                          m_chistics.comment.length);
 }
 
-
 void
 sp_head::set_info(longlong created, longlong modified,
                   const st_sp_chistics &chistics, sql_mode_t sql_mode)
@@ -4178,7 +4191,7 @@ sp_instr_cfetch::execute(THD *thd, uint *nextp)
   Query_arena backup_arena;
   DBUG_ENTER("sp_instr_cfetch::execute");
 
-  res= c ? c->fetch(thd, &m_varlist) : -1;
+  res= c ? c->fetch(thd, &m_varlist, m_error_on_no_data) : -1;
 
   *nextp= m_ip+1;
   DBUG_RETURN(res);
@@ -4217,6 +4230,35 @@ sp_instr_cfetch::print(String *str)
   }
 }
 
+int
+sp_instr_agg_cfetch::execute(THD *thd, uint *nextp)
+{
+  DBUG_ENTER("sp_instr_cfetch::execute");
+  int res= 0;
+  if (!thd->spcont->instr_ptr)
+  {
+    *nextp= m_ip+1;
+    thd->spcont->instr_ptr= m_ip + 1;
+  }
+  else if (!thd->spcont->pause_state)
+    thd->spcont->pause_state= TRUE;
+  else
+  {
+    thd->spcont->pause_state= FALSE;
+    if (thd->server_status == SERVER_STATUS_LAST_ROW_SENT)
+    {
+      my_message(ER_SP_FETCH_NO_DATA,
+                 ER_THD(thd, ER_SP_FETCH_NO_DATA), MYF(0));
+      res= -1;
+      thd->spcont->quit_func= TRUE;
+    }
+    else
+      *nextp= m_ip + 1;
+  }
+  DBUG_RETURN(res);
+}
+
+
 
 /*
   sp_instr_cursor_copy_struct class functions
@@ -4778,7 +4820,7 @@ bool sp_head::add_for_loop_open_cursor(THD *thd, sp_pcontext *spcont,
 
   sp_instr_cfetch *instr_cfetch=
     new (thd->mem_root) sp_instr_cfetch(instructions(),
-                                        spcont, coffset);
+                                        spcont, coffset, false);
   if (instr_cfetch == NULL || add_instr(instr_cfetch))
     return true;
   instr_cfetch->add_to_varlist(index);
diff --git a/sql/sp_head.h b/sql/sp_head.h
index 815a68c922f..04b67941226 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -164,7 +164,10 @@ public:
     /*
       Marks routines that have column type references: DECLARE a t1.a%TYPE;
     */
-    HAS_COLUMN_TYPE_REFS= 8192
+    HAS_COLUMN_TYPE_REFS= 8192,
+    /* Set if has FETCH GROUP NEXT ROW instr. Used to ensure that only
+       functions with AGGREGATE keyword use the instr. */
+    HAS_AGGREGATE_INSTR= 16384
   };
 
   const Sp_handler *m_handler;
@@ -197,6 +200,7 @@ public:
   enum_sp_suid_behaviour suid() const { return m_chistics.suid; }
   bool detistic() const { return m_chistics.detistic; }
   enum_sp_data_access daccess() const { return m_chistics.daccess; }
+  enum_sp_aggregate_type agg_type() const { return m_chistics.agg_type; }
   /**
     Is this routine being executed?
   */
@@ -343,7 +347,8 @@ public:
                   GRANT_INFO *grant_info);
 
   bool
-  execute_function(THD *thd, Item **args, uint argcount, Field *return_fld);
+  execute_function(THD *thd, Item **args, uint argcount, Field *return_fld,
+                   sp_rcontext **nctx, Query_arena *call_arena);
 
   bool
   execute_procedure(THD *thd, List<Item> *args);
@@ -719,6 +724,10 @@ public:
                                           const LEX_CSTRING &table);
 
   void set_chistics(const st_sp_chistics &chistics);
+  inline void set_chistics_agg_type(enum enum_sp_aggregate_type type)
+  {
+    m_chistics.agg_type= type;
+  }
   void set_info(longlong created, longlong modified,
 		const st_sp_chistics &chistics, sql_mode_t sql_mode);
 
@@ -1795,8 +1804,8 @@ class sp_instr_cfetch : public sp_instr
 
 public:
 
-  sp_instr_cfetch(uint ip, sp_pcontext *ctx, uint c)
-    : sp_instr(ip, ctx), m_cursor(c)
+  sp_instr_cfetch(uint ip, sp_pcontext *ctx, uint c, bool error_on_no_data)
+    : sp_instr(ip, ctx), m_cursor(c), m_error_on_no_data(error_on_no_data)
   {
     m_varlist.empty();
   }
@@ -1817,9 +1826,36 @@ private:
 
   uint m_cursor;
   List<sp_variable> m_varlist;
+  bool m_error_on_no_data;
 
 }; // class sp_instr_cfetch : public sp_instr
 
+/*
+This class is created for the special fetch instruction
+FETCH GROUP NEXT ROW, used in the user-defined aggregate
+functions
+*/
+
+class sp_instr_agg_cfetch : public sp_instr
+{
+  sp_instr_agg_cfetch(const sp_instr_cfetch &); /**< Prevent use of these */
+  void operator=(sp_instr_cfetch &);
+
+public:
+
+  sp_instr_agg_cfetch(uint ip, sp_pcontext *ctx)
+    : sp_instr(ip, ctx){}
+
+  virtual ~sp_instr_agg_cfetch()
+  {}
+
+  virtual int execute(THD *thd, uint *nextp);
+
+  virtual void print(String *str){};
+}; // class sp_instr_agg_cfetch : public sp_instr
+
+
+
 
 class sp_instr_error : public sp_instr
 {
diff --git a/sql/sp_rcontext.cc b/sql/sp_rcontext.cc
index 6716aa54170..740941937e8 100644
--- a/sql/sp_rcontext.cc
+++ b/sql/sp_rcontext.cc
@@ -40,6 +40,7 @@ sp_rcontext::sp_rcontext(const sp_head *owner,
                          Field *return_value_fld,
                          bool in_sub_stmt)
   :end_partial_result_set(false),
+   pause_state(false), quit_func(false), instr_ptr(0),
    m_sp(owner),
    m_root_parsing_ctx(root_parsing_ctx),
    m_var_table(NULL),
@@ -800,7 +801,13 @@ int sp_cursor::open_view_structure_only(THD *thd)
   if (!(thd->lex->limit_rows_examined= new (thd->mem_root) Item_uint(thd, 0)))
     return -1;
   thd->no_errors= true; // Suppress ER_QUERY_EXCEEDED_ROWS_EXAMINED_LIMIT
+  DBUG_ASSERT(!thd->killed);
   res= open(thd);
+  /*
+    The query possibly exited on LIMIT ROWS EXAMINED and set thd->killed.
+    Reset it now.
+  */
+  thd->reset_killed();
   thd->no_errors= thd_no_errors_save;
   thd->lex->limit_rows_examined= limit_rows_examined;
   return res;
@@ -829,7 +836,7 @@ void sp_cursor::destroy()
 }
 
 
-int sp_cursor::fetch(THD *thd, List<sp_variable> *vars)
+int sp_cursor::fetch(THD *thd, List<sp_variable> *vars, bool error_on_no_data)
 {
   if (! server_side_cursor)
   {
@@ -866,7 +873,7 @@ int sp_cursor::fetch(THD *thd, List<sp_variable> *vars)
   if (! server_side_cursor->is_open())
   {
     m_found= false;
-    if (thd->variables.sql_mode & MODE_ORACLE)
+    if (!error_on_no_data)
       return 0;
     my_message(ER_SP_FETCH_NO_DATA, ER_THD(thd, ER_SP_FETCH_NO_DATA), MYF(0));
     return -1;
diff --git a/sql/sp_rcontext.h b/sql/sp_rcontext.h
index 658972ece40..0999271ebde 100644
--- a/sql/sp_rcontext.h
+++ b/sql/sp_rcontext.h
@@ -178,6 +178,9 @@ public:
   /// (if one is found). Otherwise the client will hang due to a violation
   /// of the client/server protocol.
   bool end_partial_result_set;
+  bool pause_state;
+  bool quit_func;
+  uint instr_ptr;
 
   /// The stored program for which this runtime context is created. Used for
   /// checking if correct runtime context is used for variable handling.
@@ -455,7 +458,7 @@ public:
   ulonglong fetch_count() const
   { return m_fetch_count; }
 
-  int fetch(THD *, List<sp_variable> *vars);
+  int fetch(THD *, List<sp_variable> *vars, bool error_on_no_data);
 
   bool export_structure(THD *thd, Row_definition_list *list);
 
diff --git a/sql/spatial.cc b/sql/spatial.cc
index 19035a4e882..2a07ef2ecbe 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -1041,7 +1041,7 @@ bool Gis_line_string::init_from_json(json_engine_t *je, bool er_on_3D,
   }
   if (n_points < 1)
   {
-    je->s.error= GEOJ_TOO_FEW_POINTS;
+    je->s.error= Geometry::GEOJ_TOO_FEW_POINTS;
     return TRUE;
   }
   wkb->write_at_position(np_pos, n_points);
@@ -1440,6 +1440,15 @@ bool Gis_polygon::init_from_json(json_engine_t *je, bool er_on_3D, String *wkb)
     }
     n_linear_rings++;
   }
+
+  if (je->s.error)
+    return TRUE;
+
+  if (n_linear_rings == 0)
+  {
+    je->s.error= Geometry::GEOJ_EMPTY_COORDINATES;
+    return TRUE;
+  }
   wkb->write_at_position(lr_pos, n_linear_rings);
   return FALSE;
 }
@@ -1945,6 +1954,14 @@ bool Gis_multi_point::init_from_json(json_engine_t *je, bool er_on_3D,
     n_points++;
   }
 
+  if (je->s.error)
+    return TRUE;
+  if (n_points == 0)
+  {
+    je->s.error= Geometry::GEOJ_EMPTY_COORDINATES;
+    return TRUE;
+  }
+
   wkb->write_at_position(np_pos, n_points);
   return FALSE;
 }
@@ -2214,6 +2231,15 @@ bool Gis_multi_line_string::init_from_json(json_engine_t *je, bool er_on_3D,
 
     n_line_strings++;
   }
+  if (je->s.error)
+    return TRUE;
+
+  if (n_line_strings == 0)
+  {
+    je->s.error= Geometry::GEOJ_EMPTY_COORDINATES;
+    return TRUE;
+  }
+
   wkb->write_at_position(ls_pos, n_line_strings);
   return FALSE;
 }
@@ -2603,6 +2629,13 @@ bool Gis_multi_polygon::init_from_json(json_engine_t *je, bool er_on_3D,
 
     n_polygons++;
   }
+  if (je->s.error)
+    return TRUE;
+  if (n_polygons == 0)
+  {
+    je->s.error= Geometry::GEOJ_EMPTY_COORDINATES;
+    return TRUE;
+  }
   wkb->write_at_position(np_pos, n_polygons);
   return FALSE;
 }
diff --git a/sql/spatial.h b/sql/spatial.h
index 78e850dc2d7..901544b6916 100644
--- a/sql/spatial.h
+++ b/sql/spatial.h
@@ -256,6 +256,7 @@ public:
     GEOJ_TOO_FEW_POINTS= 2,
     GEOJ_POLYGON_NOT_CLOSED= 3,
     GEOJ_DIMENSION_NOT_SUPPORTED= 4,
+    GEOJ_EMPTY_COORDINATES= 5,
   };
 
 
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 78fd44c86a4..307a6badd70 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -7375,9 +7375,8 @@ static bool grant_load(THD *thd,
             continue;
           }
         }
-        uint type= procs_priv.routine_type()->val_int();
-        const Sp_handler *sph= Sp_handler::handler((stored_procedure_type)
-                                                   type);
+        stored_procedure_type type= (stored_procedure_type)procs_priv.routine_type()->val_int();
+        const Sp_handler *sph= Sp_handler::handler(type);
         if (!sph || !(hash= sph->get_priv_hash()))
         {
           sql_print_warning("'procs_priv' entry '%s' "
@@ -7605,6 +7604,11 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
                          INSERT_ACL : SELECT_ACL);
     }
 
+    if (tl->with ||
+        (tl->select_lex &&
+         (tl->with= tl->select_lex->find_table_def_in_with_clauses(tl))))
+      continue;
+
     const ACL_internal_table_access *access=
       get_cached_table_access(&t_ref->grant.m_internal,
                               t_ref->get_db_name(),
diff --git a/sql/sql_alter.h b/sql/sql_alter.h
index 5c651b0c91b..75435c7f275 100644
--- a/sql/sql_alter.h
+++ b/sql/sql_alter.h
@@ -408,13 +408,15 @@ public:
 /**
   Sql_cmd_alter_sequence represents the ALTER SEQUENCE statement.
 */
-class Sql_cmd_alter_sequence : public Sql_cmd
+class Sql_cmd_alter_sequence : public Sql_cmd,
+                               public DDL_options
 {
 public:
   /**
     Constructor, used to represent a ALTER TABLE statement.
   */
-  Sql_cmd_alter_sequence()
+  Sql_cmd_alter_sequence(const DDL_options &options)
+   :DDL_options(options)
   {}
 
   ~Sql_cmd_alter_sequence()
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 2a3a2903b35..4f4ea2a864c 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -878,6 +878,12 @@ void close_thread_table(THD *thd, TABLE **table_ptr)
     table->file->update_global_index_stats();
   }
 
+  /*
+    This look is needed to allow THD::notify_shared_lock() to
+    traverse the thd->open_tables list without having to worry that
+    some of the tables are removed from under it
+  */
+
   mysql_mutex_lock(&thd->LOCK_thd_data);
   *table_ptr=table->next;
   mysql_mutex_unlock(&thd->LOCK_thd_data);
@@ -1096,14 +1102,32 @@ unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
 
   table= table->find_table_for_update();
 
-  if (table->table && table->table->file->ht->db_type == DB_TYPE_MRG_MYISAM)
+  if (table->table &&
+      table->table->file->ha_table_flags() & HA_CAN_MULTISTEP_MERGE)
   {
     TABLE_LIST *child;
     dup= NULL;
     /* Check duplicates of all merge children. */
-    for (child= table->next_global; child && child->parent_l == table;
+    for (child= table->next_global; child;
          child= child->next_global)
     {
+      if (child->table &&
+          child->table->file->ha_table_flags() & HA_CAN_MULTISTEP_MERGE)
+        continue;
+
+      /*
+        Ensure that the child has one parent that is the table that is
+        updated.
+      */
+      TABLE_LIST *tmp_parent= child;
+      while ((tmp_parent= tmp_parent->parent_l))
+      {
+        if (tmp_parent == table)
+          break;
+      }
+      if (!tmp_parent)
+        break;
+
       if ((dup= find_dup_table(thd, child, child->next_global, check_alias)))
         break;
     }
@@ -1112,6 +1136,8 @@ unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
     dup= find_dup_table(thd, table, table_list, check_alias);
   return dup;
 }
+
+
 /*
   Issue correct error message in case we found 2 duplicate tables which
   prevent some update operation
@@ -4089,7 +4115,7 @@ restart:
       continue;
 
     /* Schema tables may not have a TABLE object here. */
-    if (tbl->file->ht->db_type == DB_TYPE_MRG_MYISAM)
+    if (tbl->file->ha_table_flags() & HA_CAN_MULTISTEP_MERGE)
     {
       /* MERGE tables need to access parent and child TABLE_LISTs. */
       DBUG_ASSERT(tbl->pos_in_table_list == tables);
@@ -4636,7 +4662,7 @@ TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
     */
     DBUG_ASSERT(table_list->table);
     table= table_list->table;
-    if (table->file->ht->db_type == DB_TYPE_MRG_MYISAM)
+    if (table->file->ha_table_flags() & HA_CAN_MULTISTEP_MERGE)
     {
       /* A MERGE table must not come here. */
       /* purecov: begin tested */
@@ -8449,84 +8475,6 @@ my_bool mysql_rm_tmp_tables(void)
 	unireg support functions
 *****************************************************************************/
 
-/**
-   A callback to the server internals that is used to address
-   special cases of the locking protocol.
-   Invoked when acquiring an exclusive lock, for each thread that
-   has a conflicting shared metadata lock.
-
-   This function:
-     - aborts waiting of the thread on a data lock, to make it notice
-       the pending exclusive lock and back off.
-     - if the thread is an INSERT DELAYED thread, sends it a KILL
-       signal to terminate it.
-
-   @note This function does not wait for the thread to give away its
-         locks. Waiting is done outside for all threads at once.
-
-   @param thd    Current thread context
-   @param in_use The thread to wake up
-   @param needs_thr_lock_abort Indicates that to wake up thread
-                               this call needs to abort its waiting
-                               on table-level lock.
-
-   @retval  TRUE  if the thread was woken up
-   @retval  FALSE otherwise.
-
-   @note It is one of two places where border between MDL and the
-         rest of the server is broken.
-*/
-
-bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use,
-                                            bool needs_thr_lock_abort)
-{
-  bool signalled= FALSE;
-  if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
-      !in_use->killed)
-  {
-    in_use->set_killed(KILL_SYSTEM_THREAD);
-    mysql_mutex_lock(&in_use->mysys_var->mutex);
-    if (in_use->mysys_var->current_cond)
-    {
-      mysql_mutex_lock(in_use->mysys_var->current_mutex);
-      mysql_cond_broadcast(in_use->mysys_var->current_cond);
-      mysql_mutex_unlock(in_use->mysys_var->current_mutex);
-    }
-    mysql_mutex_unlock(&in_use->mysys_var->mutex);
-    signalled= TRUE;
-  }
-
-  if (needs_thr_lock_abort)
-  {
-    mysql_mutex_lock(&in_use->LOCK_thd_data);
-    for (TABLE *thd_table= in_use->open_tables;
-         thd_table ;
-         thd_table= thd_table->next)
-    {
-      /*
-        Check for TABLE::needs_reopen() is needed since in some places we call
-        handler::close() for table instance (and set TABLE::db_stat to 0)
-        and do not remove such instances from the THD::open_tables
-        for some time, during which other thread can see those instances
-        (e.g. see partitioning code).
-      */
-      if (!thd_table->needs_reopen())
-      {
-	signalled|= mysql_lock_abort_for_thread(thd, thd_table);
-	if (thd && WSREP(thd) && wsrep_thd_is_BF(thd, true))
-	{
-	  WSREP_DEBUG("remove_table_from_cache: %llu",
-		      (unsigned long long) thd->real_id);
-	  wsrep_abort_thd((void *)thd, (void *)in_use, FALSE);
-	}
-      }
-    }
-    mysql_mutex_unlock(&in_use->LOCK_thd_data);
-  }
-  return signalled;
-}
-
-
 int setup_ftfuncs(SELECT_LEX *select_lex)
 {
   List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 94898628827..051b7366372 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -4775,19 +4775,6 @@ extern "C" int thd_slave_thread(const MYSQL_THD thd)
   return(thd->slave_thread);
 }
 
-/* Returns true for a worker thread in parallel replication. */
-extern "C" int thd_rpl_is_parallel(const MYSQL_THD thd)
-{
-  return thd->rgi_slave && thd->rgi_slave->is_parallel_exec;
-}
-
-/* Returns high resolution timestamp for the start
-  of the current query. */
-extern "C" time_t thd_start_time(const MYSQL_THD thd)
-{
-  return thd->start_time;
-}
-
 /* Returns high resolution timestamp for the start
   of the current query. */
 extern "C" unsigned long long thd_start_utime(const MYSQL_THD thd)
@@ -5035,17 +5022,14 @@ extern "C" int thd_non_transactional_update(const MYSQL_THD thd)
 
 extern "C" int thd_binlog_format(const MYSQL_THD thd)
 {
-#ifdef WITH_WSREP
   if (WSREP(thd))
   {
     /* for wsrep binlog format is meaningful also when binlogging is off */
-    return (int) WSREP_BINLOG_FORMAT(thd->variables.binlog_format);
+    return (int) thd->wsrep_binlog_format();
   }
-#endif /* WITH_WSREP */
   if (mysql_bin_log.is_open() && (thd->variables.option_bits & OPTION_BIN_LOG))
     return (int) thd->variables.binlog_format;
-  else
-    return BINLOG_FORMAT_UNSPEC;
+  return BINLOG_FORMAT_UNSPEC;
 }
 
 extern "C" void thd_mark_transaction_to_rollback(MYSQL_THD thd, bool all)
diff --git a/sql/sql_class.h b/sql/sql_class.h
index f7fbda7dc61..3cc114bd366 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -5262,10 +5262,11 @@ public:
 
   select_unit(THD *thd_arg):
     select_result_interceptor(thd_arg),
-    curr_step(0), prev_step(0), curr_sel(UINT_MAX),
-    step(UNION_TYPE), intersect_mark(0), write_err(0), table(0),
-    records(0)
-  { tmp_table_param.init(); }
+    intersect_mark(0), table(0)
+  {
+    init();
+    tmp_table_param.init();
+  }
   int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
   /**
     Do prepare() and prepare2() if they have been postponed until
@@ -5289,6 +5290,14 @@ public:
                                    bool keep_row_order,
                                    uint hidden);
   TMP_TABLE_PARAM *get_tmp_table_param() { return &tmp_table_param; }
+  void init()
+  {
+    curr_step= prev_step= 0;
+    curr_sel= UINT_MAX;
+    step= UNION_TYPE;
+    write_err= 0;
+    records= 0;
+  }
   void change_select();
 };
 
diff --git a/sql/sql_cte.cc b/sql/sql_cte.cc
index 487c2b3a0bb..ff80e198023 100644
--- a/sql/sql_cte.cc
+++ b/sql/sql_cte.cc
@@ -839,9 +839,10 @@ st_select_lex_unit *With_element::clone_parsed_spec(THD *thd,
        tbl;
        tbl= tbl->next_global)
   {
-    tbl->grant.privilege= with_table->grant.privilege;
     spec_tables_tail= tbl;
   }
+  if (check_table_access(thd, SELECT_ACL, spec_tables, FALSE, UINT_MAX, FALSE))
+    goto err;
   if (spec_tables)
   {
     if (with_table->next_global)
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 2c5f109e2ed..2ea2af73743 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -274,7 +274,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
                   SQL_I_List<ORDER> *order_list, ha_rows limit,
                   ulonglong options, select_result *result)
 {
-  bool          will_batch;
+  bool          will_batch= FALSE;
   int		error, loc_error;
   TABLE		*table;
   SQL_SELECT	*select=0;
@@ -286,11 +286,13 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
   bool		return_error= 0;
   ha_rows	deleted= 0;
   bool          reverse= FALSE;
+  bool          has_triggers;
   ORDER *order= (ORDER *) ((order_list && order_list->elements) ?
                            order_list->first : NULL);
   SELECT_LEX   *select_lex= &thd->lex->select_lex;
   killed_state killed_status= NOT_KILLED;
   THD::enum_binlog_query_type query_type= THD::ROW_QUERY_TYPE;
+  bool binlog_is_row;
   bool with_select= !select_lex->item_list.is_empty();
   Explain_delete *explain;
   Delete_plan query_plan(thd->mem_root);
@@ -413,9 +415,12 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
       - We should not be binlogging this statement in row-based, and
       - there should be no delete triggers associated with the table.
   */
+
+  has_triggers= (table->triggers &&
+                 table->triggers->has_delete_triggers());
   if (!with_select && !using_limit && const_cond_result &&
       (!thd->is_current_stmt_binlog_format_row() &&
-       !(table->triggers && table->triggers->has_delete_triggers()))
+       !has_triggers)
       && !table->versioned_by_sql())
   {
     /* Update the table->file->stats.records number */
@@ -565,14 +570,59 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
   if (!(select && select->quick))
     status_var_increment(thd->status_var.delete_scan_count);
 
-  if (query_plan.using_filesort)
+  binlog_is_row= thd->is_current_stmt_binlog_format_row();
+  DBUG_PRINT("info", ("binlog_is_row: %s", binlog_is_row ? "TRUE" : "FALSE"));
+
+  /*
+    We can use direct delete (delete that is done silently in the handler)
+    if none of the following conditions are true:
+    - There are triggers
+    - There is binary logging
+    - There is a virtual not stored column in the WHERE clause
+    - ORDER BY or LIMIT
+      - As this requires the rows to be deleted in a specific order
+      - Note that Spider can handle ORDER BY and LIMIT in a cluster with
+        one data node.  These conditions are therefore checked in
+        direct_delete_rows_init().
+
+    Direct delete does not require a WHERE clause
+
+    Later we also ensure that we are only using one table (no sub queries)
+  */
+
+  if ((table->file->ha_table_flags() & HA_CAN_DIRECT_UPDATE_AND_DELETE) &&
+      !has_triggers && !binlog_is_row && !with_select)
   {
+    table->mark_columns_needed_for_delete();
+    if (!table->check_virtual_columns_marked_for_read())
+    {
+      DBUG_PRINT("info", ("Trying direct delete"));
+      if (select && select->cond &&
+          (select->cond->used_tables() == table->map))
+      {
+        DBUG_ASSERT(!table->file->pushed_cond);
+        if (!table->file->cond_push(select->cond))
+          table->file->pushed_cond= select->cond;
+      }
+      if (!table->file->direct_delete_rows_init())
+      {
+        /* Direct deleting is supported */
+        DBUG_PRINT("info", ("Using direct delete"));
+        THD_STAGE_INFO(thd, stage_updating);
+        if (!(error= table->file->ha_direct_delete_rows(&deleted)))
+          error= -1;
+        goto terminate_delete;
+      }
+    }
+  }
 
+  if (query_plan.using_filesort)
+  {
     {
       Filesort fsort(order, HA_POS_ERROR, true, select);
       DBUG_ASSERT(query_plan.index == MAX_KEY);
 
-      Filesort_tracker *fs_tracker= 
+      Filesort_tracker *fs_tracker=
         thd->lex->explain->get_upd_del_plan()->filesort_tracker;
 
       if (!(file_sort= filesort(thd, table, &fsort, fs_tracker)))
@@ -611,15 +661,12 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
   if (init_ftfuncs(thd, select_lex, 1))
     goto got_error;
 
-  if (table->prepare_triggers_for_delete_stmt_or_event())
-  {
-    will_batch= FALSE;
-  }
-  else
-    will_batch= !table->file->start_bulk_delete();
-
   table->mark_columns_needed_for_delete();
 
+  if ((table->file->ha_table_flags() & HA_CAN_FORCE_BULK_DELETE) &&
+      !table->prepare_triggers_for_delete_stmt_or_event())
+    will_batch= !table->file->start_bulk_delete();
+
   if (with_select)
   {
     if (result->send_result_set_metadata(select_lex->item_list,
@@ -727,6 +774,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
     else
       break;
   }
+
 terminate_delete:
   killed_status= thd->killed;
   if (killed_status != NOT_KILLED || thd->is_error())
@@ -815,6 +863,8 @@ cleanup:
   }
   delete file_sort;
   free_underlaid_joins(thd, select_lex);
+  if (table->file->pushed_cond)
+    table->file->cond_pop();
   DBUG_RETURN(error >= 0 || thd->is_error());
   
   /* Special exits */
@@ -836,7 +886,8 @@ send_nothing_and_leave:
   delete select;
   delete file_sort;
   free_underlaid_joins(thd, select_lex);
-  //table->set_keyread(false);
+  if (table->file->pushed_cond)
+    table->file->cond_pop();
 
   DBUG_ASSERT(!return_error || thd->is_error() || thd->killed);
   DBUG_RETURN((return_error || thd->is_error() || thd->killed) ? 1 : 0);
diff --git a/sql/sql_explain.cc b/sql/sql_explain.cc
index 660d68427d1..fed38a5f4f4 100644
--- a/sql/sql_explain.cc
+++ b/sql/sql_explain.cc
@@ -1813,9 +1813,9 @@ const char * extra_tag_text[]=
 
   "Using join buffer", // special handling 
 
-  "const row not found",
-  "unique row not found",
-  "Impossible ON condition"
+  "Const row not found",
+  "Unique row not found",
+  "Impossible ON condition",
 };
 
 
diff --git a/sql/sql_get_diagnostics.cc b/sql/sql_get_diagnostics.cc
index 76973b4daa2..e7ab6cc3c75 100644
--- a/sql/sql_get_diagnostics.cc
+++ b/sql/sql_get_diagnostics.cc
@@ -110,6 +110,9 @@ Diagnostics_information_item::set_value(THD *thd, Item **value)
 
   DBUG_ASSERT(srp);
 
+  /* GET DIAGNOSTICS is not allowed in prepared statements */
+  DBUG_ASSERT(srp->get_item_param() == NULL);
+
   /* Set variable/parameter value. */
   rv= srp->set_value(thd, thd->spcont, value);
 
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 947c41e461e..eecfd5ad0b6 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -139,6 +139,48 @@ static void mysql_ha_hash_free(SQL_HANDLER *table)
   delete table;
 }
 
+static void mysql_ha_close_childs(THD *thd, TABLE_LIST *current_table_list,
+                                  TABLE_LIST **next_global)
+{
+  TABLE_LIST *table_list;
+  DBUG_ENTER("mysql_ha_close_childs");
+  DBUG_PRINT("info",("current_table_list: %p", current_table_list));
+  DBUG_PRINT("info",("next_global: %p", *next_global));
+  for (table_list = *next_global; table_list; table_list = *next_global)
+  {
+    *next_global = table_list->next_global;
+    DBUG_PRINT("info",("table_name: %s.%s", table_list->table->s->db.str,
+                       table_list->table->s->table_name.str));
+    DBUG_PRINT("info",("parent_l: %p", table_list->parent_l));
+    if (table_list->parent_l == current_table_list)
+    {
+      DBUG_PRINT("info",("found child"));
+      TABLE *table = table_list->table;
+      if (table)
+      {
+        table->open_by_handler= 0;
+        if (!table->s->tmp_table)
+        {
+          (void) close_thread_table(thd, &table);
+          thd->mdl_context.release_lock(table_list->mdl_request.ticket);
+        }
+        else
+        {
+          thd->mark_tmp_table_as_free_for_reuse(table);
+        }
+      }
+      mysql_ha_close_childs(thd, table_list, next_global);
+    }
+    else
+    {
+      /* the end of child tables */
+      *next_global = table_list;
+      break;
+    }
+  }
+  DBUG_VOID_RETURN;
+}
+
 /**
   Close a HANDLER table.
 
@@ -155,11 +197,16 @@ static void mysql_ha_close_table(SQL_HANDLER *handler)
 {
   THD *thd= handler->thd;
   TABLE *table= handler->table;
+  TABLE_LIST *current_table_list= NULL, *next_global;
 
   /* check if table was already closed */
   if (!table)
     return;
 
+  if ((next_global= table->file->get_next_global_for_child()))
+    current_table_list= next_global->parent_l;
+
+  table->open_by_handler= 0;
   if (!table->s->tmp_table)
   {
     /* Non temporary table. */
@@ -170,15 +217,17 @@ static void mysql_ha_close_table(SQL_HANDLER *handler)
     }
 
     table->file->ha_index_or_rnd_end();
-    table->open_by_handler= 0;
     close_thread_table(thd, &table);
+    if (current_table_list)
+      mysql_ha_close_childs(thd, current_table_list, &next_global);
     thd->mdl_context.release_lock(handler->mdl_request.ticket);
   }
   else
   {
     /* Must be a temporary table */
     table->file->ha_index_or_rnd_end();
-    table->open_by_handler= 0;
+    if (current_table_list)
+      mysql_ha_close_childs(thd, current_table_list, &next_global);
     thd->mark_tmp_table_as_free_for_reuse(table);
   }
   my_free(handler->lock);
@@ -309,15 +358,24 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
     goto err;
   }
 
-  if (tables->mdl_request.ticket &&
-      thd->mdl_context.has_lock(mdl_savepoint, tables->mdl_request.ticket))
+  DBUG_PRINT("info",("clone_tickets start"));
+  for (TABLE_LIST *table_list= tables; table_list;
+    table_list= table_list->next_global)
+  {
+    DBUG_PRINT("info",("table_list %s.%s", table_list->table->s->db.str,
+      table_list->table->s->table_name.str));
+  if (table_list->mdl_request.ticket &&
+      thd->mdl_context.has_lock(mdl_savepoint, table_list->mdl_request.ticket))
   {
+      DBUG_PRINT("info",("clone_tickets"));
     /* The ticket returned is within a savepoint. Make a copy.  */
-    error= thd->mdl_context.clone_ticket(&tables->mdl_request);
-    tables->table->mdl_ticket= tables->mdl_request.ticket;
+    error= thd->mdl_context.clone_ticket(&table_list->mdl_request);
+    table_list->table->mdl_ticket= table_list->mdl_request.ticket;
     if (error)
       goto err;
   }
+  }
+  DBUG_PRINT("info",("clone_tickets end"));
 
   if (! reopen)
   {
@@ -378,26 +436,37 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
 
   /* Restore the state. */
   thd->set_open_tables(backup_open_tables);
+  DBUG_PRINT("info",("set_lock_duration start"));
   if (sql_handler->mdl_request.ticket)
   {
     thd->mdl_context.set_lock_duration(sql_handler->mdl_request.ticket,
                                        MDL_EXPLICIT);
     thd->mdl_context.set_needs_thr_lock_abort(TRUE);
   }
+  for (TABLE_LIST *table_list= tables->next_global; table_list;
+    table_list= table_list->next_global)
+  {
+    DBUG_PRINT("info",("table_list %s.%s", table_list->table->s->db.str,
+      table_list->table->s->table_name.str));
+    if (table_list->mdl_request.ticket)
+    {
+      thd->mdl_context.set_lock_duration(table_list->mdl_request.ticket,
+                                         MDL_EXPLICIT);
+      thd->mdl_context.set_needs_thr_lock_abort(TRUE);
+    }
+  }
+  DBUG_PRINT("info",("set_lock_duration end"));
 
   /*
-    Assert that the above check prevents opening of views and merge tables.
-    For temporary tables, TABLE::next can be set even if only one table
-    was opened for HANDLER as it is used to link them together.
-  */
-  DBUG_ASSERT(sql_handler->table->next == NULL ||
-              sql_handler->table->s->tmp_table);
-  /*
     If it's a temp table, don't reset table->query_id as the table is
     being used by this handler. For non-temp tables we use this flag
     in asserts.
   */
-  table->open_by_handler= 1;
+  for (TABLE_LIST *table_list= tables; table_list;
+    table_list= table_list->next_global)
+  {
+    table_list->table->open_by_handler= 1;
+  }
 
   /* Safety, cleanup the pointer to satisfy MDL assertions. */
   tables->mdl_request.ticket= NULL;
@@ -707,8 +776,14 @@ retry:
   {
     int lock_error;
 
-    if (handler->lock->lock_count > 0)
-      handler->lock->locks[0]->type= handler->lock->locks[0]->org_type;
+    THR_LOCK_DATA **pos,**end;
+    for (pos= handler->lock->locks,
+           end= handler->lock->locks + handler->lock->lock_count;
+         pos < end;
+         pos++)
+    {
+      pos[0]->type= pos[0]->org_type;
+    }
 
     /* save open_tables state */
     TABLE* backup_open_tables= thd->open_tables;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 4a42d8dc156..950635d74e3 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -2530,8 +2530,7 @@ TABLE *Delayed_insert::get_local_table(THD* client_thd)
         The thread could be killed with an error message if
         di->handle_inserts() or di->open_and_lock_table() fails.
         The thread could be killed without an error message if
-        killed using mysql_notify_thread_having_shared_lock() or
-        kill_delayed_threads_for_table().
+        killed using kill_delayed_threads_for_table().
       */
       if (!thd.is_error())
         my_message(ER_QUERY_INTERRUPTED, ER_THD(&thd, ER_QUERY_INTERRUPTED),
diff --git a/sql/sql_join_cache.h b/sql/sql_join_cache.h
index f6894c6727d..12c278dae85 100644
--- a/sql/sql_join_cache.h
+++ b/sql/sql_join_cache.h
@@ -1325,6 +1325,10 @@ public:
   JOIN_CACHE_BKA(JOIN *j, JOIN_TAB *tab, uint flags, JOIN_CACHE *prev)
     :JOIN_CACHE(j, tab, prev), mrr_mode(flags) {}
   
+  JOIN_CACHE_BKA(JOIN_CACHE_BKA *bka)
+    :JOIN_CACHE(bka->join, bka->join_tab, bka->prev_cache),
+      mrr_mode(bka->mrr_mode)  {}
+
   uchar **get_curr_association_ptr() { return &curr_association; }
 
   /* Initialize the BKA cache */       
@@ -1421,6 +1425,10 @@ public:
   JOIN_CACHE_BKAH(JOIN *j, JOIN_TAB *tab, uint flags, JOIN_CACHE *prev)
     :JOIN_CACHE_BNLH(j, tab, prev), mrr_mode(flags)  {}
 
+  JOIN_CACHE_BKAH(JOIN_CACHE_BKAH *bkah)
+    :JOIN_CACHE_BNLH(bkah->join, bkah->join_tab, bkah->prev_cache),
+      mrr_mode(bkah->mrr_mode)  {}
+
   uchar **get_curr_association_ptr() { return &curr_matching_chain; }
 
   /* Initialize the BKAH cache */       
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 6f79d443345..db22669d287 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -829,6 +829,7 @@ void lex_end_stage2(LEX *lex)
 
   /* Reset LEX_MASTER_INFO */
   lex->mi.reset(lex->sql_command == SQLCOM_CHANGE_MASTER);
+  delete_dynamic(&lex->delete_gtid_domain);
 
   DBUG_VOID_RETURN;
 }
@@ -3060,6 +3061,10 @@ LEX::LEX()
                       INITIAL_LEX_PLUGIN_LIST_SIZE, 0);
   reset_query_tables_list(TRUE);
   mi.init();
+  init_dynamic_array2(&delete_gtid_domain, sizeof(ulong*),
+                      gtid_domain_static_buffer,
+                      initial_gtid_domain_buffer_size,
+                      initial_gtid_domain_buffer_size, 0);
 }
 
 
@@ -5623,6 +5628,35 @@ sp_variable *LEX::sp_add_for_loop_variable(THD *thd, const LEX_CSTRING *name,
 }
 
 
+bool LEX::sp_for_loop_implicit_cursor_statement(THD *thd,
+                                                Lex_for_loop_bounds_st *bounds,
+                                                sp_lex_cursor *cur)
+{
+  Item *item;
+  DBUG_ASSERT(sphead);
+  LEX_CSTRING name= {STRING_WITH_LEN("[implicit_cursor]") };
+  if (sp_declare_cursor(thd, &name, cur, NULL, true))
+    return true;
+  DBUG_ASSERT(thd->lex == this);
+  if (!(bounds->m_index= new (thd->mem_root) sp_assignment_lex(thd, this)))
+    return true;
+  bounds->m_index->sp_lex_in_use= true;
+  sphead->reset_lex(thd, bounds->m_index);
+  DBUG_ASSERT(thd->lex != this);
+  if (!(item= new (thd->mem_root) Item_field(thd,
+                                             thd->lex->current_context(),
+                                             NullS, NullS, &name)))
+    return true;
+  bounds->m_index->set_item_and_free_list(item, NULL);
+  if (thd->lex->sphead->restore_lex(thd))
+    return true;
+  DBUG_ASSERT(thd->lex == this);
+  bounds->m_direction= 1;
+  bounds->m_upper_bound= NULL;
+  bounds->m_implicit_cursor= true;
+  return false;
+}
+
 sp_variable *
 LEX::sp_add_for_loop_cursor_variable(THD *thd,
                                      const LEX_CSTRING *name,
@@ -5834,7 +5868,7 @@ bool LEX::sp_for_loop_cursor_finalize(THD *thd, const Lex_for_loop_st &loop)
 {
   sp_instr_cfetch *instr=
     new (thd->mem_root) sp_instr_cfetch(sphead->instructions(),
-                                        spcont, loop.m_cursor_offset);
+                                        spcont, loop.m_cursor_offset, false);
   if (instr == NULL || sphead->add_instr(instr))
     return true;
   instr->add_to_varlist(loop.m_index);
@@ -6481,6 +6515,11 @@ Item *LEX::create_and_link_Item_trigger_field(THD *thd,
 Item_param *LEX::add_placeholder(THD *thd, const LEX_CSTRING *name,
                                  const char *start, const char *end)
 {
+  if (!thd->m_parser_state->m_lip.stmt_prepare_mode)
+  {
+    thd->parse_error(ER_SYNTAX_ERROR, start);
+    return NULL;
+  }
   if (!parsing_options.allows_variable)
   {
     my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
@@ -7321,7 +7360,8 @@ bool LEX::sp_add_cfetch(THD *thd, const LEX_CSTRING *name)
     return true;
   }
   i= new (thd->mem_root)
-    sp_instr_cfetch(sphead->instructions(), spcont, offset);
+    sp_instr_cfetch(sphead->instructions(), spcont, offset,
+                    !(thd->variables.sql_mode & MODE_ORACLE));
   if (i == NULL || sphead->add_instr(i))
     return true;
   return false;
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index a58bd9725ea..94fdc6442ab 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -226,6 +226,13 @@ enum enum_sp_data_access
   SP_MODIFIES_SQL_DATA
 };
 
+enum enum_sp_aggregate_type
+{
+  DEFAULT_AGGREGATE= 0,
+  NOT_AGGREGATE,
+  GROUP_AGGREGATE
+};
+
 const LEX_STRING sp_data_access_name[]=
 {
   { C_STRING_WITH_LEN("") },
@@ -1305,6 +1312,7 @@ struct st_sp_chistics
   enum enum_sp_suid_behaviour suid;
   bool detistic;
   enum enum_sp_data_access daccess;
+  enum enum_sp_aggregate_type agg_type;
   void init() { bzero(this, sizeof(*this)); }
   void set(const st_sp_chistics &other) { *this= other; }
   bool read_from_mysql_proc_row(THD *thd, TABLE *table);
@@ -2976,6 +2984,13 @@ public:
   */
   Item *limit_rows_examined;
   ulonglong limit_rows_examined_cnt;
+  /**
+    Holds a set of domain_ids for deletion at FLUSH..DELETE_DOMAIN_ID
+  */
+  DYNAMIC_ARRAY delete_gtid_domain;
+  static const ulong initial_gtid_domain_buffer_size= 16;
+  ulong gtid_domain_static_buffer[initial_gtid_domain_buffer_size];
+
   inline void set_limit_rows_examined()
   {
     if (limit_rows_examined)
@@ -3503,6 +3518,9 @@ public:
                                                uint coffset,
                                                sp_assignment_lex *param_lex,
                                                Item_args *parameters);
+  bool sp_for_loop_implicit_cursor_statement(THD *thd,
+                                             Lex_for_loop_bounds_st *bounds,
+                                             sp_lex_cursor *cur);
   bool sp_for_loop_cursor_condition_test(THD *thd, const Lex_for_loop_st &loop);
   bool sp_for_loop_cursor_finalize(THD *thd, const Lex_for_loop_st &);
 
diff --git a/sql/sql_list.h b/sql/sql_list.h
index 422b7943aa9..c708ed6d2f9 100644
--- a/sql/sql_list.h
+++ b/sql/sql_list.h
@@ -622,6 +622,10 @@ struct ilink
   {
     DBUG_ASSERT(prev != 0 && next != 0);
   }
+  inline void assert_not_linked()
+  {
+    DBUG_ASSERT(prev == 0 && next == 0);
+  }
   virtual ~ilink() { unlink(); }		/*lint -e1740 */
 };
 
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 590fe245d7d..a255c477cee 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -3735,6 +3735,14 @@ mysql_execute_command(THD *thd)
     ulong privileges_requested= lex->exchange ? SELECT_ACL | FILE_ACL :
       SELECT_ACL;
 
+    /* 
+      The same function must be called for DML commands
+      when CTEs are supported in DML statements
+    */
+    res= check_dependencies_in_with_clauses(thd->lex->with_clauses_list);
+    if (res)
+      break;
+
     if (all_tables)
       res= check_table_access(thd,
                               privileges_requested,
@@ -6290,6 +6298,24 @@ finish:
       THD_STAGE_INFO(thd, stage_rollback);
       trans_rollback_stmt(thd);
     }
+#ifdef WITH_WSREP
+    else if (thd->spcont &&
+             (thd->wsrep_conflict_state == MUST_ABORT ||
+              thd->wsrep_conflict_state == CERT_FAILURE))
+    {
+      /*
+        The error was cleared, but THD was aborted by wsrep and
+        wsrep_conflict_state is still set accordingly. This
+        situation is expected if we are running a stored procedure
+        that declares a handler that catches ER_LOCK_DEADLOCK error.
+        In which case the error may have been cleared in method
+        sp_rcontext::handle_sql_condition().
+      */
+      trans_rollback_stmt(thd);
+      thd->wsrep_conflict_state= NO_CONFLICT;
+      thd->killed= NOT_KILLED;
+    }
+#endif /* WITH_WSREP */
     else
     {
       /* If commit fails, we should be able to reset the OK status. */
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index 9478db8e6d5..462829a255b 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -1155,6 +1155,7 @@ static bool plugin_add(MEM_ROOT *tmp_root,
       report_error(report, ER_CANT_OPEN_LIBRARY, dl->str, ENOEXEC, buf);
       goto err;
     }
+
     if (plugin_maturity_map[plugin->maturity] < plugin_maturity)
     {
       char buf[256];
@@ -1167,6 +1168,14 @@ static bool plugin_add(MEM_ROOT *tmp_root,
       report_error(report, ER_CANT_OPEN_LIBRARY, dl->str, EPERM, buf);
       goto err;
     }
+    else if (plugin_maturity_map[plugin->maturity] < SERVER_MATURITY_LEVEL)
+    {
+      sql_print_warning("Plugin '%s' is of maturity level %s while the server is %s",
+        tmp.name.str,
+        plugin_maturity_names[plugin->maturity],
+        plugin_maturity_names[SERVER_MATURITY_LEVEL]);
+    }
+
     tmp.plugin= plugin;
     tmp.ref_count= 0;
     tmp.state= PLUGIN_IS_UNINITIALIZED;
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index 775717fe62b..243d9d524c2 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -489,24 +489,23 @@ static ulong get_param_length(uchar **packet, ulong len)
     (i.e. when input types altered) and for all subsequent executions
     we don't read any values for this.
 
-  @param  param             parameter item
   @param  pos               input data buffer
   @param  len               length of data in the buffer
 */
 
-static void set_param_tiny(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_tiny(uchar **pos, ulong len)
 {
 #ifndef EMBEDDED_LIBRARY
   if (len < 1)
     return;
 #endif
   int8 value= (int8) **pos;
-  param->set_int(param->unsigned_flag ? (longlong) ((uint8) value) :
-                                        (longlong) value, 4);
+  set_int(unsigned_flag ? (longlong) ((uint8) value) :
+                          (longlong) value, 4);
   *pos+= 1;
 }
 
-static void set_param_short(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_short(uchar **pos, ulong len)
 {
   int16 value;
 #ifndef EMBEDDED_LIBRARY
@@ -516,12 +515,12 @@ static void set_param_short(Item_param *param, uchar **pos, ulong len)
 #else
   shortget(value, *pos);
 #endif
-  param->set_int(param->unsigned_flag ? (longlong) ((uint16) value) :
-                                        (longlong) value, 6);
+  set_int(unsigned_flag ? (longlong) ((uint16) value) :
+                          (longlong) value, 6);
   *pos+= 2;
 }
 
-static void set_param_int32(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_int32(uchar **pos, ulong len)
 {
   int32 value;
 #ifndef EMBEDDED_LIBRARY
@@ -531,12 +530,12 @@ static void set_param_int32(Item_param *param, uchar **pos, ulong len)
 #else
   longget(value, *pos);
 #endif
-  param->set_int(param->unsigned_flag ? (longlong) ((uint32) value) :
-                                        (longlong) value, 11);
+  set_int(unsigned_flag ? (longlong) ((uint32) value) :
+                          (longlong) value, 11);
   *pos+= 4;
 }
 
-static void set_param_int64(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_int64(uchar **pos, ulong len)
 {
   longlong value;
 #ifndef EMBEDDED_LIBRARY
@@ -546,11 +545,11 @@ static void set_param_int64(Item_param *param, uchar **pos, ulong len)
 #else
   longlongget(value, *pos);
 #endif
-  param->set_int(value, 21);
+  set_int(value, 21);
   *pos+= 8;
 }
 
-static void set_param_float(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_float(uchar **pos, ulong len)
 {
   float data;
 #ifndef EMBEDDED_LIBRARY
@@ -560,11 +559,11 @@ static void set_param_float(Item_param *param, uchar **pos, ulong len)
 #else
   floatget(data, *pos);
 #endif
-  param->set_double((double) data);
+  set_double((double) data);
   *pos+= 4;
 }
 
-static void set_param_double(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_double(uchar **pos, ulong len)
 {
   double data;
 #ifndef EMBEDDED_LIBRARY
@@ -574,14 +573,14 @@ static void set_param_double(Item_param *param, uchar **pos, ulong len)
 #else
   doubleget(data, *pos);
 #endif
-  param->set_double((double) data);
+  set_double((double) data);
   *pos+= 8;
 }
 
-static void set_param_decimal(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_decimal(uchar **pos, ulong len)
 {
   ulong length= get_param_length(pos, len);
-  param->set_decimal((char*)*pos, length);
+  set_decimal((char*)*pos, length);
   *pos+= length;
 }
 
@@ -597,7 +596,7 @@ static void set_param_decimal(Item_param *param, uchar **pos, ulong len)
   @todo
     Add warning 'Data truncated' here
 */
-static void set_param_time(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_time(uchar **pos, ulong len)
 {
   MYSQL_TIME tm;
   ulong length= get_param_length(pos, len);
@@ -624,11 +623,11 @@ static void set_param_time(Item_param *param, uchar **pos, ulong len)
   }
   else
     set_zero_time(&tm, MYSQL_TIMESTAMP_TIME);
-  param->set_time(&tm, MYSQL_TIMESTAMP_TIME, MAX_TIME_FULL_WIDTH);
+  set_time(&tm, MYSQL_TIMESTAMP_TIME, MAX_TIME_FULL_WIDTH);
   *pos+= length;
 }
 
-static void set_param_datetime(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_datetime(uchar **pos, ulong len)
 {
   MYSQL_TIME tm;
   ulong length= get_param_length(pos, len);
@@ -654,13 +653,12 @@ static void set_param_datetime(Item_param *param, uchar **pos, ulong len)
   }
   else
     set_zero_time(&tm, MYSQL_TIMESTAMP_DATETIME);
-  param->set_time(&tm, MYSQL_TIMESTAMP_DATETIME,
-                  MAX_DATETIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
+  set_time(&tm, MYSQL_TIMESTAMP_DATETIME, MAX_DATETIME_WIDTH);
   *pos+= length;
 }
 
 
-static void set_param_date(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_date(uchar **pos, ulong len)
 {
   MYSQL_TIME tm;
   ulong length= get_param_length(pos, len);
@@ -679,8 +677,7 @@ static void set_param_date(Item_param *param, uchar **pos, ulong len)
   }
   else
     set_zero_time(&tm, MYSQL_TIMESTAMP_DATE);
-  param->set_time(&tm, MYSQL_TIMESTAMP_DATE,
-                  MAX_DATE_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
+  set_time(&tm, MYSQL_TIMESTAMP_DATE, MAX_DATE_WIDTH);
   *pos+= length;
 }
 
@@ -689,7 +686,7 @@ static void set_param_date(Item_param *param, uchar **pos, ulong len)
   @todo
     Add warning 'Data truncated' here
 */
-void set_param_time(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_time(uchar **pos, ulong len)
 {
   MYSQL_TIME tm= *((MYSQL_TIME*)*pos);
   tm.hour+= tm.day * 24;
@@ -701,145 +698,81 @@ void set_param_time(Item_param *param, uchar **pos, ulong len)
     tm.minute= 59;
     tm.second= 59;
   }
-  param->set_time(&tm, MYSQL_TIMESTAMP_TIME,
-                  MAX_TIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
-
+  set_time(&tm, MYSQL_TIMESTAMP_TIME, MAX_TIME_WIDTH);
 }
 
-void set_param_datetime(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_datetime(uchar **pos, ulong len)
 {
   MYSQL_TIME tm= *((MYSQL_TIME*)*pos);
   tm.neg= 0;
-
-  param->set_time(&tm, MYSQL_TIMESTAMP_DATETIME,
-                  MAX_DATETIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
+  set_time(&tm, MYSQL_TIMESTAMP_DATETIME, MAX_DATETIME_WIDTH);
 }
 
-void set_param_date(Item_param *param, uchar **pos, ulong len)
+void Item_param::set_param_date(uchar **pos, ulong len)
 {
   MYSQL_TIME *to= (MYSQL_TIME*)*pos;
-
-  param->set_time(to, MYSQL_TIMESTAMP_DATE,
-                  MAX_DATE_WIDTH * MY_CHARSET_BIN_MB_MAXLEN);
+  set_time(to, MYSQL_TIMESTAMP_DATE, MAX_DATE_WIDTH);
 }
 #endif /*!EMBEDDED_LIBRARY*/
 
 
-static void set_param_str_or_null(Item_param *param, uchar **pos, ulong len,
-                                  bool empty_string_is_null)
+void Item_param::set_param_str(uchar **pos, ulong len)
 {
   ulong length= get_param_length(pos, len);
-  if (length == 0 && empty_string_is_null)
-    param->set_null();
+  if (length == 0 && m_empty_string_is_null)
+    set_null();
   else
   {
     if (length > len)
       length= len;
-    param->set_str((const char *) *pos, length);
+    /*
+      We use &my_charset_bin here. Conversion and setting real character
+      sets will be done in Item_param::convert_str_value(), after the
+      original value is appended to the query used for logging.
+    */
+    set_str((const char *) *pos, length, &my_charset_bin, &my_charset_bin);
     *pos+= length;
   }
 }
 
 
-static void set_param_str(Item_param *param, uchar **pos, ulong len)
-{
-  set_param_str_or_null(param, pos, len, false);
-}
+#undef get_param_length
 
 
-/*
-  set_param_str_empty_is_null : bind empty string as null value
-  when sql_mode=MODE_EMPTY_STRING_IS_NULL
-*/
-static void set_param_str_empty_is_null(Item_param *param, uchar **pos,
-                                        ulong len)
+void Item_param::setup_conversion(THD *thd, uchar param_type)
 {
-  set_param_str_or_null(param, pos, len, true);
+  const Type_handler *h=
+    Type_handler::get_handler_by_field_type((enum_field_types) param_type);
+  /*
+    The client library ensures that we won't get any unexpected typecodes
+    in the bound parameter. Translating unknown typecodes to
+    &type_handler_string lets us to handle malformed packets as well.
+  */
+  if (!h)
+    h= &type_handler_string;
+  set_handler(h);
+  h->Item_param_setup_conversion(thd, this);
 }
 
 
-#undef get_param_length
-
-static void setup_one_conversion_function(THD *thd, Item_param *param,
-                                          uchar param_type)
+void Item_param::setup_conversion_blob(THD *thd)
 {
-  switch (param_type) {
-  case MYSQL_TYPE_TINY:
-    param->set_param_func= set_param_tiny;
-    break;
-  case MYSQL_TYPE_SHORT:
-    param->set_param_func= set_param_short;
-    break;
-  case MYSQL_TYPE_LONG:
-    param->set_param_func= set_param_int32;
-    break;
-  case MYSQL_TYPE_LONGLONG:
-    param->set_param_func= set_param_int64;
-    break;
-  case MYSQL_TYPE_FLOAT:
-    param->set_param_func= set_param_float;
-    break;
-  case MYSQL_TYPE_DOUBLE:
-    param->set_param_func= set_param_double;
-    break;
-  case MYSQL_TYPE_DECIMAL:
-  case MYSQL_TYPE_NEWDECIMAL:
-    param->set_param_func= set_param_decimal;
-    break;
-  case MYSQL_TYPE_TIME:
-    param->set_param_func= set_param_time;
-    break;
-  case MYSQL_TYPE_DATE:
-    param->set_param_func= set_param_date;
-    break;
-  case MYSQL_TYPE_DATETIME:
-  case MYSQL_TYPE_TIMESTAMP:
-    param->set_param_func= set_param_datetime;
-    break;
-  case MYSQL_TYPE_TINY_BLOB:
-  case MYSQL_TYPE_MEDIUM_BLOB:
-  case MYSQL_TYPE_LONG_BLOB:
-  case MYSQL_TYPE_BLOB:
-    param->set_param_func= set_param_str;
-    param->value.cs_info.character_set_of_placeholder= &my_charset_bin;
-    param->value.cs_info.character_set_client=
-      thd->variables.character_set_client;
-    DBUG_ASSERT(thd->variables.character_set_client);
-    param->value.cs_info.final_character_set_of_str_value= &my_charset_bin;
-    break;
-  default:
-    /*
-      The client library ensures that we won't get any other typecodes
-      except typecodes above and typecodes for string types. Marking
-      label as 'default' lets us to handle malformed packets as well.
-    */
-    {
-      CHARSET_INFO *fromcs= thd->variables.character_set_client;
-      CHARSET_INFO *tocs= thd->variables.collation_connection;
-      uint32 dummy_offset;
+  value.cs_info.character_set_of_placeholder= &my_charset_bin;
+  value.cs_info.character_set_client= thd->variables.character_set_client;
+  DBUG_ASSERT(thd->variables.character_set_client);
+  value.cs_info.final_character_set_of_str_value= &my_charset_bin;
+  m_empty_string_is_null= thd->variables.sql_mode & MODE_EMPTY_STRING_IS_NULL;
+}
 
-      param->value.cs_info.character_set_of_placeholder= fromcs;
-      param->value.cs_info.character_set_client= fromcs;
 
-      /*
-        Setup source and destination character sets so that they
-        are different only if conversion is necessary: this will
-        make later checks easier.
-      */
-      param->value.cs_info.final_character_set_of_str_value=
-        String::needs_conversion(0, fromcs, tocs, &dummy_offset) ?
-        tocs : fromcs;
-
-      param->set_param_func=
-        (thd->variables.sql_mode & MODE_EMPTY_STRING_IS_NULL) ?
-        set_param_str_empty_is_null : set_param_str;
-      /*
-        Exact value of max_length is not known unless data is converted to
-        charset of connection, so we have to set it later.
-      */
-    }
-  }
-  param->set_handler_by_field_type((enum enum_field_types) param_type);
+void Item_param::setup_conversion_string(THD *thd, CHARSET_INFO *fromcs)
+{
+  value.cs_info.set(thd, fromcs);
+  m_empty_string_is_null= thd->variables.sql_mode & MODE_EMPTY_STRING_IS_NULL;
+  /*
+    Exact value of max_length is not known unless data is converted to
+    charset of connection, so we have to set it later.
+  */
 }
 
 #ifndef EMBEDDED_LIBRARY
@@ -903,14 +836,13 @@ static bool insert_params_with_log(Prepared_statement *stmt, uchar *null_array,
       {
         if (read_pos >= data_end)
           DBUG_RETURN(1);
-        param->set_param_func(param, &read_pos, (uint) (data_end - read_pos));
+        param->set_param_func(&read_pos, (uint) (data_end - read_pos));
         if (param->has_no_value())
           DBUG_RETURN(1);
 
         if (param->limit_clause_param && !param->has_int_value())
         {
-          param->set_int(param->val_int(), MY_INT64_NUM_DECIMAL_DIGITS);
-          if (!param->unsigned_flag && param->value.integer < 0)
+          if (param->set_limit_clause_param(param->val_int()))
             DBUG_RETURN(1);
         }
       }
@@ -958,7 +890,7 @@ static bool insert_params(Prepared_statement *stmt, uchar *null_array,
       {
         if (read_pos >= data_end)
           DBUG_RETURN(1);
-        param->set_param_func(param, &read_pos, (uint) (data_end - read_pos));
+        param->set_param_func(&read_pos, (uint) (data_end - read_pos));
         if (param->has_no_value())
           DBUG_RETURN(1);
       }
@@ -1002,7 +934,7 @@ static bool insert_bulk_params(Prepared_statement *stmt,
       case STMT_INDICATOR_NONE:
         if ((*read_pos) >= data_end)
           DBUG_RETURN(1);
-        param->set_param_func(param, read_pos, (uint) (data_end - (*read_pos)));
+        param->set_param_func(read_pos, (uint) (data_end - (*read_pos)));
         if (param->has_no_value())
           DBUG_RETURN(1);
         if (param->convert_str_value(stmt->thd))
@@ -1048,7 +980,7 @@ static bool set_conversion_functions(Prepared_statement *stmt,
     typecode= sint2korr(read_pos);
     read_pos+= 2;
     (**it).unsigned_flag= MY_TEST(typecode & signed_bit);
-    setup_one_conversion_function(thd, *it, (uchar) (typecode & 0xff));
+    (*it)->setup_conversion(thd, (uchar) (typecode & 0xff));
   }
   *data= read_pos;
   DBUG_RETURN(0);
@@ -1103,7 +1035,7 @@ static bool emb_insert_params(Prepared_statement *stmt, String *expanded_query)
   for (; it < end; ++it, ++client_param)
   {
     Item_param *param= *it;
-    setup_one_conversion_function(thd, param, client_param->buffer_type);
+    param->setup_conversion(thd, client_param->buffer_type);
     if (!param->has_long_data_value())
     {
       if (*client_param->is_null)
@@ -1112,7 +1044,7 @@ static bool emb_insert_params(Prepared_statement *stmt, String *expanded_query)
       {
         uchar *buff= (uchar*) client_param->buffer;
         param->unsigned_flag= client_param->is_unsigned;
-        param->set_param_func(param, &buff,
+        param->set_param_func(&buff,
                               client_param->length ?
                               *client_param->length :
                               client_param->buffer_length);
@@ -1139,7 +1071,7 @@ static bool emb_insert_params_with_log(Prepared_statement *stmt, String *query)
   for (; it < end; ++it, ++client_param)
   {
     Item_param *param= *it;
-    setup_one_conversion_function(thd, param, client_param->buffer_type);
+    param->setup_conversion(thd, client_param->buffer_type);
     if (!param->has_long_data_value())
     {
       if (*client_param->is_null)
@@ -1148,7 +1080,7 @@ static bool emb_insert_params_with_log(Prepared_statement *stmt, String *query)
       {
         uchar *buff= (uchar*)client_param->buffer;
         param->unsigned_flag= client_param->is_unsigned;
-        param->set_param_func(param, &buff,
+        param->set_param_func(&buff,
                               client_param->length ?
                               *client_param->length :
                               client_param->buffer_length);
@@ -1281,12 +1213,6 @@ insert_params_from_actual_params_with_log(Prepared_statement *stmt,
   {
     Item_param *param= *it;
     Item *ps_param= param_it++;
-    /*
-      We have to call the setup_one_conversion_function() here to set
-      the parameter's members that might be needed further
-      (e.g. value.cs_info.character_set_client is used in the query_val_str()).
-    */
-    setup_one_conversion_function(thd, param, param->field_type());
     if (ps_param->save_in_param(thd, param))
       DBUG_RETURN(1);
 
diff --git a/sql/sql_reload.cc b/sql/sql_reload.cc
index 057d1a9f46c..93db089b24a 100644
--- a/sql/sql_reload.cc
+++ b/sql/sql_reload.cc
@@ -153,7 +153,10 @@ bool reload_acl_and_cache(THD *thd, unsigned long long options,
     tmp_write_to_binlog= 0;
     if (mysql_bin_log.is_open())
     {
-      if (mysql_bin_log.rotate_and_purge(true))
+      DYNAMIC_ARRAY *drop_gtid_domain=
+        (thd && (thd->lex->delete_gtid_domain.elements > 0)) ?
+        &thd->lex->delete_gtid_domain : NULL;
+      if (mysql_bin_log.rotate_and_purge(true, drop_gtid_domain))
         *write_to_binlog= -1;
 
       if (WSREP_ON)
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index 839b98dc785..d978a2d58ee 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -30,7 +30,7 @@
 #include <my_dir.h>
 #include "rpl_handler.h"
 #include "debug_sync.h"
-
+#include "log.h"                                // get_gtid_list_event
 
 enum enum_gtid_until_state {
   GTID_UNTIL_NOT_DONE,
@@ -875,72 +875,6 @@ get_binlog_list(MEM_ROOT *memroot)
   DBUG_RETURN(current_list);
 }
 
-/*
-  Find the Gtid_list_log_event at the start of a binlog.
-
-  NULL for ok, non-NULL error message for error.
-
-  If ok, then the event is returned in *out_gtid_list. This can be NULL if we
-  get back to binlogs written by old server version without GTID support. If
-  so, it means we have reached the point to start from, as no GTID events can
-  exist in earlier binlogs.
-*/
-static const char *
-get_gtid_list_event(IO_CACHE *cache, Gtid_list_log_event **out_gtid_list)
-{
-  Format_description_log_event init_fdle(BINLOG_VERSION);
-  Format_description_log_event *fdle;
-  Log_event *ev;
-  const char *errormsg = NULL;
-
-  *out_gtid_list= NULL;
-
-  if (!(ev= Log_event::read_log_event(cache, 0, &init_fdle,
-                                      opt_master_verify_checksum)) ||
-      ev->get_type_code() != FORMAT_DESCRIPTION_EVENT)
-  {
-    if (ev)
-      delete ev;
-    return "Could not read format description log event while looking for "
-      "GTID position in binlog";
-  }
-
-  fdle= static_cast<Format_description_log_event *>(ev);
-
-  for (;;)
-  {
-    Log_event_type typ;
-
-    ev= Log_event::read_log_event(cache, 0, fdle, opt_master_verify_checksum);
-    if (!ev)
-    {
-      errormsg= "Could not read GTID list event while looking for GTID "
-        "position in binlog";
-      break;
-    }
-    typ= ev->get_type_code();
-    if (typ == GTID_LIST_EVENT)
-      break;                                    /* Done, found it */
-    if (typ == START_ENCRYPTION_EVENT)
-    {
-      if (fdle->start_decryption((Start_encryption_log_event*) ev))
-        errormsg= "Could not set up decryption for binlog.";
-    }
-    delete ev;
-    if (typ == ROTATE_EVENT || typ == STOP_EVENT ||
-        typ == FORMAT_DESCRIPTION_EVENT || typ == START_ENCRYPTION_EVENT)
-      continue;                                 /* Continue looking */
-
-    /* We did not find any Gtid_list_log_event, must be old binlog. */
-    ev= NULL;
-    break;
-  }
-
-  delete fdle;
-  *out_gtid_list= static_cast<Gtid_list_log_event *>(ev);
-  return errormsg;
-}
-
 
 /*
   Check if every GTID requested by the slave is contained in this (or a later)
diff --git a/sql/sql_repl.h b/sql/sql_repl.h
index 4105bdddf4e..8d9a127bca7 100644
--- a/sql/sql_repl.h
+++ b/sql/sql_repl.h
@@ -81,7 +81,6 @@ int rpl_append_gtid_state(String *dest, bool use_binlog);
 int rpl_load_gtid_state(slave_connection_state *state, bool use_binlog);
 bool rpl_gtid_pos_check(THD *thd, char *str, size_t len);
 bool rpl_gtid_pos_update(THD *thd, char *str, size_t len);
-
 #else
 
 struct LOAD_FILE_IO_CACHE : public IO_CACHE { };
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 87c56b3e3f5..e0e160b45aa 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -2767,20 +2767,22 @@ bool JOIN::make_aggr_tables_info()
 
   /*
     All optimization is done. Check if we can use the storage engines
-    group by handler to evaluate the group by
+    group by handler to evaluate the group by.
+    Some storage engines, like spider can also do joins, group by and
+    distinct in the engine, so we do this for all queries, not only
+    GROUP BY queries.
   */
-  if (tables_list && (tmp_table_param.sum_func_count || group_list) &&
-      !procedure)
+  if (tables_list && !procedure)
   {
     /*
       At the moment we only support push down for queries where
       all tables are in the same storage engine
     */
     TABLE_LIST *tbl= tables_list;
-    handlerton *ht= tbl && tbl->table ? tbl->table->file->ht : 0;
+    handlerton *ht= tbl && tbl->table ? tbl->table->file->partition_ht() : 0;
     for (tbl= tbl->next_local; ht && tbl; tbl= tbl->next_local)
     {
-      if (!tbl->table || tbl->table->file->ht != ht)
+      if (!tbl->table || tbl->table->file->partition_ht() != ht)
         ht= 0;
     }
 
@@ -4572,6 +4574,7 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
               keyuse->val->is_null() && keyuse->null_rejecting)
           {
             s->type= JT_CONST;
+            s->table->const_table= 1;
             mark_as_null_row(table);
             found_const_table_map|= table->map;
 	    join->const_table_map|= table->map;
@@ -4677,6 +4680,7 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
 	        s->type= JT_CONST;
 	        join->const_table_map|=table->map;
 	        set_position(join,const_count++,s,start_keyuse);
+                /* create_ref_for_key will set s->table->const_table */
 	        if (create_ref_for_key(join, s, start_keyuse, FALSE,
 				       found_const_table_map))
                   goto error;
@@ -4882,12 +4886,12 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
 	join->const_table_map|= s->table->map;
 	set_position(join,const_count++,s,(KEYUSE*) 0);
 	s->type= JT_CONST;
+        s->table->const_table= 1;
 	if (*s->on_expr_ref)
 	{
 	  /* Generate empty row */
 	  s->info= ET_IMPOSSIBLE_ON_CONDITION;
 	  found_const_table_map|= s->table->map;
-	  s->type= JT_CONST;
 	  mark_as_null_row(s->table);		// All fields are NULL
 	}
       }
@@ -13231,7 +13235,7 @@ remove_const(JOIN *join,ORDER *first_order, COND *cond,
       *simple_order=0;				// Must do a temp table to sort
     else if (!(order_tables & not_const_tables))
     {
-      if (order->item[0]->has_subquery())
+      if (order->item[0]->with_subquery())
       {
         /*
           Delay the evaluation of constant ORDER and/or GROUP expressions that
@@ -13269,8 +13273,37 @@ remove_const(JOIN *join,ORDER *first_order, COND *cond,
             can be used without tmp. table.
           */
           bool can_subst_to_first_table= false;
+          bool first_is_in_sjm_nest= false;
+          if (first_is_base_table)
+          {
+            TABLE_LIST *tbl_for_first=
+              join->join_tab[join->const_tables].table->pos_in_table_list;
+            first_is_in_sjm_nest= tbl_for_first->sj_mat_info &&
+                                  tbl_for_first->sj_mat_info->is_used;
+          }
+          /*
+            Currently we do not employ the optimization that uses multiple
+            equalities for ORDER BY to remove tmp table in the case when
+            the first table happens to be the result of materialization of
+            a semi-join nest ( <=> first_is_in_sjm_nest == true).
+
+            When a semi-join nest is materialized and scanned to look for
+            possible matches in the remaining tables for every its row
+            the fields from the result of materialization are copied
+            into the record buffers of tables from the semi-join nest.
+            So these copies are used to access the remaining tables rather
+            than the fields from the result of materialization.
+
+            Unfortunately now this so-called 'copy back' technique is
+            supported only if the rows  are scanned with the rr_sequential
+            function, but not with other rr_* functions that are employed
+            when the result of materialization is required to be sorted.
+
+            TODO: either to support 'copy back' technique for the above case,
+                  or to get rid of this technique altogether.
+          */
           if (optimizer_flag(join->thd, OPTIMIZER_SWITCH_ORDERBY_EQ_PROP) &&
-              first_is_base_table &&
+              first_is_base_table && !first_is_in_sjm_nest &&
               order->item[0]->real_item()->type() == Item::FIELD_ITEM &&
               join->cond_equal)
           {
@@ -19925,6 +19958,7 @@ join_read_system(JOIN_TAB *tab)
     {
       if (error != HA_ERR_END_OF_FILE)
 	return report_error(table, error);
+      table->const_table= 1;
       mark_as_null_row(tab->table);
       empty_record(table);			// Make empty record
       return -1;
@@ -22533,7 +22567,7 @@ create_sort_index(THD *thd, JOIN *join, JOIN_TAB *tab, Filesort *fsort)
  
   table->file->ha_end_keyread();
   if (tab->type == JT_FT)
-    table->file->ft_end();
+    table->file->ha_ft_end();
   else
     table->file->ha_index_or_rnd_end();
 
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 36b1669b49f..659bc4e7827 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -1436,7 +1436,7 @@ public:
     table_count= 0;
     top_join_tab_count= 0;
     const_tables= 0;
-    const_table_map= 0;
+    const_table_map= found_const_table_map= 0;
     aggr_tables= 0;
     eliminated_tables= 0;
     join_list= 0;
diff --git a/sql/sql_sequence.cc b/sql/sql_sequence.cc
index 1af37fe1fad..de4cd3522a5 100644
--- a/sql/sql_sequence.cc
+++ b/sql/sql_sequence.cc
@@ -113,7 +113,7 @@ bool sequence_definition::check_and_adjust(bool set_reserved_until)
 
   /* To ensure that cache * real_increment will never overflow */
   max_increment= (real_increment ?
-                  labs(real_increment) :
+                  llabs(real_increment) :
                   MAX_AUTO_INCREMENT_VALUE);
 
   if (max_value >= start &&
@@ -852,10 +852,10 @@ bool Sql_cmd_alter_sequence::execute(THD *thd)
   if (check_grant(thd, ALTER_ACL, first_table, FALSE, 1, FALSE))
     DBUG_RETURN(TRUE);                  /* purecov: inspected */
 
-  if (lex->check_exists)
+  if (if_exists())
     thd->push_internal_handler(&no_such_table_handler);
   error= open_and_lock_tables(thd, first_table, FALSE, 0);
-  if (lex->check_exists)
+  if (if_exists())
   {
     trapped_errors= no_such_table_handler.safely_trapped_errors();
     thd->pop_internal_handler();
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 0b417017423..dd4d9178b35 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -5326,12 +5326,13 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
 
     if (share->tmp_table == SYSTEM_TMP_TABLE)
       table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
-    else if (share->tmp_table)
-      table->field[3]->store(STRING_WITH_LEN("LOCAL TEMPORARY"), cs);
     else if (share->table_type == TABLE_TYPE_SEQUENCE)
       table->field[3]->store(STRING_WITH_LEN("SEQUENCE"), cs);
     else
+    {
+      DBUG_ASSERT(share->tmp_table == NO_TMP_TABLE);
       table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
+    }
 
     for (int i= 4; i < 20; i++)
     {
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 24b9fa619ca..ba5eb36173b 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -5235,7 +5235,7 @@ static bool vers_reset_alter_copy(THD *thd, TABLE *table)
   READ_RECORD info;
   int error= 0;
   bool will_batch= false;
-  uint dup_key_found= 0;
+  ha_rows dup_key_found= 0;
   if (init_read_record(&info, thd, table, NULL, NULL, 0, 1, true))
     goto err;
 
diff --git a/sql/sql_type.cc b/sql/sql_type.cc
index d1e4641253c..b4860176c0c 100644
--- a/sql/sql_type.cc
+++ b/sql/sql_type.cc
@@ -4392,7 +4392,7 @@ bool Type_handler::
 bool Type_handler::
        Item_char_typecast_fix_length_and_dec(Item_char_typecast *item) const
 {
-  item->fix_length_and_dec_str();
+  item->fix_length_and_dec_generic();
   return false;
 }
 
@@ -4405,6 +4405,14 @@ bool Type_handler_numeric::
 }
 
 
+bool Type_handler_string_result::
+       Item_char_typecast_fix_length_and_dec(Item_char_typecast *item) const
+{
+  item->fix_length_and_dec_str();
+  return false;
+}
+
+
 bool Type_handler::
        Item_time_typecast_fix_length_and_dec(Item_time_typecast *item) const
 {
@@ -5060,7 +5068,6 @@ bool Type_handler_real_result::
 {
   param->unsigned_flag= attr->unsigned_flag;
   param->set_double(val->value.m_double);
-  param->set_handler(&type_handler_double);
   return false;
 }
 
@@ -5072,8 +5079,7 @@ bool Type_handler_int_result::
                             const st_value *val) const
 {
   param->unsigned_flag= attr->unsigned_flag;
-  param->set_int(val->value.m_longlong, MY_INT64_NUM_DECIMAL_DIGITS);
-  param->set_handler(&type_handler_longlong);
+  param->set_int(val->value.m_longlong, attr->max_length);
   return false;
 }
 
@@ -5086,7 +5092,6 @@ bool Type_handler_decimal_result::
 {
   param->unsigned_flag= attr->unsigned_flag;
   param->set_decimal(&val->m_decimal, attr->unsigned_flag);
-  param->set_handler(&type_handler_newdecimal);
   return false;
 }
 
@@ -5098,13 +5103,14 @@ bool Type_handler_string_result::
                             const st_value *val) const
 {
   param->unsigned_flag= false;
-  param->value.cs_info.set(thd, attr->collation.collation);
+  param->setup_conversion_string(thd, attr->collation.collation);
   /*
     Exact value of max_length is not known unless data is converted to
     charset of connection, so we have to set it later.
   */
-  param->set_handler(&type_handler_varchar);
-  return param->set_str(val->m_string.ptr(), val->m_string.length());
+  return param->set_str(val->m_string.ptr(), val->m_string.length(),
+                        attr->collation.collation,
+                        attr->collation.collation);
 }
 
 
@@ -5116,7 +5122,6 @@ bool Type_handler_temporal_result::
 {
   param->unsigned_flag= attr->unsigned_flag;
   param->set_time(&val->value.m_time, attr->max_length, attr->decimals);
-  param->set_handler(this);
   return false;
 }
 
@@ -5129,10 +5134,10 @@ bool Type_handler_geometry::
                             const st_value *val) const
 {
   param->unsigned_flag= false;
-  param->value.cs_info.set(thd, &my_charset_bin);
-  param->set_handler(&type_handler_geometry);
+  param->setup_conversion_blob(thd);
   param->set_geometry_type(attr->uint_geometry_type());
-  return param->set_str(val->m_string.ptr(), val->m_string.length());
+  return param->set_str(val->m_string.ptr(), val->m_string.length(),
+                        &my_charset_bin, &my_charset_bin);
 }
 #endif
 
@@ -5518,3 +5523,139 @@ Item *Type_handler_long_blob::
 }
 
 /***************************************************************************/
+
+void Type_handler_string_result::Item_param_setup_conversion(THD *thd,
+                                                             Item_param *param)
+                                                             const
+{
+  param->setup_conversion_string(thd, thd->variables.character_set_client);
+}
+
+
+void Type_handler_blob_common::Item_param_setup_conversion(THD *thd,
+                                                           Item_param *param)
+                                                           const
+{
+  param->setup_conversion_blob(thd);
+}
+
+
+void Type_handler_tiny::Item_param_set_param_func(Item_param *param,
+                                                  uchar **pos, ulong len) const
+{
+  param->set_param_tiny(pos, len);
+}
+
+
+void Type_handler_short::Item_param_set_param_func(Item_param *param,
+                                                   uchar **pos, ulong len) const
+{
+  param->set_param_short(pos, len);
+}
+
+
+void Type_handler_long::Item_param_set_param_func(Item_param *param,
+                                                  uchar **pos, ulong len) const
+{
+  param->set_param_int32(pos, len);
+}
+
+
+void Type_handler_longlong::Item_param_set_param_func(Item_param *param,
+                                                      uchar **pos,
+                                                      ulong len) const
+{
+  param->set_param_int64(pos, len);
+}
+
+
+void Type_handler_float::Item_param_set_param_func(Item_param *param,
+                                                   uchar **pos,
+                                                   ulong len) const
+{
+  param->set_param_float(pos, len);
+}
+
+
+void Type_handler_double::Item_param_set_param_func(Item_param *param,
+                                                   uchar **pos,
+                                                   ulong len) const
+{
+  param->set_param_double(pos, len);
+}
+
+
+void Type_handler_decimal_result::Item_param_set_param_func(Item_param *param,
+                                                            uchar **pos,
+                                                            ulong len) const
+{
+  param->set_param_decimal(pos, len);
+}
+
+
+void Type_handler_string_result::Item_param_set_param_func(Item_param *param,
+                                                           uchar **pos,
+                                                           ulong len) const
+{
+  param->set_param_str(pos, len);
+}
+
+
+void Type_handler_time_common::Item_param_set_param_func(Item_param *param,
+                                                         uchar **pos,
+                                                         ulong len) const
+{
+  param->set_param_time(pos, len);
+}
+
+
+void Type_handler_date_common::Item_param_set_param_func(Item_param *param,
+                                                         uchar **pos,
+                                                         ulong len) const
+{
+  param->set_param_date(pos, len);
+}
+
+
+void Type_handler_datetime_common::Item_param_set_param_func(Item_param *param,
+                                                             uchar **pos,
+                                                             ulong len) const
+{
+  param->set_param_datetime(pos, len);
+}
+
+
+void Type_handler_timestamp_common::Item_param_set_param_func(Item_param *param,
+                                                              uchar **pos,
+                                                              ulong len) const
+{
+  param->set_param_datetime(pos, len);
+}
+
+
+void Type_handler::Item_param_set_param_func(Item_param *param,
+                                             uchar **pos,
+                                             ulong len) const
+{
+  param->set_null(); // Not possible type code in the client-server protocol
+}
+
+
+void Type_handler_typelib::Item_param_set_param_func(Item_param *param,
+                                                     uchar **pos,
+                                                     ulong len) const
+{
+  param->set_null(); // Not possible type code in the client-server protocol
+}
+
+
+#ifdef HAVE_SPATIAL
+void Type_handler_geometry::Item_param_set_param_func(Item_param *param,
+                                                      uchar **pos,
+                                                      ulong len) const
+{
+  param->set_null(); // Not possible type code in the client-server protocol
+}
+#endif
+
+/***************************************************************************/
diff --git a/sql/sql_type.h b/sql/sql_type.h
index 3c52c70289a..c400420586e 100644
--- a/sql/sql_type.h
+++ b/sql/sql_type.h
@@ -804,6 +804,9 @@ public:
   virtual uint32 max_display_length(const Item *item) const= 0;
   virtual uint32 calc_pack_length(uint32 length) const= 0;
   virtual bool Item_save_in_value(Item *item, st_value *value) const= 0;
+  virtual void Item_param_setup_conversion(THD *thd, Item_param *) const {}
+  virtual void Item_param_set_param_func(Item_param *param,
+                                         uchar **pos, ulong len) const;
   virtual bool Item_param_set_from_value(THD *thd,
                                          Item_param *param,
                                          const Type_all_attributes *attr,
@@ -1422,6 +1425,8 @@ public:
                              const Type_cast_attributes &attr) const;
   uint Item_decimal_precision(const Item *item) const;
   bool Item_save_in_value(Item *item, st_value *value) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
   bool Item_param_set_from_value(THD *thd,
                                  Item_param *param,
                                  const Type_all_attributes *attr,
@@ -1658,6 +1663,9 @@ public:
   }
   uint Item_decimal_precision(const Item *item) const;
   bool Item_save_in_value(Item *item, st_value *value) const;
+  void Item_param_setup_conversion(THD *thd, Item_param *) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
   bool Item_param_set_from_value(THD *thd,
                                  Item_param *param,
                                  const Type_all_attributes *attr,
@@ -1716,6 +1724,7 @@ public:
                                   MYSQL_TIME *, ulonglong fuzzydate) const;
   bool Item_func_between_fix_length_and_dec(Item_func_between *func) const;
   longlong Item_func_between_val_int(Item_func_between *func) const;
+  bool Item_char_typecast_fix_length_and_dec(Item_char_typecast *) const;
   cmp_item *make_cmp_item(THD *thd, CHARSET_INFO *cs) const;
   in_vector *make_in_vector(THD *, const Item_func_in *, uint nargs) const;
   bool Item_func_in_fix_comparator_compatible_types(THD *thd,
@@ -1783,6 +1792,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -1810,6 +1821,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -1840,6 +1853,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -1871,6 +1886,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2005,6 +2022,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2035,6 +2054,8 @@ public:
                           const Record_addr &addr,
                           const Type_all_attributes &attr,
                           TABLE *table) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2079,6 +2100,8 @@ public:
   bool set_comparator_func(Arg_comparator *cmp) const;
   cmp_item *make_cmp_item(THD *thd, CHARSET_INFO *cs) const;
   in_vector *make_in_vector(THD *, const Item_func_in *, uint nargs) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2162,6 +2185,8 @@ public:
                                        Type_handler_hybrid_field_type *,
                                        Type_all_attributes *atrr,
                                        Item **items, uint nitems) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 class Type_handler_date: public Type_handler_date_common
@@ -2236,6 +2261,8 @@ public:
                                        Type_handler_hybrid_field_type *,
                                        Type_all_attributes *atrr,
                                        Item **items, uint nitems) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2316,6 +2343,8 @@ public:
                                        Type_handler_hybrid_field_type *,
                                        Type_all_attributes *atrr,
                                        Item **items, uint nitems) const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2584,6 +2613,7 @@ public:
                                        Type_handler_hybrid_field_type *,
                                        Type_all_attributes *atrr,
                                        Item **items, uint nitems) const;
+  void Item_param_setup_conversion(THD *thd, Item_param *) const;
 };
 
 
@@ -2685,6 +2715,8 @@ public:
   {
     return false; // Materialization does not work with GEOMETRY columns
   }
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
   bool Item_param_set_from_value(THD *thd,
                                  Item_param *param,
                                  const Type_all_attributes *attr,
@@ -2764,6 +2796,8 @@ public:
                                          const handler *file,
                                          const Schema_specification_st *schema)
                                          const;
+  void Item_param_set_param_func(Item_param *param,
+                                 uchar **pos, ulong len) const;
 };
 
 
@@ -2832,6 +2866,10 @@ public:
   Type_handler_hybrid_field_type(const Type_handler_hybrid_field_type *other)
     :m_type_handler(other->m_type_handler), m_vers_trx_id(other->m_vers_trx_id)
   { }
+  void swap(Type_handler_hybrid_field_type &other)
+  {
+    swap_variables(const Type_handler *, m_type_handler, other.m_type_handler);
+  }
   const Type_handler *type_handler() const { return m_type_handler; }
   enum_field_types real_field_type() const
   {
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index ecc2a54bdd8..b3a7227678d 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -303,7 +303,8 @@ int select_union_recursive::send_data(List<Item> &values)
 {
   int rc= select_unit::send_data(values);
 
-  if (write_err != HA_ERR_FOUND_DUPP_KEY && 
+  if (rc == 0 &&
+      write_err != HA_ERR_FOUND_DUPP_KEY &&
       write_err != HA_ERR_FOUND_DUPP_UNIQUE)
   { 
     int err;
@@ -1360,6 +1361,9 @@ bool st_select_lex_unit::exec()
   if (saved_error)
     DBUG_RETURN(saved_error);
 
+  if (union_result)
+    union_result->init();
+
   if (uncacheable || !item || !item->assigned() || describe)
   {
     if (!fake_select_lex && !(with_element && with_element->is_recursive))
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 96aec4b9afa..d14d50267fd 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -275,11 +275,12 @@ int mysql_update(THD *thd,
 {
   bool		using_limit= limit != HA_POS_ERROR;
   bool          safe_update= thd->variables.option_bits & OPTION_SAFE_UPDATES;
-  bool          used_key_is_modified= FALSE, transactional_table, will_batch;
+  bool          used_key_is_modified= FALSE, transactional_table;
+  bool          will_batch= FALSE;
   bool		can_compare_record;
   int           res;
   int		error, loc_error;
-  uint          dup_key_found;
+  ha_rows       dup_key_found;
   bool          need_sort= TRUE;
   bool          reverse= FALSE;
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
@@ -296,6 +297,7 @@ int mysql_update(THD *thd,
   ulonglong     id;
   List<Item> all_fields;
   killed_state killed_status= NOT_KILLED;
+  bool has_triggers, binlog_is_row, do_direct_update= FALSE;
   Update_plan query_plan(thd->mem_root);
   Explain_update *explain;
   TABLE_LIST *update_source_table;
@@ -311,7 +313,7 @@ int mysql_update(THD *thd,
   if (open_tables(thd, &table_list, &table_count, 0))
     DBUG_RETURN(1);
 
-  //Prepare views so they are handled correctly.
+  /* Prepare views so they are handled correctly */
   if (mysql_handle_derived(thd->lex, DT_INIT))
     DBUG_RETURN(1);
 
@@ -543,7 +545,6 @@ int mysql_update(THD *thd,
       query_plan.using_io_buffer= true;
   }
 
-
   /*
     Ok, we have generated a query plan for the UPDATE.
      - if we're running EXPLAIN UPDATE, goto produce explain output 
@@ -558,10 +559,68 @@ int mysql_update(THD *thd,
 
   DBUG_EXECUTE_IF("show_explain_probe_update_exec_start", 
                   dbug_serve_apcs(thd, 1););
-  
+
+  has_triggers= (table->triggers &&
+                 (table->triggers->has_triggers(TRG_EVENT_UPDATE,
+                                                TRG_ACTION_BEFORE) ||
+                 table->triggers->has_triggers(TRG_EVENT_UPDATE,
+                                               TRG_ACTION_AFTER)));
+  DBUG_PRINT("info", ("has_triggers: %s", has_triggers ? "TRUE" : "FALSE"));
+  binlog_is_row= thd->is_current_stmt_binlog_format_row();
+  DBUG_PRINT("info", ("binlog_is_row: %s", binlog_is_row ? "TRUE" : "FALSE"));
+
   if (!(select && select->quick))
     status_var_increment(thd->status_var.update_scan_count);
 
+  /*
+    We can use direct update (update that is done silently in the handler)
+    if none of the following conditions are true:
+    - There are triggers
+    - There is binary logging
+    - using_io_buffer
+      - This means that the partition changed or the key we want
+        to use for scanning the table is changed
+    - ignore is set
+      - Direct updates don't return the number of ignored rows
+    - There is a virtual not stored column in the WHERE clause
+    - Changing a field used by a stored virtual column, which
+      would require the column to be recalculated.
+    - ORDER BY or LIMIT
+      - As this requires the rows to be updated in a specific order
+      - Note that Spider can handle ORDER BY and LIMIT in a cluster with
+        one data node.  These conditions are therefore checked in
+        direct_update_rows_init().
+
+    Direct update does not require a WHERE clause
+
+    Later we also ensure that we are only using one table (no sub queries)
+  */
+  if ((table->file->ha_table_flags() & HA_CAN_DIRECT_UPDATE_AND_DELETE) &&
+      !has_triggers && !binlog_is_row &&
+      !query_plan.using_io_buffer && !ignore &&
+      !table->check_virtual_columns_marked_for_read() &&
+      !table->check_virtual_columns_marked_for_write())
+  {
+    DBUG_PRINT("info", ("Trying direct update"));
+    if (select && select->cond &&
+        (select->cond->used_tables() == table->map))
+    {
+      DBUG_ASSERT(!table->file->pushed_cond);
+      if (!table->file->cond_push(select->cond))
+        table->file->pushed_cond= select->cond;
+    }
+
+    if (!table->file->info_push(INFO_KIND_UPDATE_FIELDS, &fields) &&
+        !table->file->info_push(INFO_KIND_UPDATE_VALUES, &values) &&
+        !table->file->direct_update_rows_init())
+    {
+      do_direct_update= TRUE;
+
+      /* Direct update is not using_filesort and is not using_io_buffer */
+      goto update_begin;
+    }
+  }
+
   if (query_plan.using_filesort || query_plan.using_io_buffer)
   {
     /*
@@ -721,6 +780,7 @@ int mysql_update(THD *thd,
     }
   }
 
+update_begin:
   if (ignore)
     table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
   
@@ -740,11 +800,20 @@ int mysql_update(THD *thd,
 
   transactional_table= table->file->has_transactions();
   thd->abort_on_warning= !ignore && thd->is_strict_mode();
-  if (table->prepare_triggers_for_update_stmt_or_event())
+
+  if (do_direct_update)
   {
-    will_batch= FALSE;
+    /* Direct updating is supported */
+    DBUG_PRINT("info", ("Using direct update"));
+    table->reset_default_fields();
+    if (!(error= table->file->ha_direct_update_rows(&updated)))
+      error= -1;
+    found= updated;
+    goto update_end;
   }
-  else
+
+  if ((table->file->ha_table_flags() & HA_CAN_FORCE_BULK_UPDATE) &&
+      !table->prepare_triggers_for_update_stmt_or_event())
     will_batch= !table->file->start_bulk_update();
 
   /*
@@ -838,6 +907,7 @@ int mysql_update(THD *thd,
             call then it should be included in the count of dup_key_found
             and error should be set to 0 (only if these errors are ignored).
           */
+          DBUG_PRINT("info", ("Batched update"));
           error= table->file->ha_bulk_update_row(table->record[1],
                                                  table->record[0],
                                                  &dup_key_found);
@@ -1002,6 +1072,8 @@ int mysql_update(THD *thd,
     updated-= dup_key_found;
   if (will_batch)
     table->file->end_bulk_update();
+
+update_end:
   table->file->try_semi_consistent_read(0);
 
   if (!transactional_table && updated > 0)
@@ -1060,6 +1132,11 @@ int mysql_update(THD *thd,
   DBUG_ASSERT(transactional_table || !updated || thd->transaction.stmt.modified_non_trans_table);
   free_underlaid_joins(thd, select_lex);
   delete file_sort;
+  if (table->file->pushed_cond)
+  {
+    table->file->pushed_cond= 0;
+    table->file->cond_pop();
+  }
 
   /* If LAST_INSERT_ID(X) was used, report X */
   id= thd->arg_of_last_insert_id_function ?
@@ -1091,7 +1168,6 @@ int mysql_update(THD *thd,
   *found_return= found;
   *updated_return= updated;
   
-  
   if (thd->lex->analyze_stmt)
     goto emit_explain_and_leave;
 
@@ -1102,6 +1178,8 @@ err:
   delete file_sort;
   free_underlaid_joins(thd, select_lex);
   table->file->ha_end_keyread();
+  if (table->file->pushed_cond)
+    table->file->cond_pop();
   thd->abort_on_warning= 0;
   DBUG_RETURN(1);
 
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 551ce4020af..6e34e1974a1 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -896,10 +896,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %parse-param { THD *thd }
 %lex-param { THD *thd }
 /*
-  Currently there are 123 shift/reduce conflicts.
+  Currently there are 125 shift/reduce conflicts.
   We should not introduce new conflicts any more.
 */
-%expect 123
+%expect 125
 
 /*
    Comments for TOKENS.
@@ -1058,6 +1058,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  DEFINER_SYM
 %token  DELAYED_SYM
 %token  DELAY_KEY_WRITE_SYM
+%token  DELETE_DOMAIN_ID_SYM
 %token  DELETE_SYM                    /* SQL-2003-R */
 %token  DENSE_RANK_SYM
 %token  DESC                          /* SQL-2003-N */
@@ -1659,11 +1660,15 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         LEX_HOSTNAME ULONGLONG_NUM field_ident select_alias ident_or_text
         IDENT_sys TEXT_STRING_sys TEXT_STRING_literal
         opt_component key_cache_name
-        sp_opt_label BIN_NUM label_ident TEXT_STRING_filesystem ident_or_empty
-        opt_constraint constraint opt_ident
+        sp_opt_label BIN_NUM TEXT_STRING_filesystem ident_or_empty
+        opt_constraint constraint opt_ident ident_table_alias
         sp_decl_ident
         sp_block_label opt_place opt_db
 
+%type <lex_str>
+        label_ident
+        sp_label
+
 %type <lex_string_with_metadata>
         TEXT_STRING
         NCHAR_STRING
@@ -1711,7 +1716,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <num>
         order_dir lock_option
         udf_type opt_local opt_no_write_to_binlog
-        opt_temporary all_or_any opt_distinct
+        opt_temporary all_or_any opt_distinct opt_glimit_clause
         opt_ignore_leaves fulltext_options union_option
         opt_not
         select_derived_init transaction_access_mode_types
@@ -1804,6 +1809,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <assignment_lex>
         assignment_source_lex
         assignment_source_expr
+        for_loop_bound_expr
 
 %type <sp_assignment_lex_list>
         cursor_actual_parameters
@@ -1850,7 +1856,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <Lex_length_and_dec> precision opt_precision float_options
 
-%type <symbol> keyword keyword_sp
+%type <symbol> keyword keyword_sp keyword_alias
                keyword_sp_data_type
                keyword_sp_not_data_type
 
@@ -1942,7 +1948,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         opt_field_or_var_spec fields_or_vars opt_load_data_set_spec
         view_list_opt view_list view_select
         trigger_tail sp_tail sf_tail event_tail
-        udf_tail create_function_tail
+        udf_tail create_function_tail create_aggregate_function_tail
         install uninstall partition_entry binlog_base64_event
         normal_key_options normal_key_opts all_key_opt 
         spatial_key_options fulltext_key_options normal_key_opt 
@@ -1956,7 +1962,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         parse_vcol_expr vcol_opt_specifier vcol_opt_attribute
         vcol_opt_attribute_list vcol_attribute
         opt_serial_attribute opt_serial_attribute_list serial_attribute
-        explainable_command opt_lock_wait_timeout asrow_attribute
+        explainable_command
+	opt_lock_wait_timeout
+        opt_delete_gtid_domain
+	asrow_attribute
 END_OF_INPUT
 
 %type <NONE> call sp_proc_stmts sp_proc_stmts1 sp_proc_stmt
@@ -1982,6 +1991,9 @@ END_OF_INPUT
 %type <spblock> sp_decls sp_decl sp_decl_body sp_decl_variable_list
 %type <spname> sp_name
 %type <spvar> sp_param_name sp_param_name_and_type
+%type <for_loop> sp_for_loop_index_and_bounds
+%type <for_loop_bounds> sp_for_loop_bounds
+%type <num> opt_sp_for_loop_direction
 %type <spvar_mode> sp_opt_inout
 %type <index_hint> index_hint_type
 %type <num> index_hint_clause normal_join inner_join
@@ -2667,8 +2679,16 @@ create:
           event_tail
           { }
         | create_or_replace definer FUNCTION_SYM
-          { Lex->create_info.set($1); }
-          sf_tail
+          {
+            Lex->create_info.set($1);
+          }
+          sf_tail_not_aggregate
+          { }
+        | create_or_replace definer AGGREGATE_SYM FUNCTION_SYM
+          {
+            Lex->create_info.set($1);
+          }
+          sf_tail_aggregate
           { }
         | create_or_replace no_definer FUNCTION_SYM
           { Lex->create_info.set($1); }
@@ -2677,9 +2697,8 @@ create:
         | create_or_replace no_definer AGGREGATE_SYM FUNCTION_SYM
           {
             Lex->create_info.set($1);
-            Lex->udf.type= UDFTYPE_AGGREGATE;
           }
-          udf_tail
+          create_aggregate_function_tail
           { }
         | create_or_replace USER_SYM opt_if_not_exists clear_privileges grant_list
           opt_require_clause opt_resource_options
@@ -2706,11 +2725,36 @@ create:
           { }
         ;
 
+sf_tail_not_aggregate:
+        sf_tail
+        {
+          if (Lex->sphead->m_flags & sp_head::HAS_AGGREGATE_INSTR)
+          {
+            my_yyabort_error((ER_NOT_AGGREGATE_FUNCTION, MYF(0), ""));
+          }
+          Lex->sphead->set_chistics_agg_type(NOT_AGGREGATE);
+        }
+
+sf_tail_aggregate:
+        sf_tail
+        {
+          if (!(Lex->sphead->m_flags & sp_head::HAS_AGGREGATE_INSTR))
+          {
+            my_yyabort_error((ER_INVALID_AGGREGATE_FUNCTION, MYF(0), ""));
+          }
+          Lex->sphead->set_chistics_agg_type(GROUP_AGGREGATE);
+        }
+
 create_function_tail:
-          sf_tail { }
+          sf_tail_not_aggregate { }
         | udf_tail { Lex->udf.type= UDFTYPE_FUNCTION; }
         ;
 
+create_aggregate_function_tail:
+          sf_tail_aggregate
+          { }
+        | udf_tail { Lex->udf.type= UDFTYPE_AGGREGATE; }
+        ;
 opt_sequence:
          /* empty */ { }
         | sequence_defs
@@ -3978,6 +4022,22 @@ assignment_source_expr:
           }
         ;
 
+for_loop_bound_expr:
+          assignment_source_lex
+          {
+            Lex->sphead->reset_lex(thd, $1);
+          }
+          expr
+          {
+            DBUG_ASSERT($1 == thd->lex);
+            $$= $1;
+            $$->sp_lex_in_use= true;
+            $$->set_item_and_free_list($3, NULL);
+            if ($$->sphead->restore_lex(thd))
+              MYSQL_YYABORT;
+          }
+        ;
+
 cursor_actual_parameters:
           assignment_source_expr
           {
@@ -4024,7 +4084,19 @@ sp_proc_stmt_fetch_head:
         ;
 
 sp_proc_stmt_fetch:
-          sp_proc_stmt_fetch_head sp_fetch_list { }
+         sp_proc_stmt_fetch_head sp_fetch_list { }
+       | FETCH_SYM GROUP_SYM NEXT_SYM ROW_SYM
+         {
+            LEX *lex= Lex;
+            sp_head *sp= lex->sphead;
+            lex->sphead->m_flags|= sp_head::HAS_AGGREGATE_INSTR;
+            sp_instr_agg_cfetch *i=
+              new (thd->mem_root) sp_instr_agg_cfetch(sp->instructions(),
+                                                      lex->spcont);
+            if (i == NULL ||
+                sp->add_instr(i))
+              MYSQL_YYABORT;
+         }
         ;
 
 sp_proc_stmt_close:
@@ -4277,13 +4349,17 @@ else_clause_opt:
         | ELSE sp_proc_stmts1
         ;
 
+sp_label:
+          label_ident ':' { $$= $1; }
+        ;
+
 sp_opt_label:
           /* Empty  */  { $$= null_clex_str; }
         | label_ident   { $$= $1; }
         ;
 
 sp_block_label:
-          label_ident ':'
+          sp_label
           {
             if (Lex->spcont->block_label_declare(&$1))
               MYSQL_YYABORT;
@@ -4337,6 +4413,43 @@ sp_unlabeled_block_not_atomic:
           }
         ;
 
+/* This adds one shift/reduce conflict */
+opt_sp_for_loop_direction:
+            /* Empty */ { $$= 1; }
+          | REVERSE_SYM { $$= -1; }
+        ;
+
+sp_for_loop_index_and_bounds:
+          ident sp_for_loop_bounds
+          {
+            if (Lex->sp_for_loop_declarations(thd, &$$, &$1, $2))
+              MYSQL_YYABORT;
+          }
+        ;
+
+sp_for_loop_bounds:
+          IN_SYM opt_sp_for_loop_direction for_loop_bound_expr
+          DOT_DOT_SYM for_loop_bound_expr
+          {
+            $$.m_direction= $2;
+            $$.m_index= $3;
+            $$.m_upper_bound= $5;
+            $$.m_implicit_cursor= false;
+          }
+        | IN_SYM opt_sp_for_loop_direction for_loop_bound_expr
+          {
+            $$.m_direction= $2;
+            $$.m_index= $3;
+            $$.m_upper_bound= NULL;
+            $$.m_implicit_cursor= false;
+          }
+        | IN_SYM opt_sp_for_loop_direction '(' sp_cursor_stmt ')'
+          {
+            if (Lex->sp_for_loop_implicit_cursor_statement(thd, &$$, $4))
+              MYSQL_YYABORT;
+          }
+        ;
+
 loop_body:
           sp_proc_stmts1 END LOOP_SYM
           {
@@ -4396,14 +4509,14 @@ pop_sp_loop_label:
         ;
 
 sp_labeled_control:
-          label_ident ':' LOOP_SYM
+          sp_label LOOP_SYM
           {
             if (Lex->sp_push_loop_label(thd, &$1))
               MYSQL_YYABORT;
           }
           loop_body pop_sp_loop_label
           { }
-        | label_ident ':' WHILE_SYM
+        | sp_label WHILE_SYM
           {
             if (Lex->sp_push_loop_label(thd, &$1))
               MYSQL_YYABORT;
@@ -4411,7 +4524,33 @@ sp_labeled_control:
           }
           while_body pop_sp_loop_label
           { }
-        | label_ident ':' REPEAT_SYM
+        | sp_label FOR_SYM
+          {
+            // See "The FOR LOOP statement" comments in sql_lex.cc
+            Lex->sp_block_init(thd); // The outer DECLARE..BEGIN..END block
+          }
+          sp_for_loop_index_and_bounds
+          {
+            if (Lex->sp_push_loop_label(thd, &$1)) // The inner WHILE block
+              MYSQL_YYABORT;
+            if (Lex->sp_for_loop_condition_test(thd, $4))
+              MYSQL_YYABORT;
+          }
+          DO_SYM
+          sp_proc_stmts1
+          END FOR_SYM
+          {
+            if (Lex->sp_for_loop_finalize(thd, $4))
+              MYSQL_YYABORT;
+          }
+          pop_sp_loop_label                    // The inner WHILE block
+          {
+            Lex_spblock tmp;
+            tmp.curs= MY_TEST($4.m_implicit_cursor);
+            if (Lex->sp_block_finalize(thd, tmp)) // The outer DECLARE..BEGIN..END
+              MYSQL_YYABORT;
+          }
+        | sp_label REPEAT_SYM
           {
             if (Lex->sp_push_loop_label(thd, &$1))
               MYSQL_YYABORT;
@@ -4440,6 +4579,32 @@ sp_unlabeled_control:
           {
             Lex->sp_pop_loop_empty_label(thd);
           }
+        | FOR_SYM
+          {
+            // See "The FOR LOOP statement" comments in sql_lex.cc
+            if (Lex->maybe_start_compound_statement(thd))
+              MYSQL_YYABORT;
+            Lex->sp_block_init(thd); // The outer DECLARE..BEGIN..END block
+          }
+          sp_for_loop_index_and_bounds
+          {
+            if (Lex->sp_push_loop_empty_label(thd)) // The inner WHILE block
+              MYSQL_YYABORT;
+            if (Lex->sp_for_loop_condition_test(thd, $3))
+              MYSQL_YYABORT;
+          }
+          DO_SYM
+          sp_proc_stmts1
+          END FOR_SYM
+          {
+            Lex_spblock tmp;
+            tmp.curs= MY_TEST($3.m_implicit_cursor);
+            if (Lex->sp_for_loop_finalize(thd, $3))
+              MYSQL_YYABORT;
+            Lex->sp_pop_loop_empty_label(thd); // The inner WHILE block
+            if (Lex->sp_block_finalize(thd, tmp)) // The outer DECLARE..BEGIN..END
+              MYSQL_YYABORT;
+          }
         | REPEAT_SYM
           {
             if (Lex->sp_push_loop_empty_label(thd))
@@ -7602,7 +7767,7 @@ alter:
             Lex->create_info.set($2);
             Lex->sql_command= SQLCOM_ALTER_USER;
           }
-        | ALTER SEQUENCE_SYM opt_if_exists_table_element
+        | ALTER SEQUENCE_SYM opt_if_exists
           {
             LEX *lex= Lex;
             lex->name= null_clex_str;
@@ -7625,7 +7790,7 @@ alter:
           sequence_defs
           {
             /* Create a generic ALTER SEQUENCE statment. */
-            Lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_alter_sequence();
+            Lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_alter_sequence($3);
             if (Lex->m_sql_cmd == NULL)
               MYSQL_YYABORT;
           }
@@ -10931,16 +11096,22 @@ sum_expr:
         | GROUP_CONCAT_SYM '(' opt_distinct
           { Select->in_sum_expr++; }
           expr_list opt_gorder_clause
-          opt_gconcat_separator
+          opt_gconcat_separator opt_glimit_clause
           ')'
           {
             SELECT_LEX *sel= Select;
             sel->in_sum_expr--;
             $$= new (thd->mem_root)
-                  Item_func_group_concat(thd, Lex->current_context(), $3, $5,
-                                         sel->gorder_list, $7);
+                  Item_func_group_concat(thd, Lex->current_context(),
+                                        $3, $5,
+                                        sel->gorder_list, $7, $8,
+                                        sel->select_limit,
+                                        sel->offset_limit);
             if ($$ == NULL)
               MYSQL_YYABORT;
+            sel->select_limit= NULL;
+            sel->offset_limit= NULL;
+            sel->explicit_limit= 0;
             $5->empty();
             sel->gorder_list.empty();
           }
@@ -11230,6 +11401,48 @@ gorder_list:
           { if (add_gorder_to_list(thd, $1,(bool) $2)) MYSQL_YYABORT; }
         ;
 
+opt_glimit_clause:
+          /* empty */ { $$ = 0; }
+        | glimit_clause { $$ = 1; }
+        ;
+
+glimit_clause_init:
+          LIMIT{}
+        ;
+
+glimit_clause:
+          glimit_clause_init glimit_options
+          {
+            Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+          }
+        ;
+
+glimit_options:
+          limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $1;
+            sel->offset_limit= 0;
+            sel->explicit_limit= 1;
+          }
+        | limit_option ',' limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $3;
+            sel->offset_limit= $1;
+            sel->explicit_limit= 1;
+          }
+        | limit_option OFFSET_SYM limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $1;
+            sel->offset_limit= $3;
+            sel->explicit_limit= 1;
+          }
+        ;
+
+
+
 in_sum_expr:
           opt_all
           {
@@ -12005,7 +12218,7 @@ table_alias:
 
 opt_table_alias:
           /* empty */ { $$=0; }
-        | table_alias ident
+        | table_alias ident_table_alias
           {
             $$= (LEX_CSTRING*) thd->memdup(&$2,sizeof(LEX_STRING));
             if ($$ == NULL)
@@ -13993,7 +14206,7 @@ flush_option:
           { Lex->type|= REFRESH_GENERAL_LOG; }
         | SLOW LOGS_SYM
           { Lex->type|= REFRESH_SLOW_LOG; }
-        | BINARY LOGS_SYM
+        | BINARY LOGS_SYM opt_delete_gtid_domain
           { Lex->type|= REFRESH_BINARY_LOG; }
         | RELAY LOGS_SYM optional_connection_name
           {
@@ -14050,6 +14263,24 @@ opt_table_list:
         | table_list {}
         ;
 
+opt_delete_gtid_domain:
+          /* empty */ {}
+        | DELETE_DOMAIN_ID_SYM '=' '(' delete_domain_id_list ')'
+          {}
+        ;
+delete_domain_id_list:
+          /* Empty */
+        | delete_domain_id
+        | delete_domain_id_list ',' delete_domain_id
+        ;
+
+delete_domain_id:
+          ulong_num
+          {
+            insert_dynamic(&Lex->delete_gtid_domain, (uchar*) &($1));
+          }
+        ;
+
 optional_flush_tables_arguments:
           /* empty */        {$$= 0;}
         | AND_SYM DISABLE_SYM CHECKPOINT_SYM {$$= REFRESH_CHECKPOINT; } 
@@ -14934,6 +15165,16 @@ TEXT_STRING_filesystem:
 	      $$.length= to.length;
             }
           }
+
+ident_table_alias:
+          IDENT_sys   { $$= $1; }
+        | keyword_alias
+          {
+            $$.str= thd->strmake($1.str, $1.length);
+            if ($$.str == NULL)
+              MYSQL_YYABORT;
+            $$.length= $1.length;
+          }
         ;
 
 ident:
@@ -15048,8 +15289,8 @@ user: user_maybe_role
          }
          ;
 
-/* Keyword that we allow for identifiers (except SP labels) */
-keyword:
+/* Keywords which we allow as table aliases. */
+keyword_alias:
           keyword_sp            {}
         | keyword_sp_verb_clause{}
         | ASCII_SYM             {}
@@ -15114,6 +15355,10 @@ keyword:
         | UPGRADE_SYM           {}
         ;
 
+
+/* Keyword that we allow for identifiers (except SP labels) */
+keyword: keyword_alias | WINDOW_SYM {};
+
 /*
  * Keywords that we allow for labels in SPs.
  * Anything that's the beginning of a statement or characteristics
diff --git a/sql/sql_yacc_ora.yy b/sql/sql_yacc_ora.yy
index 945f2e33028..3ea1dc25595 100644
--- a/sql/sql_yacc_ora.yy
+++ b/sql/sql_yacc_ora.yy
@@ -436,6 +436,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  DEFINER_SYM
 %token  DELAYED_SYM
 %token  DELAY_KEY_WRITE_SYM
+%token  DELETE_DOMAIN_ID_SYM
 %token  DELETE_SYM                    /* SQL-2003-R */
 %token  DENSE_RANK_SYM
 %token  DESC                          /* SQL-2003-N */
@@ -1037,13 +1038,17 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         LEX_HOSTNAME ULONGLONG_NUM field_ident select_alias ident_or_text
         IDENT_sys TEXT_STRING_sys TEXT_STRING_literal
         opt_component key_cache_name
-        sp_opt_label BIN_NUM label_ident TEXT_STRING_filesystem ident_or_empty
+        sp_opt_label BIN_NUM TEXT_STRING_filesystem ident_or_empty
         opt_constraint constraint opt_ident
-        label_declaration_oracle labels_declaration_oracle
         ident_directly_assignable
         sp_decl_ident
         sp_block_label opt_place opt_db
 
+%type <lex_str>
+        label_ident
+        label_declaration_oracle
+        labels_declaration_oracle
+
 %type <lex_string_with_metadata>
         TEXT_STRING
         NCHAR_STRING
@@ -1094,7 +1099,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <num>
         order_dir lock_option
         udf_type opt_local opt_no_write_to_binlog
-        opt_temporary all_or_any opt_distinct
+        opt_temporary all_or_any opt_distinct opt_glimit_clause
         opt_ignore_leaves fulltext_options union_option
         opt_not
         select_derived_init transaction_access_mode_types
@@ -4097,25 +4102,8 @@ sp_for_loop_bounds:
           }
         | IN_SYM opt_sp_for_loop_direction '(' sp_cursor_stmt ')'
           {
-            Item *item;
-            DBUG_ASSERT(Lex->sphead);
-            LEX_CSTRING name= {STRING_WITH_LEN("[implicit_cursor]") };
-            if (Lex->sp_declare_cursor(thd, &name, $4, NULL, true))
+            if (Lex->sp_for_loop_implicit_cursor_statement(thd, &$$, $4))
               MYSQL_YYABORT;
-            if (!($$.m_index= new (thd->mem_root) sp_assignment_lex(thd, thd->lex)))
-              MYSQL_YYABORT;
-            $$.m_index->sp_lex_in_use= true;
-            Lex->sphead->reset_lex(thd, $$.m_index);
-            if (!(item= new (thd->mem_root) Item_field(thd,
-                                                       Lex->current_context(),
-                                                       NullS, NullS, &name)))
-              MYSQL_YYABORT;
-            $$.m_index->set_item_and_free_list(item, NULL);
-            if (Lex->sphead->restore_lex(thd))
-              MYSQL_YYABORT;
-            $$.m_direction= 1;
-            $$.m_upper_bound= NULL;
-            $$.m_implicit_cursor= true;
           }
         ;
 
@@ -7325,7 +7313,7 @@ alter:
             Lex->create_info.set($2);
             Lex->sql_command= SQLCOM_ALTER_USER;
           }
-        | ALTER SEQUENCE_SYM opt_if_exists_table_element
+        | ALTER SEQUENCE_SYM opt_if_exists
           {
             LEX *lex= Lex;
             lex->name= null_clex_str;
@@ -7348,7 +7336,7 @@ alter:
           sequence_defs
           {
             /* Create a generic ALTER SEQUENCE statment. */
-            Lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_alter_sequence();
+            Lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_alter_sequence($3);
             if (Lex->m_sql_cmd == NULL)
               MYSQL_YYABORT;
           }
@@ -10590,16 +10578,22 @@ sum_expr:
         | GROUP_CONCAT_SYM '(' opt_distinct
           { Select->in_sum_expr++; }
           expr_list opt_gorder_clause
-          opt_gconcat_separator
+          opt_gconcat_separator opt_glimit_clause
           ')'
           {
             SELECT_LEX *sel= Select;
             sel->in_sum_expr--;
             $$= new (thd->mem_root)
-                  Item_func_group_concat(thd, Lex->current_context(), $3, $5,
-                                         sel->gorder_list, $7);
+                  Item_func_group_concat(thd, Lex->current_context(),
+                                        $3, $5,
+                                        sel->gorder_list, $7, $8,
+                                        sel->select_limit,
+                                        sel->offset_limit);
             if ($$ == NULL)
               MYSQL_YYABORT;
+            sel->select_limit= NULL;
+            sel->offset_limit= NULL;
+            sel->explicit_limit= 0;
             $5->empty();
             sel->gorder_list.empty();
           }
@@ -10885,6 +10879,46 @@ gorder_list:
           { if (add_gorder_to_list(thd, $1,(bool) $2)) MYSQL_YYABORT; }
         ;
 
+opt_glimit_clause:
+          /* empty */ { $$ = 0; }
+        | glimit_clause { $$ = 1; }
+        ;
+
+glimit_clause_init:
+          LIMIT{}
+        ;
+
+glimit_clause:
+          glimit_clause_init glimit_options
+          {
+            Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+          }
+        ;
+
+glimit_options:
+          limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $1;
+            sel->offset_limit= 0;
+            sel->explicit_limit= 1;
+          }
+        | limit_option ',' limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $3;
+            sel->offset_limit= $1;
+            sel->explicit_limit= 1;
+          }
+        | limit_option OFFSET_SYM limit_option
+          {
+            SELECT_LEX *sel= Select;
+            sel->select_limit= $1;
+            sel->offset_limit= $3;
+            sel->explicit_limit= 1;
+          }
+        ;
+
 in_sum_expr:
           opt_all
           {
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index a30d202db63..adef93ef205 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -622,8 +622,7 @@ static Sys_var_mybool Sys_explicit_defaults_for_timestamp(
        "explicit_defaults_for_timestamp",
        "This option causes CREATE TABLE to create all TIMESTAMP columns "
        "as NULL with DEFAULT NULL attribute, Without this option, "
-       "TIMESTAMP columns are NOT NULL and have implicit DEFAULT clauses. "
-       "The old behavior is deprecated.",
+       "TIMESTAMP columns are NOT NULL and have implicit DEFAULT clauses.",
        READ_ONLY GLOBAL_VAR(opt_explicit_defaults_for_timestamp),
        CMD_LINE(OPT_ARG), DEFAULT(FALSE), NO_MUTEX_GUARD, NOT_IN_BINLOG);
 
@@ -4922,6 +4921,14 @@ static Sys_var_ulonglong Sys_read_binlog_speed_limit(
        GLOBAL_VAR(opt_read_binlog_speed_limit), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(0, ULONG_MAX), DEFAULT(0), BLOCK_SIZE(1));
 
+static Sys_var_charptr Sys_slave_transaction_retry_errors(
+       "slave_transaction_retry_errors", "Tells the slave thread to retry "
+       "transaction for replication when a query event returns an error from "
+       "the provided list. Deadlock and elapsed lock wait timeout errors are "
+       "automatically added to this list",
+       READ_ONLY GLOBAL_VAR(opt_slave_transaction_retry_errors), CMD_LINE(REQUIRED_ARG),
+       IN_SYSTEM_CHARSET, DEFAULT(0));
+
 static Sys_var_ulonglong Sys_relay_log_space_limit(
        "relay_log_space_limit", "Maximum space to use for all relay logs",
        READ_ONLY GLOBAL_VAR(relay_log_space_limit), CMD_LINE(REQUIRED_ARG),
@@ -4956,10 +4963,19 @@ static Sys_var_uint Sys_sync_masterinfo_period(
 #ifdef HAVE_REPLICATION
 static Sys_var_ulong Sys_slave_trans_retries(
        "slave_transaction_retries", "Number of times the slave SQL "
-       "thread will retry a transaction in case it failed with a deadlock "
-       "or elapsed lock wait timeout, before giving up and stopping",
+       "thread will retry a transaction in case it failed with a deadlock, "
+       "elapsed lock wait timeout or listed in "
+       "slave_transaction_retry_errors, before giving up and stopping",
        GLOBAL_VAR(slave_trans_retries), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(0, UINT_MAX), DEFAULT(10), BLOCK_SIZE(1));
+
+static Sys_var_ulong Sys_slave_trans_retry_interval(
+       "slave_transaction_retry_interval", "Interval of the slave SQL "
+       "thread will retry a transaction in case it failed with a deadlock "
+       "or elapsed lock wait timeout or listed in "
+       "slave_transaction_retry_errors",
+       GLOBAL_VAR(slave_trans_retry_interval), CMD_LINE(REQUIRED_ARG),
+       VALID_RANGE(0, 3600), DEFAULT(0), BLOCK_SIZE(1));
 #endif
 
 static bool check_locale(sys_var *self, THD *thd, set_var *var)
@@ -5415,7 +5431,9 @@ static Sys_var_enum Sys_plugin_maturity(
        "The lowest desirable plugin maturity. "
        "Plugins less mature than that will not be installed or loaded",
        READ_ONLY GLOBAL_VAR(plugin_maturity), CMD_LINE(REQUIRED_ARG),
-       plugin_maturity_names, DEFAULT(MariaDB_PLUGIN_MATURITY_UNKNOWN));
+       plugin_maturity_names,
+       DEFAULT(SERVER_MATURITY_LEVEL > 0 ?
+               SERVER_MATURITY_LEVEL - 1 : SERVER_MATURITY_LEVEL));
 
 static Sys_var_ulong Sys_deadlock_search_depth_short(
        "deadlock_search_depth_short",
diff --git a/sql/table.cc b/sql/table.cc
index a421697e341..72acfc5a9ee 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -6781,6 +6781,58 @@ bool TABLE::mark_virtual_columns_for_write(bool insert_fl)
   DBUG_RETURN(bitmap_updated);
 }
 
+
+/**
+   Check if a virtual not stored column field is in read set
+
+   @retval FALSE  No virtual not stored column is used
+   @retval TRUE   At least one virtual not stored column is used
+*/
+
+bool TABLE::check_virtual_columns_marked_for_read()
+{
+  if (vfield)
+  {
+    Field **vfield_ptr;
+    for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+    {
+      Field *tmp_vfield= *vfield_ptr;
+      if (bitmap_is_set(read_set, tmp_vfield->field_index) &&
+          !tmp_vfield->vcol_info->stored_in_db)
+        return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+
+/**
+   Check if a stored virtual column field is marked for write
+
+   This can be used to check if any column that is part of a virtual
+   stored column is changed
+
+   @retval FALSE  No stored virtual column is used
+   @retval TRUE   At least one stored virtual column is used
+*/
+
+bool TABLE::check_virtual_columns_marked_for_write()
+{
+  if (vfield)
+  {
+    Field **vfield_ptr;
+    for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+    {
+      Field *tmp_vfield= *vfield_ptr;
+      if (bitmap_is_set(write_set, tmp_vfield->field_index) &&
+                        tmp_vfield->vcol_info->stored_in_db)
+        return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+
 /*
   Mark fields used by check constraints.
   This is done once for the TABLE_SHARE the first time the table is opened.
@@ -6838,6 +6890,7 @@ void TABLE::mark_default_fields_for_write(bool is_insert)
   DBUG_VOID_RETURN;
 }
 
+
 void TABLE::move_fields(Field **ptr, const uchar *to, const uchar *from)
 {
   my_ptrdiff_t diff= to - from;
diff --git a/sql/table.h b/sql/table.h
index 45505efc9dd..1dad990edab 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -1371,6 +1371,8 @@ public:
   void mark_columns_per_binlog_row_image(void);
   bool mark_virtual_col(Field *field);
   bool mark_virtual_columns_for_write(bool insert_fl);
+  bool check_virtual_columns_marked_for_read();
+  bool check_virtual_columns_marked_for_write();
   void mark_default_fields_for_write(bool insert_fl);
   void mark_columns_used_by_check_constraints(void);
   void mark_check_constraint_columns_for_read(void);
diff --git a/sql/threadpool_generic.cc b/sql/threadpool_generic.cc
index 3fdaff0504f..4ff6d5f2cfb 100644
--- a/sql/threadpool_generic.cc
+++ b/sql/threadpool_generic.cc
@@ -28,11 +28,19 @@
 #endif
 
 #ifdef HAVE_IOCP
-#define OPTIONAL_IO_POLL_READ_PARAM &overlapped
+#define OPTIONAL_IO_POLL_READ_PARAM this
 #else 
 #define OPTIONAL_IO_POLL_READ_PARAM 0
 #endif
 
+#ifdef _WIN32
+typedef HANDLE TP_file_handle;
+#else
+typedef int TP_file_handle;
+#define  INVALID_HANDLE_VALUE -1
+#endif
+
+
 #include <sql_connect.h>
 #include <mysqld.h>
 #include <debug_sync.h>
@@ -59,10 +67,10 @@ typedef OVERLAPPED_ENTRY native_event;
 #pragma warning (disable : 4312)
 #endif
 
-static void io_poll_close(int fd)
+static void io_poll_close(TP_file_handle fd)
 {
 #ifdef _WIN32
-  CloseHandle((HANDLE)fd);
+  CloseHandle(fd);
 #else
   close(fd);
 #endif
@@ -151,14 +159,17 @@ struct TP_connection_generic:public TP_connection
   TP_connection_generic **prev_in_queue;
   ulonglong abs_wait_timeout;
   ulonglong dequeue_time;
+  TP_file_handle fd;
   bool bound_to_poll_descriptor;
   int waiting;
 #ifdef HAVE_IOCP
   OVERLAPPED overlapped;
 #endif
+#ifdef _WIN32
+  enum_vio_type vio_type;
+#endif
 };
 
-typedef TP_connection_generic TP_connection_generic;
 
 typedef I_P_List<TP_connection_generic,
                      I_P_List_adapter<TP_connection_generic,
@@ -177,7 +188,7 @@ struct thread_group_t
   worker_list_t waiting_threads; 
   worker_thread_t *listener;
   pthread_attr_t *pthread_attr;
-  int  pollfd;
+  TP_file_handle  pollfd;
   int  thread_count;
   int  active_thread_count;
   int  connection_count;
@@ -245,11 +256,11 @@ static void print_pool_blocked_message(bool);
  Creates an io_poll descriptor 
  On Linux: epoll_create()
  
- - io_poll_associate_fd(int poll_fd, int fd, void *data, void *opt)
+ - io_poll_associate_fd(int poll_fd, TP_file_handle fd, void *data, void *opt)
  Associate file descriptor with io poll descriptor 
  On Linux : epoll_ctl(..EPOLL_CTL_ADD))
  
- - io_poll_disassociate_fd(int pollfd, int fd)
+ - io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
   Associate file descriptor with io poll descriptor 
   On Linux: epoll_ctl(..EPOLL_CTL_DEL)
  
@@ -259,7 +270,7 @@ static void print_pool_blocked_message(bool);
  io_poll_associate_fd() was called.
  On Linux : epoll_ctl(..EPOLL_CTL_MOD)
  
- - io_poll_wait (int pollfd, native_event *native_events, int maxevents, 
+ - io_poll_wait (TP_file_handle pollfd, native_event *native_events, int maxevents, 
    int timeout_ms)
  
  wait until one or more descriptors added with io_poll_associate_fd() 
@@ -276,13 +287,13 @@ static void print_pool_blocked_message(bool);
 /* Early 2.6 kernel did not have EPOLLRDHUP */
 #define EPOLLRDHUP 0
 #endif
-static int io_poll_create()
+static TP_file_handle io_poll_create()
 {
   return epoll_create(1);
 }
 
 
-int io_poll_associate_fd(int pollfd, int fd, void *data, void*)
+int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data, void*)
 {
   struct epoll_event ev;
   ev.data.u64= 0; /* Keep valgrind happy */
@@ -293,7 +304,7 @@ int io_poll_associate_fd(int pollfd, int fd, void *data, void*)
 
 
 
-int io_poll_start_read(int pollfd, int fd, void *data, void *)
+int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *data, void *)
 {
   struct epoll_event ev;
   ev.data.u64= 0; /* Keep valgrind happy */
@@ -302,7 +313,7 @@ int io_poll_start_read(int pollfd, int fd, void *data, void *)
   return epoll_ctl(pollfd, EPOLL_CTL_MOD,  fd, &ev); 
 }
 
-int io_poll_disassociate_fd(int pollfd, int fd)
+int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
 {
   struct epoll_event ev;
   return epoll_ctl(pollfd, EPOLL_CTL_DEL,  fd, &ev);
@@ -314,7 +325,7 @@ int io_poll_disassociate_fd(int pollfd, int fd)
  NOTE - in case of EINTR, it restarts with original timeout. Since we use
  either infinite or 0 timeouts, this is not critical
 */
-int io_poll_wait(int pollfd, native_event *native_events, int maxevents, 
+int io_poll_wait(TP_file_handle pollfd, native_event *native_events, int maxevents, 
               int timeout_ms)
 {
   int ret;
@@ -347,12 +358,12 @@ static void *native_event_get_userdata(native_event *event)
 #endif
 
 
-int io_poll_create()
+TP_file_handle io_poll_create()
 {
   return kqueue();
 }
 
-int io_poll_start_read(int pollfd, int fd, void *data,void *)
+int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *data,void *)
 {
   struct kevent ke;
   MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT, 
@@ -361,7 +372,7 @@ int io_poll_start_read(int pollfd, int fd, void *data,void *)
 }
 
 
-int io_poll_associate_fd(int pollfd, int fd, void *data,void *)
+int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data,void *)
 {
   struct kevent ke;
   MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT, 
@@ -370,7 +381,7 @@ int io_poll_associate_fd(int pollfd, int fd, void *data,void *)
 }
 
 
-int io_poll_disassociate_fd(int pollfd, int fd)
+int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
 {
   struct kevent ke;
   MY_EV_SET(&ke,fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
@@ -378,7 +389,7 @@ int io_poll_disassociate_fd(int pollfd, int fd)
 }
 
 
-int io_poll_wait(int pollfd, struct kevent *events, int maxevents, int timeout_ms)
+int io_poll_wait(TP_file_handle pollfd, struct kevent *events, int maxevents, int timeout_ms)
 {
   struct timespec ts;
   int ret;
@@ -403,27 +414,27 @@ static void* native_event_get_userdata(native_event *event)
 
 #elif defined (__sun)
 
-static int io_poll_create()
+static TP_file_handle io_poll_create()
 {
   return port_create();
 }
 
-int io_poll_start_read(int pollfd, int fd, void *data, void *)
+int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *data, void *)
 {
   return port_associate(pollfd, PORT_SOURCE_FD, fd, POLLIN, data);
 }
 
-static int io_poll_associate_fd(int pollfd, int fd, void *data, void *)
+static int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data, void *)
 {
   return io_poll_start_read(pollfd, fd, data, 0);
 }
 
-int io_poll_disassociate_fd(int pollfd, int fd)
+int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
 {
   return port_dissociate(pollfd, PORT_SOURCE_FD, fd);
 }
 
-int io_poll_wait(int pollfd, native_event *events, int maxevents, int timeout_ms)
+int io_poll_wait(TP_file_handle pollfd, native_event *events, int maxevents, int timeout_ms)
 {
   struct timespec ts;
   int ret;
@@ -451,25 +462,32 @@ static void* native_event_get_userdata(native_event *event)
 #elif defined(HAVE_IOCP)
 
 
-static int io_poll_create()
+static TP_file_handle io_poll_create()
 {
-  HANDLE h= CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
-  return PtrToInt(h);
+  return CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
 }
 
 
-int io_poll_start_read(int pollfd, int fd, void *, void *opt)
+int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *, void *opt)
 {
-  DWORD num_bytes = 0;
   static char c;
+  TP_connection_generic *con= (TP_connection_generic *)opt;
+  OVERLAPPED *overlapped= &con->overlapped;
+  if (con->vio_type == VIO_TYPE_NAMEDPIPE)
+  {
+    if (ReadFile(fd, &c, 0, NULL, overlapped))
+      return 0;
+  }
+  else
+  {
+    WSABUF buf;
+    buf.buf= &c;
+    buf.len= 0;
+    DWORD flags=0;
 
-  WSABUF buf;
-  buf.buf= &c;
-  buf.len= 0;
-  DWORD flags=0;
-  
-  if (WSARecv((SOCKET)fd, &buf, 1, &num_bytes, &flags, (OVERLAPPED *)opt, NULL) == 0)
-    return 0;
+    if (WSARecv((SOCKET)fd, &buf, 1,NULL, &flags,overlapped, NULL) == 0)
+      return 0;
+  }
 
   if (GetLastError() == ERROR_IO_PENDING)
     return 0;
@@ -478,26 +496,26 @@ int io_poll_start_read(int pollfd, int fd, void *, void *opt)
 }
 
 
-static int io_poll_associate_fd(int pollfd, int fd, void *data, void *opt)
+static int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data, void *opt)
 {
-  HANDLE h= CreateIoCompletionPort(IntToPtr(fd), IntToPtr(pollfd), (ULONG_PTR)data, 0);
+  HANDLE h= CreateIoCompletionPort(fd, pollfd, (ULONG_PTR)data, 0);
   if (!h) 
     return -1;
   return io_poll_start_read(pollfd,fd, 0, opt); 
 }
 
 
-int io_poll_disassociate_fd(int pollfd, int fd)
+int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
 {
   /* Not possible to unbind/rebind file descriptor in IOCP. */
   return 0;
 }
 
 
-int io_poll_wait(int pollfd, native_event *events, int maxevents, int timeout_ms)
+int io_poll_wait(TP_file_handle pollfd, native_event *events, int maxevents, int timeout_ms)
 {
   ULONG n;
-  BOOL ok = GetQueuedCompletionStatusEx((HANDLE)pollfd, events, 
+  BOOL ok = GetQueuedCompletionStatusEx(pollfd, events, 
      maxevents, &n, timeout_ms, FALSE);
  
   return ok ? (int)n : -1;
@@ -1038,7 +1056,7 @@ int thread_group_init(thread_group_t *thread_group, pthread_attr_t* thread_attr)
   DBUG_ENTER("thread_group_init");
   thread_group->pthread_attr = thread_attr;
   mysql_mutex_init(key_group_mutex, &thread_group->mutex, NULL);
-  thread_group->pollfd= -1;
+  thread_group->pollfd= INVALID_HANDLE_VALUE;
   thread_group->shutdown_pipe[0]= -1;
   thread_group->shutdown_pipe[1]= -1;
   queue_init(thread_group);
@@ -1049,10 +1067,10 @@ int thread_group_init(thread_group_t *thread_group, pthread_attr_t* thread_attr)
 void thread_group_destroy(thread_group_t *thread_group)
 {
   mysql_mutex_destroy(&thread_group->mutex);
-  if (thread_group->pollfd != -1)
+  if (thread_group->pollfd != INVALID_HANDLE_VALUE)
   {
     io_poll_close(thread_group->pollfd);
-    thread_group->pollfd= -1;
+    thread_group->pollfd= INVALID_HANDLE_VALUE;
   }
 #ifndef HAVE_IOCP
   for(int i=0; i < 2; i++)
@@ -1109,7 +1127,7 @@ static int wake_listener(thread_group_t *thread_group)
   if (write(thread_group->shutdown_pipe[1], &c, 1) < 0)
     return -1;
 #else
-  PostQueuedCompletionStatus((HANDLE)thread_group->pollfd, 0, 0, 0);
+  PostQueuedCompletionStatus(thread_group->pollfd, 0, 0, 0);
 #endif
   return 0;
 }
@@ -1432,6 +1450,16 @@ TP_connection_generic::TP_connection_generic(CONNECT *c):
 , overlapped()
 #endif
 {
+  DBUG_ASSERT(c->vio);
+
+#ifdef _WIN32
+  vio_type= c->vio->type;
+  fd= (vio_type == VIO_TYPE_NAMEDPIPE) ?
+    c->vio->hPipe: (TP_file_handle)mysql_socket_getfd(c->vio->mysql_socket);
+#else
+  fd= mysql_socket_getfd(c->vio->mysql_socket);
+#endif
+
   /* Assign connection to a group. */
   thread_group_t *group=
     &all_groups[c->thread_id%group_count];
@@ -1486,7 +1514,6 @@ static int change_group(TP_connection_generic *c,
  thread_group_t *new_group)
 { 
   int ret= 0;
-  int fd= (int)mysql_socket_getfd(c->thd->net.vio->mysql_socket);
 
   DBUG_ASSERT(c->thread_group == old_group);
 
@@ -1494,7 +1521,7 @@ static int change_group(TP_connection_generic *c,
   mysql_mutex_lock(&old_group->mutex);
   if (c->bound_to_poll_descriptor)
   {
-    io_poll_disassociate_fd(old_group->pollfd,fd);
+    io_poll_disassociate_fd(old_group->pollfd,c->fd);
     c->bound_to_poll_descriptor= false;
   }
   c->thread_group->connection_count--;
@@ -1513,9 +1540,7 @@ static int change_group(TP_connection_generic *c,
 
 
 int TP_connection_generic::start_io()
-{ 
-  int fd= (int)mysql_socket_getfd(thd->net.vio->mysql_socket);
-
+{
 #ifndef HAVE_IOCP
   /*
     Usually, connection will stay in the same group for the entire
@@ -1666,10 +1691,10 @@ int TP_pool_generic::set_pool_size(uint size)
   {
     thread_group_t *group= &all_groups[i];
     mysql_mutex_lock(&group->mutex);
-    if (group->pollfd == -1)
+    if (group->pollfd == INVALID_HANDLE_VALUE)
     {
       group->pollfd= io_poll_create();
-      success= (group->pollfd >= 0);
+      success= (group->pollfd != INVALID_HANDLE_VALUE);
       if(!success)
       {
         sql_print_error("io_poll_create() failed, errno=%d\n", errno);
@@ -1707,7 +1732,7 @@ int TP_pool_generic::set_stall_limit(uint limit)
 int TP_pool_generic::get_idle_thread_count()
 {
   int sum=0;
-  for (uint i= 0; i < threadpool_max_size && all_groups[i].pollfd >= 0; i++)
+  for (uint i= 0; i < threadpool_max_size && all_groups[i].pollfd != INVALID_HANDLE_VALUE; i++)
   {
     sum+= (all_groups[i].thread_count - all_groups[i].active_thread_count);
   }
diff --git a/sql/wsrep_hton.cc b/sql/wsrep_hton.cc
index 50ecacd9960..35a0020ef44 100644
--- a/sql/wsrep_hton.cc
+++ b/sql/wsrep_hton.cc
@@ -509,6 +509,9 @@ wsrep_run_wsrep_commit(THD *thd, bool all)
   }
 
   mysql_mutex_lock(&thd->LOCK_wsrep_thd);
+
+  DEBUG_SYNC(thd, "wsrep_after_replication");
+
   switch(rcode) {
   case 0:
     /*
diff --git a/sql/wsrep_mysqld.cc b/sql/wsrep_mysqld.cc
index fd759717aaf..2f41e939ee4 100644
--- a/sql/wsrep_mysqld.cc
+++ b/sql/wsrep_mysqld.cc
@@ -2022,7 +2022,7 @@ static bool abort_replicated(THD *thd)
   bool ret_code= false;
   if (thd->wsrep_query_state== QUERY_COMMITTING)
   {
-    WSREP_DEBUG("aborting replicated trx: %lu", (ulong) thd->real_id);
+    WSREP_DEBUG("aborting replicated trx: %llu", (ulonglong)(thd->real_id));
 
     (void)wsrep_abort_thd(thd, thd, TRUE);
     ret_code= true;
@@ -2739,6 +2739,7 @@ my_bool wsrep_aborting_thd_contains(THD *thd)
 
 void wsrep_aborting_thd_enqueue(THD *thd)
 {
+  mysql_mutex_assert_owner(&LOCK_wsrep_rollback);
   wsrep_aborting_thd_t aborting = (wsrep_aborting_thd_t)
           my_malloc(sizeof(struct wsrep_aborting_thd), MYF(0));
   aborting->aborting_thd  = thd;
diff --git a/sql/wsrep_var.cc b/sql/wsrep_var.cc
index 8107ab12c6b..188fa3e292b 100644
--- a/sql/wsrep_var.cc
+++ b/sql/wsrep_var.cc
@@ -327,8 +327,9 @@ bool wsrep_provider_update (sys_var *self, THD* thd, enum_var_type type)
   if (wsrep_inited == 1)
     wsrep_deinit(false);
 
-  char* tmp= strdup(wsrep_provider); // wsrep_init() rewrites provider 
+  char* tmp= strdup(wsrep_provider); // wsrep_init() rewrites provider
                                      //when fails
+
   if (wsrep_init())
   {
     my_error(ER_CANT_OPEN_LIBRARY, MYF(0), tmp, my_error, "wsrep_init failed");