Bug#36220640 Mrr implement runs much slower than before

Queries using the Multi-Range Read optimization run slower after the
fix for Bug#36017204.

The reason is that the insertion sort used to sort the records in the
MRR buffer does not perform well when the number of records in the
buffer is high.

Fixed by replacing the insertion sort with a call to qsort() in the C
standard library. It performs better on large buffers.

Change-Id: I39da5db5c329d482bf83b18fb27e52a0c5fcae03

Author: kahatlen

include/varlen_sort.h

@@ -131,7 +131,6 @@
 #include "string_with_len.h"
 #include "template_utils.h"
 #include "uniques.h"  // Unique_on_insert
-#include "varlen_sort.h"
 
 /**
   @def MYSQL_TABLE_IO_WAIT
@@ -6853,9 +6852,18 @@ int DsMrr_impl::dsmrr_fill_buffer() {
   const uint elem_size = h->ref_length + (int)is_mrr_assoc * sizeof(void *);
   assert((rowids_buf_cur - rowids_buf) % elem_size == 0);
 
-  varlen_sort(
-      rowids_buf, rowids_buf_cur, elem_size,
-      [this](const uchar *a, const uchar *b) { return h->cmp_ref(a, b) < 0; });
+  // Store the handler in a thread local variable so that it is available in the
+  // stateless comparator passed to qsort.
+  thread_local const handler *current_handler;
+  current_handler = h;
+
+  qsort(rowids_buf, (rowids_buf_cur - rowids_buf) / elem_size, elem_size,
+        [](const void *a, const void *b) {
+          return current_handler->cmp_ref(
+              static_cast<const unsigned char *>(a),
+              static_cast<const unsigned char *>(b));
+        });
+
   rowids_buf_last = rowids_buf_cur;
   rowids_buf_cur = rowids_buf;
   return 0;

sql/handler.cc

@@ -60,7 +60,6 @@
 #include "sql/system_variables.h"
 #include "sql/table.h"
 #include "thr_lock.h"
-#include "varlen_sort.h"
 
 using std::string;
 using std::vector;

sql/iterators/sorting_iterator.cc

@@ -24,6 +24,7 @@
 
 #include <limits.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ -68,7 +69,6 @@
 #include "sql/trigger_def.h"
 #include "sql_string.h"
 #include "string_with_len.h"
-#include "varlen_sort.h"
 
 using std::string;
 
@@ -1176,45 +1176,50 @@ bool partition_info::check_range_constants(THD *thd) {
   goto end;
 }
 
-/*
-  Compare two lists of column values in RANGE/LIST partitioning
-  SYNOPSIS
-    compare_column_values()
-    first                    First column list argument
-    second                   Second column list argument
-  RETURN VALUES
-    true                     first < second
-    false                    first >= second
-*/
-
-static bool partition_info_compare_column_values(
+static int partition_info_compare_column_values(
     const part_column_list_val *first, const part_column_list_val *second) {
   for (Field **field = first->part_info->part_field_array; *field;
        field++, first++, second++) {
     /*
       If both are maxvalue, they are equal (don't check the rest of the parts).
       Otherwise, maxvalue > *.
-    */
-    if (first->max_value || second->max_value)
-      return first->max_value < second->max_value;
+     */
+    if (first->max_value) {
+      return second->max_value ? 0 : 1;
+    } else if (second->max_value) {
+      return -1;
+    }
 
     // NULLs sort before non-NULLs.
-    if (first->null_value != second->null_value) return first->null_value;
+    if (first->null_value != second->null_value) {
+      return first->null_value ? -1 : 1;
+    }
 
     // For non-NULLs, compare the actual fields.
     if (!first->null_value) {
       int res = (*field)->cmp(first->column_value.field_image,
                               second->column_value.field_image);
-      if (res != 0) return res < 0;
+      if (res != 0) return res;
     }
   }
-  return false;
+  return 0;
 }
 
+/*
+  Compare two lists of column values in RANGE/LIST partitioning
+  SYNOPSIS
+    compare_column_values()
+    first                    First column list argument
+    second                   Second column list argument
+  RETURN VALUES
+    true                     first < second
+    false                    first >= second
+*/
+
 bool partition_info::compare_column_values(
     const part_column_list_val *first_arg,
     const part_column_list_val *second_arg) {
-  return partition_info_compare_column_values(first_arg, second_arg);
+  return partition_info_compare_column_values(first_arg, second_arg) < 0;
 }
 
 /*
@@ -1309,14 +1314,17 @@ bool partition_info::check_list_constants(THD *thd) {
       }
     } while (++part_id < num_parts);
 
-    varlen_sort(list_col_array,
-                list_col_array + num_list_values * num_column_values,
-                size_entries, partition_info_compare_column_values);
+    qsort(list_col_array, num_list_values, size_entries,
+          [](const void *a, const void *b) {
+            return partition_info_compare_column_values(
+                static_cast<const part_column_list_val *>(a),
+                static_cast<const part_column_list_val *>(b));
+          });
 
     for (uint i = 1; i < num_list_values; ++i) {
-      if (!partition_info_compare_column_values(
+      if (partition_info_compare_column_values(
               &list_col_array[num_column_values * (i - 1)],
-              &list_col_array[num_column_values * i])) {
+              &list_col_array[num_column_values * i]) >= 0) {
         my_error(ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR, MYF(0));
         goto end;
       }

sql/partition_info.cc

@@ -181,7 +181,6 @@ SET(TESTS
   timespec
   unhex
   val_int_compare
-  varlen_sort
   )
 
 SET(ALL_SMALL_TESTS)