Bug#20075406 TEMPLATE-BASED QUEUE/HEAP IN BOUNDED_QUEUE

Our QUEUE implementation should be replaced by a templatized C++ version.
Templatized heaps are
 - type safe
 - easier to read/maintain
 - faster

Some changed results for queries doing 'ORDER BY CHAR(0) NOT NULL limit N'

Author: Tor Didriksen

include/priority_queue.h

@@ -116,25 +116,29 @@ class Priority_queue : public Less
   void heapify(size_type i, size_type last)
   {
     DBUG_ASSERT(i < size());
-    size_type l = left(i);
-    size_type r = right(i);
     size_type largest = i;
 
-    if (l < last && Base::operator()(m_container[i], m_container[l]))
+    do
     {
-      largest = l;
-    }
+      i = largest;
+      size_type l = left(i);
+      size_type r = right(i);
 
-    if (r < last && Base::operator()(m_container[largest], m_container[r]))
-    {
-      largest = r;
-    }
+      if (l < last && Base::operator()(m_container[i], m_container[l]))
+      {
+        largest = l;
+      }
 
-    if (largest != i)
-    {
-      std::swap(m_container[i], m_container[largest]);
-      heapify(largest, last);
-    }
+      if (r < last && Base::operator()(m_container[largest], m_container[r]))
+      {
+        largest = r;
+      }
+
+      if (largest != i)
+      {
+        std::swap(m_container[i], m_container[largest]);
+      }
+    } while (largest != i);
   }
 
   void heapify(size_type i)

mysql-test/r/select_all.result

@@ -4791,7 +4791,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_all_bka.result

@@ -4792,7 +4792,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_all_bka_nixbnl.result

@@ -4792,7 +4792,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_icp_mrr.result

@@ -4791,7 +4791,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_icp_mrr_bka.result

@@ -4792,7 +4792,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_icp_mrr_bka_nixbnl.result

@@ -4792,7 +4792,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_none.result

@@ -4790,7 +4790,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_none_bka.result

@@ -4791,7 +4791,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

mysql-test/r/select_none_bka_nixbnl.result

@@ -4791,7 +4791,7 @@ Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` order by `test`.`t1`.`a`,`test`.`t1`.`b` limit 5
 SELECT * FROM t1 ORDER BY a, b LIMIT 5;
 a	b	c
-		1
+		0
 		2
 		1
 		0

sql/bounded_queue.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. 
+/* Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved. 
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -16,80 +16,70 @@
 #ifndef BOUNDED_QUEUE_INCLUDED
 #define BOUNDED_QUEUE_INCLUDED
 
-#include <string.h>
 #include "my_global.h"
 #include "my_base.h"
 #include "my_sys.h"
-#include "queues.h"
+#include "mysys_err.h"
+#include "priority_queue.h"
 
 /**
   A priority queue with a fixed, limited size.
 
-  This is a wrapper on top of QUEUE and the queue_xxx() functions.
+  This is a wrapper on top of Priority_queue.
   It keeps the top-N elements which are inserted.
 
   Elements of type Element_type are pushed into the queue.
   For each element, we call a user-supplied Key_generator::make_sortkey(),
   to generate a key of type Key_type for the element.
-  Instances of Key_type are compared with the user-supplied compare_function.
-
-  The underlying QUEUE implementation needs one extra element for replacing
-  the lowest/highest element when pushing into a full queue.
+  Instances of Key_type are compared with the user-supplied Key_compare.
 
   Pointers to the top-N elements are stored in the sort_keys array given
-  to the init() function below. To access elements in sorted order, use
-  repeated calls to pop(), or, simply sort the array and access it sequentially.
-  The pop() interface is for unit testing only.
+  to the init() function below. To access elements in sorted order,
+  sort the array and access it sequentially.
  */
-template<typename Element_type, typename Key_type, typename Key_generator>
+template<typename Element_type,
+         typename Key_type,
+         typename Key_generator,
+         typename Key_compare = std::less<Key_type>
+        >
 class Bounded_queue
 {
 public:
   Bounded_queue()
-  {
-    memset(&m_queue, 0, sizeof(m_queue));
-  }
-
-  ~Bounded_queue()
-  {
-    delete_queue(&m_queue);
-  }
-
-  /**
-     Function for comparing two keys.
-     @param  n Pointer to number of bytes to compare.
-     @param  a First key.
-     @param  b Second key.
-     @retval -1, 0, or 1 depending on whether the left argument is 
-             less than, equal to, or greater than the right argument.
-   */
-  typedef int (*compare_function)(size_t *n, Key_type *a, Key_type *b);
+    : m_sort_keys(NULL),
+      m_sort_param(NULL)
+  {}
 
   /**
     Initialize the queue.
 
     @param max_elements   The size of the queue.
-    @param max_at_top     Set to true if you want biggest element on top.
-           false: We keep the n largest elements.
-                  pop() will return the smallest key in the result set.
-           true:  We keep the n smallest elements.
-                  pop() will return the largest key in the result set.
-    @param compare        Compare function for elements, takes 3 arguments.
-           If NULL, we use get_ptr_compare(sort_param->compare_length()).
     @param sort_param     Sort parameters. We call sort_param->make_sortkey()
                           to generate keys for elements.
     @param[in,out] sort_keys Array of keys to sort.
                              Must be initialized by caller.
                              Will be filled with pointers to the top-N elements.
 
-    @retval 0 OK, 1 Could not allocate memory.
+    @retval false OK, true Could not allocate memory.
 
     We do *not* take ownership of any of the input pointer arguments.
    */
-  int init(ha_rows max_elements, bool max_at_top,
-           compare_function compare,
-           Key_generator *sort_param,
-           Key_type *sort_keys);
+  bool init(ha_rows max_elements,
+            Key_generator *sort_param,
+            Key_type *sort_keys)
+  {
+    m_sort_keys= sort_keys;
+    m_sort_param= sort_param;
+    DBUG_EXECUTE_IF("bounded_queue_init_fail",
+                    my_error(EE_OUTOFMEMORY, MYF(ME_FATALERROR), 42);
+                    return true;);
+
+    // We allocate space for one extra element, for replace when queue is full.
+    if (m_queue.reserve(max_elements + 1))
+      return true;
+    m_queue.m_compare_length= sort_param->compare_length();
+    return false;
+  }
 
   /**
     Pushes an element on the queue.
@@ -98,94 +88,32 @@ class Bounded_queue
 
     @param element        The element to be pushed.
    */
-  void push(Element_type element);
-
-  /**
-    Removes the top element from the queue.
-
-    @retval Pointer to the (key of the) removed element.
-
-    @note This function is for unit testing, where we push elements into to the
-          queue, and test that the appropriate keys are retained.
-          Interleaving of push() and pop() operations has not been tested.
-   */
-  Key_type *pop()
+  void push(Element_type element)
   {
-    // Don't return the extra element to the client code.
-    if (queue_is_full((&m_queue)))
-      queue_remove(&m_queue, 0);
-    DBUG_ASSERT(m_queue.elements > 0);
-    if (m_queue.elements == 0)
-      return NULL;
-    return reinterpret_cast<Key_type*>(queue_remove(&m_queue, 0));
+    if (m_queue.size() == m_queue.capacity())
+    {
+      const Key_type &pq_top= m_queue.top();
+      m_sort_param->make_sortkey(pq_top, element);
+      m_queue.update_top();
+    } else {
+      m_sort_param->make_sortkey(m_sort_keys[m_queue.size()], element);
+      m_queue.push(m_sort_keys[m_queue.size()]);
+    }
   }
 
   /**
     The number of elements in the queue.
    */
-  uint num_elements() const { return m_queue.elements; }
+  size_t num_elements() const { return m_queue.size(); }
 
-  /**
-    Is the queue initialized?
-   */
-  bool is_initialized() const { return m_queue.max_elements > 0; }
+  typedef Priority_queue<Key_type,
+                         std::vector<Key_type>,
+                         Key_compare> Queue_type;
 
 private:
+  Queue_type         m_queue;
   Key_type          *m_sort_keys;
-  size_t             m_compare_length;
   Key_generator     *m_sort_param;
-  st_queue           m_queue;
 };
 
-
-template<typename Element_type, typename Key_type, typename Key_generator>
-int Bounded_queue<Element_type, Key_type, Key_generator>
-  ::init(ha_rows max_elements,
-         bool max_at_top,
-         compare_function compare,
-         Key_generator *sort_param,
-         Key_type *sort_keys)
-{
-  DBUG_ASSERT(sort_keys != NULL);
-
-  m_sort_keys=      sort_keys;
-  m_compare_length= sort_param->compare_length();
-  m_sort_param=     sort_param;
-  // init_queue() takes an uint, and also does (max_elements + 1)
-  if (max_elements >= (UINT_MAX - 1))
-    return 1;
-  if (compare == NULL)
-    compare=
-      reinterpret_cast<compare_function>(get_ptr_compare(m_compare_length));
-
-  DBUG_EXECUTE_IF("bounded_queue_init_fail",
-                  DBUG_SET("+d,simulate_out_of_memory"););
-
-  // We allocate space for one extra element, for replace when queue is full.
-  return init_queue(&m_queue, (uint) max_elements + 1,
-                    0, max_at_top,
-                    reinterpret_cast<queue_compare>(compare),
-                    &m_compare_length);
-}
-
-
-template<typename Element_type, typename Key_type, typename Key_generator>
-void Bounded_queue<Element_type, Key_type, Key_generator>
-  ::push(Element_type element)
-{
-  DBUG_ASSERT(is_initialized());
-  if (queue_is_full((&m_queue)))
-  {
-    // Replace top element with new key, and re-order the queue.
-    Key_type *pq_top= reinterpret_cast<Key_type *>(queue_top(&m_queue));
-    m_sort_param->make_sortkey(*pq_top, element);
-    queue_replaced(&m_queue);
-  } else {
-    // Insert new key into the queue.
-    m_sort_param->make_sortkey(m_sort_keys[m_queue.elements], element);
-    queue_insert(&m_queue,
-                 reinterpret_cast<uchar*>(&m_sort_keys[m_queue.elements]));
-  }
-}
-
 #endif  // BOUNDED_QUEUE_INCLUDED