Bug #33037007: PRELIMINARY FIXES FOR WL #14488 [TRP planning, noclose]

Move planning (in QEP_TABs) from using QUICK_SELECT_I objects to TRPs,
ie., test_quick_select() with return a TRP (instead of a quick)
and the iterator won't be created until the plan is actually decided
upon (or not at all, if the query is an EXPLAIN query). This cements
TRPs as planning objects and quicks as pure execution objects;
a necessary step in converting the former to AccessPath and the latter
to RowIterator.

It naturally moves all planning members (e.g. cost and row estimates)
away from QUICK_SELECT_I, along with all protected data members.
Various tracing and querying member functions are also taken out
(some are replaced with free functions). There is no longer a need
for quicks to be able to reverse themselves; that's a simple member
switch in TRP_RANGE (but the rather ugly moving and subclassing of
QUICK_RANGE_SELECT_DESC remains for now).

Several member fields that needed to be shared between QUICK_SELECT_I
can be moved down into the classes that actually need them. This is
especially beneficial for those that only make sense for a subset
(such as index, which had no interpretation for e.g. index merge).

Change-Id: I8896b5725f6d9c10b9c6c6384cf7a4375586fc96

Author: Steinar H. Gunderson

Diff for: sql/abstract_query_plan.cc

@@ -34,6 +34,7 @@
 #include "sql/item.h"
 #include "sql/key.h"
 #include "sql/range_optimizer/range_optimizer.h"  // QUICK_SELECT_I
+#include "sql/range_optimizer/table_read_plan.h"
 #include "sql/sql_const.h"
 #include "sql/sql_executor.h"  // QEP_TAB
 #include "sql/sql_opt_exec_shared.h"
@@ -52,7 +53,7 @@ Join_plan::Join_plan(const JOIN *join)
     be written to handle it.
   */
   assert(!m_qep_tabs[0].dynamic_range() || (m_qep_tabs[0].type() == JT_ALL) ||
-         (m_qep_tabs[0].quick() == nullptr));
+         (m_qep_tabs[0].trp() == nullptr));
 
   // Discard trailing allocated, but unused, tables.
   while (m_qep_tabs[m_access_count - 1].position() == nullptr) {
@@ -162,10 +163,10 @@ void Table_access::dbug_print() const {
 
   DBUG_PRINT("info", ("dynamic_range:%d", (int)get_qep_tab()->dynamic_range()));
   DBUG_PRINT("info", ("index:%d", get_qep_tab()->index()));
-  DBUG_PRINT("info", ("quick:%p", get_qep_tab()->quick()));
-  if (get_qep_tab()->quick()) {
+  DBUG_PRINT("info", ("trp:%p", get_qep_tab()->trp()));
+  if (get_qep_tab()->trp()) {
     DBUG_PRINT("info",
-               ("quick->get_type():%d", get_qep_tab()->quick()->get_type()));
+               ("trp->get_type():%d", get_qep_tab()->trp()->get_type()));
   }
 }
 
@@ -253,8 +254,8 @@ void Table_access::compute_type_and_index() const {
         m_access_type = AT_UNDECIDED;
         m_index_no = -1;
       } else {
-        if (qep_tab->quick() != nullptr) {
-          QUICK_SELECT_I *quick = qep_tab->quick();
+        if (qep_tab->trp() != nullptr) {
+          TABLE_READ_PLAN *trp = qep_tab->trp();
 
           /** QUICK_SELECT results in execution of MRR (Multi Range Read).
            *  Depending on each range, it may require execution of
@@ -266,33 +267,33 @@ void Table_access::compute_type_and_index() const {
            **/
 
           const KEY *key_info = qep_tab->table()->s->key_info;
-          DBUG_EXECUTE("info", quick->dbug_dump(0, true););
+          DBUG_EXECUTE("info", trp->dbug_dump(0, true););
 
           // Temporary assert as we are still investigation the relation between
-          // 'quick->index == MAX_KEY' and the different quick_types
-          assert((quick->index == MAX_KEY) ==
-                 (quick->get_type() == QS_TYPE_INDEX_MERGE ||
-                  quick->get_type() == QS_TYPE_ROR_INTERSECT ||
-                  quick->get_type() == QS_TYPE_ROR_UNION));
+          // 'trp->index == MAX_KEY' and the different quick_types
+          assert((trp->index == MAX_KEY) ==
+                 (trp->get_type() == QS_TYPE_INDEX_MERGE ||
+                  trp->get_type() == QS_TYPE_ROR_INTERSECT ||
+                  trp->get_type() == QS_TYPE_ROR_UNION));
 
           // JT_INDEX_MERGE: We have a set of qualifying PKs as root of pushed
           // joins
-          if (quick->index == MAX_KEY) {
+          if (trp->index == MAX_KEY) {
             m_index_no = qep_tab->table()->s->primary_key;
             m_access_type =
                 AT_MULTI_PRIMARY_KEY;  // Multiple PKs are produced by merge
           }
 
           // Else JT_RANGE: May be both exact PK and/or index scans when sorted
           // index available
-          else if (quick->index == qep_tab->table()->s->primary_key) {
-            m_index_no = quick->index;
+          else if (trp->index == qep_tab->table()->s->primary_key) {
+            m_index_no = trp->index;
             if (key_info[m_index_no].algorithm == HA_KEY_ALG_HASH)
               m_access_type = AT_MULTI_PRIMARY_KEY;  // MRR w/ multiple PK's
             else
               m_access_type = AT_MULTI_MIXED;  // MRR w/ both range and PKs
           } else {
-            m_index_no = quick->index;
+            m_index_no = trp->index;
             if (key_info[m_index_no].algorithm == HA_KEY_ALG_HASH)
               m_access_type =
                   AT_MULTI_UNIQUE_KEY;  // MRR with multiple unique keys

Diff for: sql/basic_row_iterators.h

@@ -129,14 +129,17 @@ class IndexRangeScanIterator final : public TableRowIterator {
   //
   // "examined_rows", if not nullptr, is incremented for each successful Read().
   IndexRangeScanIterator(THD *thd, TABLE *table, QUICK_SELECT_I *quick,
+                         bool is_loose_index_scan, bool is_ror,
                          double expected_rows, ha_rows *examined_rows);
+  ~IndexRangeScanIterator() override;
 
   bool Init() override;
   int Read() override;
 
  private:
-  // NOTE: No destructor; quick_range will call ha_index_or_rnd_end() for us.
   QUICK_SELECT_I *const m_quick;
+  const bool m_is_loose_index_scan;
+  const bool m_is_ror;
   const double m_expected_rows;
   ha_rows *const m_examined_rows;
 

Diff for: sql/join_optimizer/access_path.cc

@@ -33,6 +33,8 @@
 #include "sql/join_optimizer/estimate_selectivity.h"
 #include "sql/join_optimizer/relational_expression.h"
 #include "sql/join_optimizer/walk_access_paths.h"
+#include "sql/range_optimizer/range_optimizer.h"
+#include "sql/range_optimizer/table_read_plan.h"
 #include "sql/ref_row_iterators.h"
 #include "sql/sorting_iterator.h"
 #include "sql/sql_optimizer.h"
@@ -303,8 +305,18 @@ unique_ptr_destroy_only<RowIterator> CreateIteratorFromAccessPath(
     }
     case AccessPath::INDEX_RANGE_SCAN: {
       const auto &param = path->index_range_scan();
+      QUICK_SELECT_I *quick = param.trp->make_quick(true, thd->mem_root);
+      if (quick == nullptr || quick->init()) {
+        return nullptr;
+      }
+      const int type = param.trp->get_type();
+      bool is_loose_index_scan =
+          (type == QS_TYPE_SKIP_SCAN || type == QS_TYPE_GROUP_MIN_MAX);
+      bool is_ror =
+          (type == QS_TYPE_ROR_INTERSECT || type == QS_TYPE_ROR_UNION);
       iterator = NewIterator<IndexRangeScanIterator>(
-          thd, param.table, param.quick, path->num_output_rows, examined_rows);
+          thd, param.table, quick, is_loose_index_scan, is_ror,
+          path->num_output_rows, examined_rows);
       break;
     }
     case AccessPath::DYNAMIC_INDEX_RANGE_SCAN: {

Diff for: sql/join_optimizer/access_path.h

@@ -47,8 +47,8 @@ class JOIN;
 class KEY;
 class RowIterator;
 class QEP_TAB;
-class QUICK_SELECT_I;
 class SJ_TMP_TABLE;
+class TABLE_READ_PLAN;
 class Table_function;
 class Temp_table_param;
 class Window;
@@ -757,7 +757,7 @@ struct AccessPath {
     } follow_tail;
     struct {
       TABLE *table;
-      QUICK_SELECT_I *quick;
+      TABLE_READ_PLAN *trp;
     } index_range_scan;
     struct {
       TABLE *table;
@@ -1094,13 +1094,13 @@ inline AccessPath *NewFollowTailAccessPath(THD *thd, TABLE *table,
 }
 
 inline AccessPath *NewIndexRangeScanAccessPath(THD *thd, TABLE *table,
-                                               QUICK_SELECT_I *quick,
+                                               TABLE_READ_PLAN *trp,
                                                bool count_examined_rows) {
   AccessPath *path = new (thd->mem_root) AccessPath;
   path->type = AccessPath::INDEX_RANGE_SCAN;
   path->count_examined_rows = count_examined_rows;
   path->index_range_scan().table = table;
-  path->index_range_scan().quick = quick;
+  path->index_range_scan().trp = trp;
   return path;
 }
 

Diff for: sql/join_optimizer/explain_access_path.cc

@@ -29,7 +29,7 @@
 #include "sql/hash_join_iterator.h"
 #include "sql/item_sum.h"
 #include "sql/join_optimizer/relational_expression.h"
-#include "sql/range_optimizer/range_optimizer.h"
+#include "sql/range_optimizer/table_read_plan.h"
 #include "sql/ref_row_iterators.h"
 #include "sql/sorting_iterator.h"
 #include "sql/sql_optimizer.h"
@@ -469,7 +469,7 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
       // TODO(sgunders): Convert QUICK_SELECT_I to RowIterator so that we can
       // get better outputs here (similar to dbug_dump()).
       String str;
-      path->index_range_scan().quick->add_info_string(&str);
+      path->index_range_scan().trp->add_info_string(&str);
       string ret = string(table->key_read ? "Covering index range scan on "
                                           : "Index range scan on ") +
                    table->alias + " using " + to_string(str);