bug#34623563 Refactoring TABLE_LIST [TABLE_REF, noclose]

Renamed TABLE_REF to Index_lookup

Change-Id: Ibc0423d389d27df3a868eff8c6b0d461668c19f8

Author: Catalin Besleaga

Diff for: sql/item_subselect.cc

@@ -313,9 +313,9 @@ const TABLE *Item_subselect::get_table() const {
       ->get_table();
 }
 
-const TABLE_REF &Item_subselect::get_table_ref() const {
+const Index_lookup &Item_subselect::index_lookup() const {
   return down_cast<subselect_hash_sj_engine *>(indexsubquery_engine)
-      ->get_table_ref();
+      ->index_lookup();
 }
 
 join_type Item_subselect::get_join_type() const {
@@ -3218,8 +3218,8 @@ Query_block *SubqueryWithResult::single_query_block() const {
     the index allows at most one NULL row.
   - Create a new result sink that sends the result stream of the subquery to
     the temporary table,
-  - Create and initialize TABLE_REF objects to perform lookups into the
-    indexed temporary table.
+  - Create and initialize Index_lookup objects to perform lookups into
+    the indexed temporary table.
 
   @param thd          thread handle
   @param tmp_columns  columns of temporary table
@@ -3287,8 +3287,8 @@ bool subselect_hash_sj_engine::setup(
   /* 2. Create/initialize execution related objects. */
 
   /*
-    Create and initialize the TABLE_REF used by the index lookup
-    iterator into the materialized subquery result.
+    Create and initialize the Index_lookup used by the index lookup iterator
+    into the materialized subquery result.
   */
 
   table = tmp_table;
@@ -3497,7 +3497,7 @@ void subselect_hash_sj_engine::cleanup() {
   if (unit->is_executed()) unit->reset_executed();
 }
 
-static int safe_index_read(TABLE *table, const TABLE_REF &ref) {
+static int safe_index_read(TABLE *table, const Index_lookup &ref) {
   int error = table->file->ha_index_read_map(
       table->record[0], ref.key_buff, make_prev_keypart_map(ref.key_parts),
       HA_READ_KEY_EXACT);

Diff for: sql/item_subselect.h

@@ -118,7 +118,7 @@ class Item_subselect : public Item_result_field {
 
   // For EXPLAIN. Only valid if engine_type() == HASH_SJ_ENGINE.
   const TABLE *get_table() const;
-  const TABLE_REF &get_table_ref() const;
+  const Index_lookup &index_lookup() const;
   join_type get_join_type() const;
 
   void create_iterators(THD *thd);
@@ -804,7 +804,7 @@ class subselect_indexsubquery_engine {
   /// Table which is read, using one of eq_ref, ref, ref_or_null.
   TABLE *table{nullptr};
   TABLE_LIST *table_ref{nullptr};
-  TABLE_REF ref;
+  Index_lookup ref;
   join_type type{JT_UNKNOWN};
   Item *cond;     /* The WHERE condition of subselect */
   ulonglong hash; /* Hash value calculated by RefIterator, when needed. */
@@ -826,7 +826,8 @@ class subselect_indexsubquery_engine {
   enum enum_engine_type { INDEXSUBQUERY_ENGINE, HASH_SJ_ENGINE };
 
   subselect_indexsubquery_engine(TABLE *table, TABLE_LIST *table_ref,
-                                 const TABLE_REF &ref, enum join_type join_type,
+                                 const Index_lookup &ref,
+                                 enum join_type join_type,
                                  Item_in_subselect *subs, Item *where,
                                  Item *having_arg)
       : table(table),
@@ -902,7 +903,7 @@ class subselect_hash_sj_engine final : public subselect_indexsubquery_engine {
   enum_engine_type engine_type() const override { return HASH_SJ_ENGINE; }
 
   TABLE *get_table() const { return table; }
-  const TABLE_REF &get_table_ref() const { return ref; }
+  const Index_lookup &index_lookup() const { return ref; }
   enum join_type get_join_type() const { return type; }
   AccessPath *root_access_path() const { return m_root_access_path; }
   void create_iterators(THD *thd) override;

Diff for: sql/iterators/bka_iterator.cc

@@ -318,9 +318,9 @@ int BKAIterator::Read() {
 }
 
 MultiRangeRowIterator::MultiRangeRowIterator(
-    THD *thd, TABLE *table, TABLE_REF *ref, int mrr_flags, JoinType join_type,
-    const Prealloced_array<TABLE *, 4> &outer_input_tables, bool store_rowids,
-    table_map tables_to_get_rowid_for)
+    THD *thd, TABLE *table, Index_lookup *ref, int mrr_flags,
+    JoinType join_type, const Prealloced_array<TABLE *, 4> &outer_input_tables,
+    bool store_rowids, table_map tables_to_get_rowid_for)
     : TableRowIterator(thd, table),
       m_file(table->file),
       m_ref(ref),
@@ -394,7 +394,7 @@ uint MultiRangeRowIterator::MrrNextCallback(KEY_MULTI_RANGE *range) {
 
     LoadBufferRowIntoTableBuffers(m_outer_input_tables, *m_current_pos);
 
-    construct_lookup_ref(thd(), table(), m_ref);
+    construct_lookup(thd(), table(), m_ref);
     if (!m_ref->impossible_null_ref()) {
       break;
     }

Diff for: sql/iterators/bka_iterator.h

@@ -69,9 +69,9 @@ class Item;
 class JOIN;
 class MultiRangeRowIterator;
 class THD;
+struct Index_lookup;
 struct KEY_MULTI_RANGE;
 struct TABLE;
-struct TABLE_REF;
 
 /**
   The BKA join iterator, with an arbitrary iterator tree on the outer side
@@ -280,8 +280,8 @@ class MultiRangeRowIterator final : public TableRowIterator {
       will make sure that table has the correct row ID already present
       after Read().
    */
-  MultiRangeRowIterator(THD *thd, TABLE *table, TABLE_REF *ref, int mrr_flags,
-                        JoinType join_type,
+  MultiRangeRowIterator(THD *thd, TABLE *table, Index_lookup *ref,
+                        int mrr_flags, JoinType join_type,
                         const Prealloced_array<TABLE *, 4> &outer_input_tables,
                         bool store_rowids, table_map tables_to_get_rowid_for);
 
@@ -380,7 +380,7 @@ class MultiRangeRowIterator final : public TableRowIterator {
   handler *const m_file;
 
   /// The index condition.
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
 
   /// Flags passed on to MRR.
   const int m_mrr_flags;

Diff for: sql/iterators/ref_row_iterators.cc

@@ -73,9 +73,9 @@ using std::move;
 using std::pair;
 
 static inline pair<uchar *, key_part_map> FindKeyBufferAndMap(
-    const TABLE_REF *ref);
+    const Index_lookup *ref);
 
-ConstIterator::ConstIterator(THD *thd, TABLE *table, TABLE_REF *table_ref,
+ConstIterator::ConstIterator(THD *thd, TABLE *table, Index_lookup *table_ref,
                              ha_rows *examined_rows)
     : TableRowIterator(thd, table),
       m_ref(table_ref),
@@ -108,7 +108,7 @@ int ConstIterator::Read() {
   return err;
 }
 
-EQRefIterator::EQRefIterator(THD *thd, TABLE *table, TABLE_REF *ref,
+EQRefIterator::EQRefIterator(THD *thd, TABLE *table, Index_lookup *ref,
                              ha_rows *examined_rows)
     : TableRowIterator(thd, table),
       m_ref(ref),
@@ -181,7 +181,7 @@ int EQRefIterator::Read() {
     memcpy(m_ref->key_buff2, m_ref->key_buff, m_ref->key_length);
 
   // Create new key for lookup
-  m_ref->key_err = construct_lookup_ref(thd(), table(), m_ref);
+  m_ref->key_err = construct_lookup(thd(), table(), m_ref);
   if (m_ref->key_err) {
     table()->set_no_row();
     return -1;
@@ -240,7 +240,7 @@ int EQRefIterator::Read() {
   it if it was not used in this invocation of EQRefIterator::Read().
   Only count locks, thus remembering if the record was left unused,
   and unlock already when pruning the current value of
-  TABLE_REF buffer.
+  Index_lookup buffer.
   @sa EQRefIterator::Read()
 */
 
@@ -250,7 +250,7 @@ void EQRefIterator::UnlockRow() {
 }
 
 PushedJoinRefIterator::PushedJoinRefIterator(THD *thd, TABLE *table,
-                                             TABLE_REF *ref, bool use_order,
+                                             Index_lookup *ref, bool use_order,
                                              bool is_unique,
                                              ha_rows *examined_rows)
     : TableRowIterator(thd, table),
@@ -285,7 +285,7 @@ int PushedJoinRefIterator::Read() {
       return -1;
     }
 
-    if (construct_lookup_ref(thd(), table(), m_ref)) {
+    if (construct_lookup(thd(), table(), m_ref)) {
       table()->set_no_row();
       return -1;
     }
@@ -373,7 +373,7 @@ int RefIterator<false>::Read() {  // Forward read.
       table()->set_no_row();
       return -1;
     }
-    if (construct_lookup_ref(thd(), table(), m_ref)) {
+    if (construct_lookup(thd(), table(), m_ref)) {
       table()->set_no_row();
       return -1;
     }
@@ -426,7 +426,7 @@ int RefIterator<true>::Read() {  // Reverse read.
       table()->set_no_row();
       return -1;
     }
-    if (construct_lookup_ref(thd(), table(), m_ref)) {
+    if (construct_lookup(thd(), table(), m_ref)) {
       table()->set_no_row();
       return -1;
     }
@@ -612,7 +612,7 @@ int DynamicRangeIterator::Read() {
 }
 
 FullTextSearchIterator::FullTextSearchIterator(THD *thd, TABLE *table,
-                                               TABLE_REF *ref,
+                                               Index_lookup *ref,
                                                Item_func_match *ft_func,
                                                bool use_order, bool use_limit,
                                                ha_rows *examined_rows)
@@ -704,7 +704,7 @@ int FullTextSearchIterator::Read() {
   Reading of key with key reference and one part that may be NULL.
 */
 
-RefOrNullIterator::RefOrNullIterator(THD *thd, TABLE *table, TABLE_REF *ref,
+RefOrNullIterator::RefOrNullIterator(THD *thd, TABLE *table, Index_lookup *ref,
                                      bool use_order, double expected_rows,
                                      ha_rows *examined_rows)
     : TableRowIterator(thd, table),
@@ -735,7 +735,7 @@ int RefOrNullIterator::Read() {
     /* Perform "Late NULLs Filtering" (see internals manual for explanations)
      */
     if (m_ref->impossible_null_ref() ||
-        construct_lookup_ref(thd(), table(), m_ref)) {
+        construct_lookup(thd(), table(), m_ref)) {
       // Skip searching for non-NULL rows; go straight to NULL rows.
       *m_ref->null_ref_key = true;
     }
@@ -787,7 +787,7 @@ RefOrNullIterator::~RefOrNullIterator() {
 
 AlternativeIterator::AlternativeIterator(
     THD *thd, TABLE *table, unique_ptr_destroy_only<RowIterator> source,
-    unique_ptr_destroy_only<RowIterator> table_scan_iterator, TABLE_REF *ref)
+    unique_ptr_destroy_only<RowIterator> table_scan_iterator, Index_lookup *ref)
     : RowIterator(thd),
       m_source_iterator(std::move(source)),
       m_table_scan_iterator(std::move(table_scan_iterator)),
@@ -970,7 +970,7 @@ int TableValueConstructorIterator::Read() {
 }
 
 static inline pair<uchar *, key_part_map> FindKeyBufferAndMap(
-    const TABLE_REF *ref) {
+    const Index_lookup *ref) {
   if (ref->keypart_hash != nullptr) {
     return make_pair(pointer_cast<uchar *>(ref->keypart_hash), key_part_map{1});
   } else {

Diff for: sql/iterators/ref_row_iterators.h

@@ -36,8 +36,8 @@
 class Item_func_match;
 class QEP_TAB;
 class THD;
+struct Index_lookup;
 struct TABLE;
-struct TABLE_REF;
 
 /**
   For each record on the left side of a join (given in Init()), returns one or
@@ -47,7 +47,7 @@ template <bool Reverse>
 class RefIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  RefIterator(THD *thd, TABLE *table, TABLE_REF *ref, bool use_order,
+  RefIterator(THD *thd, TABLE *table, Index_lookup *ref, bool use_order,
               double expected_rows, ha_rows *examined_rows)
       : TableRowIterator(thd, table),
         m_ref(ref),
@@ -60,7 +60,7 @@ class RefIterator final : public TableRowIterator {
   int Read() override;
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   const bool m_use_order;
   const double m_expected_rows;
   ha_rows *const m_examined_rows;
@@ -75,15 +75,15 @@ class RefIterator final : public TableRowIterator {
 class RefOrNullIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  RefOrNullIterator(THD *thd, TABLE *table, TABLE_REF *ref, bool use_order,
+  RefOrNullIterator(THD *thd, TABLE *table, Index_lookup *ref, bool use_order,
                     double expected_rows, ha_rows *examined_rows);
   ~RefOrNullIterator() override;
 
   bool Init() override;
   int Read() override;
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   const bool m_use_order;
   bool m_reading_first_row;
   const double m_expected_rows;
@@ -100,7 +100,8 @@ 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, ha_rows *examined_rows);
+  EQRefIterator(THD *thd, TABLE *table, Index_lookup *ref,
+                ha_rows *examined_rows);
 
   bool Init() override;
   int Read() override;
@@ -115,7 +116,7 @@ class EQRefIterator final : public TableRowIterator {
   void StartPSIBatchMode() override {}
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   bool m_first_record_since_init;
   ha_rows *const m_examined_rows;
 };
@@ -127,7 +128,7 @@ class EQRefIterator final : public TableRowIterator {
 class ConstIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  ConstIterator(THD *thd, TABLE *table, TABLE_REF *table_ref,
+  ConstIterator(THD *thd, TABLE *table, Index_lookup *table_ref,
                 ha_rows *examined_rows);
 
   bool Init() override;
@@ -141,7 +142,7 @@ class ConstIterator final : public TableRowIterator {
   void UnlockRow() override {}
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   bool m_first_record_since_init;
   ha_rows *const m_examined_rows;
 };
@@ -150,7 +151,7 @@ class ConstIterator final : public TableRowIterator {
 class FullTextSearchIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  FullTextSearchIterator(THD *thd, TABLE *table, TABLE_REF *ref,
+  FullTextSearchIterator(THD *thd, TABLE *table, Index_lookup *ref,
                          Item_func_match *ft_func, bool use_order,
                          bool use_limit, ha_rows *examined_rows);
   ~FullTextSearchIterator() override;
@@ -159,7 +160,7 @@ class FullTextSearchIterator final : public TableRowIterator {
   int Read() override;
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   Item_func_match *const m_ft_func;
   const bool m_use_order;
   const bool m_use_limit;
@@ -253,14 +254,14 @@ class DynamicRangeIterator final : public TableRowIterator {
 class PushedJoinRefIterator final : public TableRowIterator {
  public:
   // "examined_rows", if not nullptr, is incremented for each successful Read().
-  PushedJoinRefIterator(THD *thd, TABLE *table, TABLE_REF *ref, bool use_order,
-                        bool is_unique, ha_rows *examined_rows);
+  PushedJoinRefIterator(THD *thd, TABLE *table, Index_lookup *ref,
+                        bool use_order, bool is_unique, ha_rows *examined_rows);
 
   bool Init() override;
   int Read() override;
 
  private:
-  TABLE_REF *const m_ref;
+  Index_lookup *const m_ref;
   const bool m_use_order;
   const bool m_is_unique;
   bool m_first_record_since_init;
@@ -283,7 +284,7 @@ class AlternativeIterator final : public RowIterator {
   AlternativeIterator(THD *thd, TABLE *table,
                       unique_ptr_destroy_only<RowIterator> source,
                       unique_ptr_destroy_only<RowIterator> table_scan_iterator,
-                      TABLE_REF *ref);
+                      Index_lookup *ref);
 
   bool Init() override;
 

Diff for: sql/iterators/row_iterator.h

@@ -96,7 +96,7 @@ class RowIterator {
 
     You can call Init() multiple times; subsequent calls will rewind the
     iterator (or reposition it, depending on whether the iterator takes in
-    e.g. a TABLE_REF) and allow you to read the records anew.
+    e.g. a Index_lookup) and allow you to read the records anew.
    */
   virtual bool Init() = 0;