1 files changed, 45 insertions, 31 deletions

diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index c1ebfe105b6..25fcdfc51fd 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -751,7 +751,7 @@ int QUICK_RANGE_SELECT::init()
   DBUG_ENTER("QUICK_RANGE_SELECT::init");
 
   if (file->inited == handler::NONE)
-    DBUG_RETURN(error= file->ha_index_init(index));
+    DBUG_RETURN(error= file->ha_index_init(index, 1));
   error= 0;
   DBUG_RETURN(0);
 }
@@ -778,9 +778,10 @@ QUICK_RANGE_SELECT::~QUICK_RANGE_SELECT()
       {
         DBUG_PRINT("info", ("Freeing separate handler %p (free=%d)", file,
                             free_file));
-        file->reset();
+        file->ha_reset();
         file->external_lock(current_thd, F_UNLCK);
         file->close();
+        delete file;
       }
     }
     delete_dynamic(&ranges); /* ranges are allocated in alloc */
@@ -916,7 +917,7 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
   {
     DBUG_PRINT("info", ("Reusing handler %p", file));
     if (file->extra(HA_EXTRA_KEYREAD) ||
-        file->extra(HA_EXTRA_RETRIEVE_PRIMARY_KEY) ||
+        file->ha_retrieve_all_pk() ||
         init() || reset())
     {
       DBUG_RETURN(1);
@@ -944,7 +945,7 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
     goto failure;
 
   if (file->extra(HA_EXTRA_KEYREAD) ||
-      file->extra(HA_EXTRA_RETRIEVE_PRIMARY_KEY) ||
+      file->ha_retrieve_all_pk() ||
       init() || reset())
   {
     file->external_lock(thd, F_UNLCK);
@@ -956,6 +957,8 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
   DBUG_RETURN(0);
 
 failure:
+  if (file)
+    delete file;
   file= save_file;
   DBUG_RETURN(1);
 }
@@ -1562,9 +1565,10 @@ static int fill_used_fields_bitmap(PARAM *param)
 {
   TABLE *table= param->table;
   param->fields_bitmap_size= (table->s->fields/8 + 1);
-  uchar *tmp;
+  uint32 *tmp;
   uint pk;
-  if (!(tmp= (uchar*)alloc_root(param->mem_root,param->fields_bitmap_size)) ||
+  if (!(tmp= (uint32*)alloc_root(param->mem_root,
+    bytes_word_aligned(param->fields_bitmap_size))) ||
       bitmap_init(&param->needed_fields, tmp, param->fields_bitmap_size*8,
                   FALSE))
     return 1;
@@ -2307,7 +2311,7 @@ static
 ROR_SCAN_INFO *make_ror_scan(const PARAM *param, int idx, SEL_ARG *sel_arg)
 {
   ROR_SCAN_INFO *ror_scan;
-  uchar *bitmap_buf;
+  uint32 *bitmap_buf;
   uint keynr;
   DBUG_ENTER("make_ror_scan");
 
@@ -2322,8 +2326,8 @@ ROR_SCAN_INFO *make_ror_scan(const PARAM *param, int idx, SEL_ARG *sel_arg)
   ror_scan->sel_arg= sel_arg;
   ror_scan->records= param->table->quick_rows[keynr];
 
-  if (!(bitmap_buf= (uchar*)alloc_root(param->mem_root,
-                                       param->fields_bitmap_size)))
+  if (!(bitmap_buf= (uint32*)alloc_root(param->mem_root,
+                                        bytes_word_aligned(param->fields_bitmap_size))))
     DBUG_RETURN(NULL);
 
   if (bitmap_init(&ror_scan->covered_fields, bitmap_buf,
@@ -2437,12 +2441,13 @@ static
 ROR_INTERSECT_INFO* ror_intersect_init(const PARAM *param)
 {
   ROR_INTERSECT_INFO *info;
-  uchar* buf;
+  uint32* buf;
   if (!(info= (ROR_INTERSECT_INFO*)alloc_root(param->mem_root,
                                               sizeof(ROR_INTERSECT_INFO))))
     return NULL;
   info->param= param;
-  if (!(buf= (uchar*)alloc_root(param->mem_root, param->fields_bitmap_size)))
+  if (!(buf= (uint32*)alloc_root(param->mem_root,
+                             bytes_word_aligned(param->fields_bitmap_size))))
     return NULL;
   if (bitmap_init(&info->covered_fields, buf, param->fields_bitmap_size*8,
                   FALSE))
@@ -2459,7 +2464,7 @@ void ror_intersect_cpy(ROR_INTERSECT_INFO *dst, const ROR_INTERSECT_INFO *src)
 {
   dst->param= src->param;
   memcpy(dst->covered_fields.bitmap, src->covered_fields.bitmap, 
-         src->covered_fields.bitmap_size);
+         no_bytes_in_map(&src->covered_fields));
   dst->out_rows= src->out_rows;
   dst->is_covering= src->is_covering;
   dst->index_records= src->index_records;
@@ -3001,9 +3006,9 @@ TRP_ROR_INTERSECT *get_best_covering_ror_intersect(PARAM *param,
   /*I=set of all covering indexes */
   ror_scan_mark= tree->ror_scans;
 
-  uchar buf[MAX_KEY/8+1];
+  uint32 int_buf[MAX_KEY/32+1];
   MY_BITMAP covered_fields;
-  if (bitmap_init(&covered_fields, buf, nbits, FALSE))
+  if (bitmap_init(&covered_fields, int_buf, nbits, FALSE))
     DBUG_RETURN(0);
   bitmap_clear_all(&covered_fields);
 
@@ -5776,7 +5781,7 @@ int QUICK_INDEX_MERGE_SELECT::read_keys_and_merge()
     (This also creates a deficiency - it is possible that we will retrieve
      parts of key that are not used by current query at all.)
   */
-  if (head->file->extra(HA_EXTRA_RETRIEVE_PRIMARY_KEY))
+  if (head->file->ha_retrieve_all_pk())
     DBUG_RETURN(1);
 
   cur_quick_it.rewind();
@@ -6045,7 +6050,7 @@ int QUICK_RANGE_SELECT::reset()
   range= NULL;
   cur_range= (QUICK_RANGE**) ranges.buffer;
 
-  if (file->inited == handler::NONE && (error= file->ha_index_init(index)))
+  if (file->inited == handler::NONE && (error= file->ha_index_init(index,1)))
     DBUG_RETURN(error);
  
   /* Do not allocate the buffers twice. */
@@ -6304,7 +6309,7 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
 			     (byte*) range->min_key,
 			     range->min_length,
 			     (ha_rkey_function)(range->flag ^ GEOM_FLAG));
-    if (result != HA_ERR_KEY_NOT_FOUND)
+    if (result != HA_ERR_KEY_NOT_FOUND && result != HA_ERR_END_OF_FILE)
       DBUG_RETURN(result);
     range=0;				// Not found, to next range
   }
@@ -6447,7 +6452,7 @@ int QUICK_SELECT_DESC::get_next()
     }
     if (result)
     {
-      if (result != HA_ERR_KEY_NOT_FOUND)
+      if (result != HA_ERR_KEY_NOT_FOUND && result != HA_ERR_END_OF_FILE)
 	DBUG_RETURN(result);
       range=0;					// Not found, to next range
       continue;
@@ -8079,7 +8084,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::reset(void)
   DBUG_ENTER("QUICK_GROUP_MIN_MAX_SELECT::reset");
 
   file->extra(HA_EXTRA_KEYREAD); /* We need only the key attributes */
-  result= file->ha_index_init(index);
+  result= file->ha_index_init(index, 1);
   result= file->index_last(record);
   if (result == HA_ERR_END_OF_FILE)
     DBUG_RETURN(0);
@@ -8155,7 +8160,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
     DBUG_ASSERT(is_last_prefix <= 0);
     if (result == HA_ERR_KEY_NOT_FOUND)
       continue;
-    else if (result)
+    if (result)
       break;
 
     if (have_min)
@@ -8185,10 +8190,11 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
                                HA_READ_KEY_EXACT);
 
     result= have_min ? min_res : have_max ? max_res : result;
-  }
-  while (result == HA_ERR_KEY_NOT_FOUND && is_last_prefix != 0);
+  } while ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
+           is_last_prefix != 0);
 
   if (result == 0)
+  {
     /*
       Partially mimic the behavior of end_select_send. Copy the
       field data from Item_field::field into Item_field::result_field
@@ -8196,6 +8202,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
       other fields in non-ANSI SQL mode).
     */
     copy_fields(&join->tmp_table_param);
+  }
   else if (result == HA_ERR_KEY_NOT_FOUND)
     result= HA_ERR_END_OF_FILE;
 
@@ -8222,6 +8229,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
   RETURN
     0                    on success
     HA_ERR_KEY_NOT_FOUND if no MIN key was found that fulfills all conditions.
+    HA_ERR_END_OF_FILE   - "" -
     other                if some error occurred
 */
 
@@ -8275,7 +8283,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
         if (key_cmp(index_info->key_part, group_prefix, real_prefix_len))
           key_restore(record, tmp_record, index_info, 0);
       }
-      else if (result == HA_ERR_KEY_NOT_FOUND) 
+      else if (result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE)
         result= 0; /* There is a result in any case. */
     }
   }
@@ -8300,6 +8308,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
   RETURN
     0                    on success
     HA_ERR_KEY_NOT_FOUND if no MAX key was found that fulfills all conditions.
+    HA_ERR_END_OF_FILE	 - "" -
     other                if some error occurred
 */
 
@@ -8400,6 +8409,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_prefix()
     0                    on success
     HA_ERR_KEY_NOT_FOUND if there is no key with the given prefix in any of
                          the ranges
+    HA_ERR_END_OF_FILE   - "" -
     other                if some error
 */
 
@@ -8444,11 +8454,12 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
 
     result= file->index_read(record, group_prefix, search_prefix_len,
                              find_flag);
-    if ((result == HA_ERR_KEY_NOT_FOUND) &&
-        (cur_range->flag & (EQ_RANGE | NULL_RANGE)))
-        continue; /* Check the next range. */
-    else if (result)
+    if (result)
     {
+      if ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
+          (cur_range->flag & (EQ_RANGE | NULL_RANGE)))
+        continue; /* Check the next range. */
+
       /*
         In all other cases (HA_ERR_*, HA_READ_KEY_EXACT with NO_MIN_RANGE,
         HA_READ_AFTER_KEY, HA_READ_KEY_OR_NEXT) if the lookup failed for this
@@ -8475,7 +8486,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
     /* Check if record belongs to the current group. */
     if (key_cmp(index_info->key_part, group_prefix, real_prefix_len))
     {
-      result = HA_ERR_KEY_NOT_FOUND;
+      result= HA_ERR_KEY_NOT_FOUND;
       continue;
     }
 
@@ -8493,7 +8504,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
       if (!((cur_range->flag & NEAR_MAX) && (cmp_res == -1) ||
             (cmp_res <= 0)))
       {
-        result = HA_ERR_KEY_NOT_FOUND;
+        result= HA_ERR_KEY_NOT_FOUND;
         continue;
       }
     }
@@ -8532,6 +8543,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
     0                    on success
     HA_ERR_KEY_NOT_FOUND if there is no key with the given prefix in any of
                          the ranges
+    HA_ERR_END_OF_FILE   - "" -
     other                if some error
 */
 
@@ -8577,10 +8589,12 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_max_in_range()
     result= file->index_read(record, group_prefix, search_prefix_len,
                              find_flag);
 
-    if ((result == HA_ERR_KEY_NOT_FOUND) && (cur_range->flag & EQ_RANGE))
-      continue; /* Check the next range. */
     if (result)
     {
+      if ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
+          (cur_range->flag & EQ_RANGE))
+        continue; /* Check the next range. */
+
       /*
         In no key was found with this upper bound, there certainly are no keys
         in the ranges to the left.