Bug#34122706: Remove use_order flag from eq_ref path and iterator

Since eq_ref never returns more than one row, ordering it does not
make sense. The eq_ref access path is always created with the
use_order flag set to false, either hard-coded or implicitly by
calling QEP_TAB::use_order() which returns false for eq_ref. There are
also asserts in the eq ref iterator that check that the flag is set to
false.

Since the flag serves no purpose, we remove it from the eq_ref access
path and the corresponding iterator class.

Change-Id: I7b8b3b4922f0aa9865e5b080929739cb52fd93b2

Author: kahatlen

sql/iterators/ref_row_iterators.cc

@@ -109,10 +109,9 @@ int ConstIterator::Read() {
 }
 
 EQRefIterator::EQRefIterator(THD *thd, TABLE *table, TABLE_REF *ref,
-                             bool use_order, ha_rows *examined_rows)
+                             ha_rows *examined_rows)
     : TableRowIterator(thd, table),
       m_ref(ref),
-      m_use_order(use_order),
       m_examined_rows(examined_rows) {}
 
 /**
@@ -134,8 +133,7 @@ EQRefIterator::EQRefIterator(THD *thd, TABLE *table, TABLE_REF *ref,
 
 bool EQRefIterator::Init() {
   if (!table()->file->inited) {
-    assert(!m_use_order);  // Don't expect sort req. for single row.
-    int error = table()->file->ha_index_init(m_ref->key, m_use_order);
+    int error = table()->file->ha_index_init(m_ref->key, /*sorted=*/false);
     if (error) {
       PrintError(error);
       return true;

sql/iterators/ref_row_iterators.h

@@ -100,8 +100,7 @@ class RefOrNullIterator final : public TableRowIterator {
 class EQRefIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  EQRefIterator(THD *thd, TABLE *table, TABLE_REF *ref, bool use_order,
-                ha_rows *examined_rows);
+  EQRefIterator(THD *thd, TABLE *table, TABLE_REF *ref, ha_rows *examined_rows);
 
   bool Init() override;
   int Read() override;
@@ -117,7 +116,6 @@ class EQRefIterator final : public TableRowIterator {
 
  private:
   TABLE_REF *const m_ref;
-  const bool m_use_order;
   bool m_first_record_since_init;
   ha_rows *const m_examined_rows;
 };

sql/join_optimizer/access_path.cc

@@ -415,9 +415,8 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
       }
       case AccessPath::EQ_REF: {
         const auto &param = path->eq_ref();
-        iterator =
-            NewIterator<EQRefIterator>(thd, mem_root, param.table, param.ref,
-                                       param.use_order, examined_rows);
+        iterator = NewIterator<EQRefIterator>(thd, mem_root, param.table,
+                                              param.ref, examined_rows);
         break;
       }
       case AccessPath::PUSHED_JOIN_REF: {

sql/join_optimizer/access_path.h

@@ -870,7 +870,6 @@ struct AccessPath {
     struct {
       TABLE *table;
       TABLE_REF *ref;
-      bool use_order;
     } eq_ref;
     struct {
       TABLE *table;
@@ -1270,14 +1269,12 @@ inline AccessPath *NewRefOrNullAccessPath(THD *thd, TABLE *table,
 }
 
 inline AccessPath *NewEQRefAccessPath(THD *thd, TABLE *table, TABLE_REF *ref,
-                                      bool use_order,
                                       bool count_examined_rows) {
   AccessPath *path = new (thd->mem_root) AccessPath;
   path->type = AccessPath::EQ_REF;
   path->count_examined_rows = count_examined_rows;
   path->eq_ref().table = table;
   path->eq_ref().ref = ref;
-  path->eq_ref().use_order = use_order;
   return path;
 }
 

sql/join_optimizer/join_optimizer.cc

@@ -1969,7 +1969,6 @@ bool CostingReceiver::ProposeRefAccess(
     path.type = AccessPath::EQ_REF;
     path.eq_ref().table = table;
     path.eq_ref().ref = ref;
-    path.eq_ref().use_order = false;
 
     // We could set really any ordering here if we wanted to.
     // It's very rare that it should matter, though.

sql/sql_executor.cc

@@ -3599,7 +3599,7 @@ AccessPath *QEP_TAB::access_path() {
 
     case JT_EQ_REF:
       // May later change to a PushedJoinRefAccessPath if 'pushed'
-      path = NewEQRefAccessPath(join()->thd, table(), &ref(), use_order(),
+      path = NewEQRefAccessPath(join()->thd, table(), &ref(),
                                 /*count_examined_rows=*/true);
       used_ref = &ref();
       break;