Add more comments

Author: spetrunia

mysys/my_bitmap.c

@@ -677,7 +677,7 @@ uint bitmap_get_next_set(const MY_BITMAP *map, uint bitmap_bit)
 uint bitmap_get_prev_set(const MY_BITMAP *map, uint bitmap_bit)
 {
   DBUG_ASSERT_BITMAP(map);
-  bitmap_bit--;
+  bitmap_bit--; // If this or one below wraps around, it's ok
   while (bitmap_bit < map->n_bits && !bitmap_is_set(map, bitmap_bit))
     bitmap_bit--;
   if (bitmap_bit >= map->n_bits)

sql/ha_partition.cc

@@ -7481,6 +7481,7 @@ int ha_partition::ft_read(uchar *buf)
   DBUG_RETURN(result);
 }
 
+
 /*
   Returns true if for a PARTITION BY RANGE table there is no need for
   priority queue for index scan. In this case an unordered index scan
@@ -7494,24 +7495,34 @@ int ha_partition::ft_read(uchar *buf)
   , OR
 
   Case 2. The PARTITION BY RANGE expression is col1 and the active
-  index is (prefix_cols, col1, ...), and we are in
-  index_read_map(prefix_cols=prefix_value), or
-  read_range_first(start_key= {prefix_value, ...},
-  end_key={prefix_value, ...}), or
-  multi_range_read_next(start_key= {prefix_value, ...},
-  end_key={prefix_value, ...})
+  index is (prefix_cols, col1, ...), and we are in one of
+    * index_read_map(prefix_cols=prefix_value)
+    * read_range_first(start_key= {prefix_value, ...},
+                       end_key=   {prefix_value, ...})
+    * multi_range_read_next(start_key= {prefix_value, ...},
+                            end_key=   {prefix_value, ...})
 */
+
 bool ha_partition::can_skip_merging_scans()
 {
   Field *part_field= NULL;
   uint i;
   m_unordered_prefix_len= 0;
+
   if (m_index_scan_type != partition_index_first &&
       m_index_scan_type != partition_index_last &&
       m_index_scan_type != partition_index_read &&
       m_index_scan_type != partition_read_range &&
       m_index_scan_type != partition_read_multi_range)
+  {
+    /*
+      This is partition_ft_read or partition_no_index_scan. We shouldn't
+      get here.
+    */
+    DBUG_ASSERT(0);
     return false;
+  }
+
   if (m_part_info->part_type != RANGE_PARTITION || m_is_sub_partitioned)
     return false;
   if (m_part_info->part_expr &&
@@ -7525,13 +7536,15 @@ bool ha_partition::can_skip_merging_scans()
     KEY_PART_INFO *key_part= &m_curr_key_info[0]->key_part[i];
     if (key_part->field != part_field)
       break;
+
+    /* Currently, we disallow indexes with mixed ASC and DESC key parts: */
+    bool kp_is_reverse= MY_TEST(key_part->key_part_flag & HA_REVERSE_SORT);
     if (i == 0)
-      m_unordered_reverse_index=
-        (key_part->key_part_flag & HA_REVERSE_SORT) ? true : false;
-    else if (m_unordered_reverse_index !=
-             ((key_part->key_part_flag & HA_REVERSE_SORT) ? true : false))
-      return false;             /* TODO: support mixed ASC/DESC keys */
+      m_unordered_reverse_index= kp_is_reverse;
+    else if (m_unordered_reverse_index != kp_is_reverse)
+      return false;
   }
+
   /* Case 1 */
   /*
     We read to the empty partition field, so the partition columns are
@@ -7560,21 +7573,27 @@ bool ha_partition::can_skip_merging_scans()
       m_unordered_reverse_index=
         (key_part->key_part_flag & HA_REVERSE_SORT) ? true : false;
       if (m_index_scan_type == partition_index_read)
+      {
         return
           m_start_key.key && (m_start_key.keypart_map & prefix) == prefix;
+      }
       else if (m_index_scan_type == partition_read_range)
+      {
         return
           m_start_key.key && (m_start_key.keypart_map & prefix) == prefix &&
           end_range && (end_range->keypart_map & prefix) == prefix &&
           !memcmp(m_start_key.key, end_range->key, m_unordered_prefix_len);
+      }
       else /* (m_index_scan_type == partition_read_multi_range) */
+      {
         return
           (m_mrr_range_current->key_multi_range.start_key.keypart_map &
            prefix) == prefix &&
           (m_mrr_range_current->key_multi_range.end_key.keypart_map &
            prefix) == prefix &&
           !memcmp(m_mrr_range_current->key[0], m_mrr_range_current->key[1],
                   m_unordered_prefix_len);
+      }
     }
   }
   return false;