Bug #30254797: REPLACE VECTOR<QEP_TAB *> WITH BITMAPS

There are several places in the translation of pre-iterator executor code (in
particular, to hash joins, but also in a few other places) where we should
juse use a bitmap. Do so, and also add a convenience class for looping over
such bitmaps using range-based for loops.

This saves ~1.3 kB of generated code in an optimized build.

Change-Id: I7fa2a8982f51d2dcfc6fe1293156a644fb5ba0ef

Author: Steinar H. Gunderson

Diff for: include/my_table_map.h

@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+   Copyright (c) 2016, 2019, 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, version 2.0,
@@ -24,12 +24,22 @@
 #ifndef MY_TABLE_MAP_INCLUDED
 #define MY_TABLE_MAP_INCLUDED
 
+#include "my_dbug.h"
 #include "my_inttypes.h"
 
-/*
-  TODO Convert these to use Bitmap class.
- */
-typedef ulonglong table_map;   /* Used for table bits in join */
-typedef ulonglong nesting_map; /* Used for flags of nesting constructs */
+using table_map = uint64_t;    // Used for table bits in join.
+using nesting_map = uint64_t;  // Used for flags of nesting constructs.
+using qep_tab_map = uint64_t;  // Used for indexing QEP_TABs in a JOIN.
+
+// Returns a bitmap representing the semi-open interval [start, end).
+static inline uint64_t TablesBetween(unsigned start, unsigned end) {
+  DBUG_ASSERT(end >= start);
+  return (uint64_t{1} << end) - (uint64_t{1} << start);
+}
+
+// Test whether "map" contains the given table.
+static inline bool ContainsTable(uint64_t map, unsigned idx) {
+  return map & (uint64_t{1} << idx);
+}
 
 #endif  // MY_TABLE_MAP_INCLUDED

Diff for: include/tables_contained_in.h

@@ -0,0 +1,93 @@
+/*
+   Copyright (c) 2019, 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, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is also distributed with certain software (including
+   but not limited to OpenSSL) that is licensed under separate terms,
+   as designated in a particular file or component or in included license
+   documentation.  The authors of MySQL hereby grant you an additional
+   permission to link the program and your derivative works with the
+   separately licensed software that they have included with MySQL.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License, version 2.0, for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#ifndef TABLES_CONTAINED_IN_H_
+#define TABLES_CONTAINED_IN_H_
+
+#include <string.h>
+
+#include "my_inttypes.h"
+#include "sql/sql_optimizer.h"
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward64)
+#endif
+
+// A utility class to loop over all set bits in the given map.
+// Use as:
+//
+//   qep_tab_map = ...;
+//   for (QEP_TAB *qep_tab : TablesContainedIn(join, qep_tab_map)) {
+//      ...
+//   }
+class TablesContainedIn {
+ public:
+  class iterator {
+   private:
+    const JOIN *const m_join;
+    qep_tab_map m_bits_left;
+
+   public:
+    iterator(const JOIN *join, qep_tab_map map)
+        : m_join(join), m_bits_left(map) {}
+    bool operator==(const iterator &other) const {
+      DBUG_ASSERT(m_join == other.m_join);
+      return m_bits_left == other.m_bits_left;
+    }
+    bool operator!=(const iterator &other) const {
+      DBUG_ASSERT(m_join == other.m_join);
+      return m_bits_left != other.m_bits_left;
+    }
+    QEP_TAB *operator*() const {
+      // Find the QEP_TAB that corresponds to the lowest set bit.
+      DBUG_ASSERT(m_bits_left != 0);
+#ifdef _MSC_VER
+      unsigned long idx;
+      _BitScanForward64(&idx, m_bits_left);
+#else
+      size_t idx = ffsll(m_bits_left) - 1;
+#endif
+      DBUG_ASSERT(idx < m_join->tables);
+      return &m_join->qep_tab[idx];
+    }
+    iterator &operator++() {
+      // Clear the lowest set bit.
+      DBUG_ASSERT(m_bits_left != 0);
+      m_bits_left &= (m_bits_left - 1);
+      return *this;
+    }
+  };
+
+  TablesContainedIn(const JOIN *join, qep_tab_map map)
+      : m_join(join), m_initial_map(map) {}
+
+  iterator begin() const { return {m_join, m_initial_map}; }
+  iterator end() const { return {m_join, 0}; }
+
+ private:
+  const JOIN *const m_join;
+  const qep_tab_map m_initial_map;
+};
+
+#endif  // TABLES_CONTAINED_IN_H_

Diff for: sql/bka_iterator.cc

@@ -52,9 +52,9 @@
 using std::string;
 using std::vector;
 
-BKAIterator::BKAIterator(THD *thd,
+BKAIterator::BKAIterator(THD *thd, JOIN *join,
                          unique_ptr_destroy_only<RowIterator> outer_input,
-                         const std::vector<QEP_TAB *> &outer_input_tables,
+                         qep_tab_map outer_input_tables,
                          unique_ptr_destroy_only<RowIterator> inner_input,
                          size_t max_memory_available,
                          size_t mrr_bytes_needed_for_single_inner_row,
@@ -65,7 +65,7 @@ BKAIterator::BKAIterator(THD *thd,
       m_inner_input(move(inner_input)),
       m_mem_root(key_memory_hash_join, 16384 /* 16 kB */),
       m_rows(&m_mem_root),
-      m_outer_input_tables(outer_input_tables),
+      m_outer_input_tables(join, outer_input_tables),
       m_max_memory_available(max_memory_available),
       m_mrr_bytes_needed_for_single_inner_row(
           mrr_bytes_needed_for_single_inner_row),
@@ -244,18 +244,19 @@ int BKAIterator::Read() {
   }
 }
 
-MultiRangeRowIterator::MultiRangeRowIterator(
-    THD *thd, const std::vector<QEP_TAB *> &outer_input_tables,
-    Item *cache_idx_cond, TABLE *table, bool keep_current_rowid, TABLE_REF *ref,
-    int mrr_flags)
+MultiRangeRowIterator::MultiRangeRowIterator(THD *thd, JOIN *join,
+                                             qep_tab_map outer_input_tables,
+                                             Item *cache_idx_cond, TABLE *table,
+                                             bool keep_current_rowid,
+                                             TABLE_REF *ref, int mrr_flags)
     : TableRowIterator(thd, table),
       m_cache_idx_cond(cache_idx_cond),
       m_keep_current_rowid(keep_current_rowid),
       m_table(table),
       m_file(table->file),
       m_ref(ref),
       m_mrr_flags(mrr_flags),
-      m_outer_input_tables(outer_input_tables) {}
+      m_outer_input_tables(join, outer_input_tables) {}
 
 bool MultiRangeRowIterator::Init() {
   /*

Diff for: sql/bka_iterator.h

@@ -80,6 +80,7 @@ class BKAIterator final : public RowIterator {
  public:
   /**
     @param thd Thread handle.
+    @param join The JOIN we are part of.
     @param outer_input The iterator to read the outer rows from.
     @param outer_input_tables QEP_TAB for each outer table involved.
       Used to know which fields we are to read into our buffer.
@@ -97,8 +98,9 @@ class BKAIterator final : public RowIterator {
     @param mrr_iterator Pointer to the MRR iterator at the bottom of
       inner_input. Used to send row ranges and buffers.
    */
-  BKAIterator(THD *thd, unique_ptr_destroy_only<RowIterator> outer_input,
-              const std::vector<QEP_TAB *> &outer_input_tables,
+  BKAIterator(THD *thd, JOIN *join,
+              unique_ptr_destroy_only<RowIterator> outer_input,
+              qep_tab_map outer_input_tables,
               unique_ptr_destroy_only<RowIterator> inner_input,
               size_t max_memory_available,
               size_t mrr_bytes_needed_for_single_inner_row,
@@ -233,6 +235,7 @@ class MultiRangeRowIterator final : public TableRowIterator {
  public:
   /**
     @param thd Thread handle.
+    @param join The JOIN we are part of.
     @param outer_input_tables QEP_TAB for each outer table involved.
       Used to know which fields we are to read back from the buffer.
     @param cache_idx_cond See m_cache_idx_cond.
@@ -243,8 +246,7 @@ class MultiRangeRowIterator final : public TableRowIterator {
     @param ref The index condition we are looking up on.
     @param mrr_flags Flags passed on to MRR.
    */
-  MultiRangeRowIterator(THD *thd,
-                        const std::vector<QEP_TAB *> &outer_input_tables,
+  MultiRangeRowIterator(THD *thd, JOIN *join, qep_tab_map outer_input_tables,
                         Item *cache_idx_cond, TABLE *table,
                         bool keep_current_rowid, TABLE_REF *ref, int mrr_flags);
 

Diff for: sql/hash_join_buffer.cc

@@ -41,7 +41,9 @@
 #include "sql/psi_memory_key.h"
 #include "sql/sql_executor.h"
 #include "sql/sql_join_buffer.h"
+#include "sql/sql_optimizer.h"
 #include "sql/table.h"
+#include "tables_contained_in.h"
 #include "template_utils.h"
 
 namespace hash_join_buffer {
@@ -92,56 +94,57 @@ Table::Table(QEP_TAB *qep_tab)
 // with no columns, like t2 in the following query:
 //
 //   SELECT t1.col1 FROM t1, t2;  # t2 will be included without any columns.
-TableCollection::TableCollection(const std::vector<QEP_TAB *> &tables)
-    : m_tables_bitmap(0),
-      m_ref_and_null_bytes_size(0),
-      m_has_blob_column(false) {
-  for (QEP_TAB *qep_tab : tables) {
-    m_tables_bitmap |= qep_tab->table_ref->map();
-
-    // When constructing the iterator tree, we might end up adding a
-    // WeedoutIterator _after_ a HashJoinIterator has been constructed.
-    // When adding the WeedoutIterator, QEP_TAB::rowid_status will be changed
-    // indicate that a row ID is needed. A side effect of this is that
-    // rowid_status might say that no row ID is needed here, while it says
-    // otherwise while hash join is executing. As such, we may write outside of
-    // the allocated buffers since we did not take the size of the row ID into
-    // account here. To overcome this, we always assume that the row ID should
-    // be kept; reserving some extra bytes in a few buffers should not be an
-    // issue.
-    m_ref_and_null_bytes_size += qep_tab->table()->file->ref_length;
-
-    if (qep_tab->table()->is_nullable()) {
-      m_ref_and_null_bytes_size += sizeof(qep_tab->table()->null_row);
-    }
+TableCollection::TableCollection(const JOIN *join, qep_tab_map tables) {
+  for (QEP_TAB *qep_tab : TablesContainedIn(join, tables)) {
+    AddTable(qep_tab);
+  }
+}
 
-    Table table(qep_tab);
-    for (const hash_join_buffer::Column &column : table.columns) {
-      // Field_typed_array will mask away the BLOB_FLAG for all types. Hence,
-      // we will treat all Field_typed_array as blob columns.
-      if ((column.field->flags & BLOB_FLAG) > 0 || column.field->is_array()) {
-        m_has_blob_column = true;
-      }
+void TableCollection::AddTable(QEP_TAB *qep_tab) {
+  m_tables_bitmap |= qep_tab->table_ref->map();
+
+  // When constructing the iterator tree, we might end up adding a
+  // WeedoutIterator _after_ a HashJoinIterator has been constructed.
+  // When adding the WeedoutIterator, QEP_TAB::rowid_status will be changed
+  // indicate that a row ID is needed. A side effect of this is that
+  // rowid_status might say that no row ID is needed here, while it says
+  // otherwise while hash join is executing. As such, we may write outside of
+  // the allocated buffers since we did not take the size of the row ID into
+  // account here. To overcome this, we always assume that the row ID should
+  // be kept; reserving some extra bytes in a few buffers should not be an
+  // issue.
+  m_ref_and_null_bytes_size += qep_tab->table()->file->ref_length;
+
+  if (qep_tab->table()->is_nullable()) {
+    m_ref_and_null_bytes_size += sizeof(qep_tab->table()->null_row);
+  }
 
-      // If a column is marked as nullable, we need to copy the NULL flags.
-      if ((column.field->flags & NOT_NULL_FLAG) == 0) {
-        table.copy_null_flags = true;
-      }
+  Table table(qep_tab);
+  for (const hash_join_buffer::Column &column : table.columns) {
+    // Field_typed_array will mask away the BLOB_FLAG for all types. Hence,
+    // we will treat all Field_typed_array as blob columns.
+    if ((column.field->flags & BLOB_FLAG) > 0 || column.field->is_array()) {
+      m_has_blob_column = true;
+    }
 
-      // BIT fields stores some of its data in the NULL flags of the table. So
-      // if we have a BIT field, we must copy the NULL flags.
-      if (column.field->type() == MYSQL_TYPE_BIT &&
-          down_cast<const Field_bit *>(column.field)->bit_len > 0) {
-        table.copy_null_flags = true;
-      }
+    // If a column is marked as nullable, we need to copy the NULL flags.
+    if ((column.field->flags & NOT_NULL_FLAG) == 0) {
+      table.copy_null_flags = true;
     }
 
-    if (table.copy_null_flags) {
-      m_ref_and_null_bytes_size += qep_tab->table()->s->null_bytes;
+    // BIT fields stores some of its data in the NULL flags of the table. So
+    // if we have a BIT field, we must copy the NULL flags.
+    if (column.field->type() == MYSQL_TYPE_BIT &&
+        down_cast<const Field_bit *>(column.field)->bit_len > 0) {
+      table.copy_null_flags = true;
     }
+  }
 
-    m_tables.push_back(table);
+  if (table.copy_null_flags) {
+    m_ref_and_null_bytes_size += qep_tab->table()->s->null_bytes;
   }
+
+  m_tables.push_back(table);
 }
 
 // Calculate how many bytes the data in the column uses. We don't bother

Diff for: sql/hash_join_buffer.h

@@ -119,7 +119,12 @@ class TableCollection {
  public:
   TableCollection() = default;
 
-  explicit TableCollection(const std::vector<QEP_TAB *> &tables);
+  explicit TableCollection(QEP_TAB *qep_tab) {
+    // Single table.
+    AddTable(qep_tab);
+  }
+
+  TableCollection(const JOIN *join, qep_tab_map tables);  // Multiple tables.
 
   const Prealloced_array<Table, 4> &tables() const { return m_tables; }
 
@@ -130,21 +135,23 @@ class TableCollection {
   bool has_blob_column() const { return m_has_blob_column; }
 
  private:
+  void AddTable(QEP_TAB *qep_tab);
+
   Prealloced_array<Table, 4> m_tables{PSI_NOT_INSTRUMENTED};
 
   // We frequently use the bitmap to determine which side of the join an Item
   // belongs to, so precomputing the bitmap saves quite some time.
-  table_map m_tables_bitmap;
+  table_map m_tables_bitmap = 0;
 
   // Sum of the NULL bytes and the row ID for all of the tables.
-  size_t m_ref_and_null_bytes_size;
+  size_t m_ref_and_null_bytes_size = 0;
 
   // Whether any of the tables has a BLOB/TEXT column. This is used to determine
   // whether we need to estimate the row size every time we store a row to the
   // row buffer or to a chunk file on disk. If this is set to false, we can
   // pre-allocate any necessary buffers we need during the hash join, and thus
   // eliminate the need for recalculating the row size every time.
-  bool m_has_blob_column;
+  bool m_has_blob_column = false;
 };
 
 /// Count up how many bytes a single row from the given tables will occupy,

Diff for: sql/hash_join_iterator.cc

@@ -45,6 +45,7 @@
 #include "sql/row_iterator.h"
 #include "sql/sql_class.h"
 #include "sql/sql_executor.h"
+#include "sql/sql_optimizer.h"
 #include "sql/sql_select.h"
 #include "sql/table.h"
 
@@ -65,7 +66,7 @@ static std::vector<HashJoinCondition> ItemToHashJoinConditions(
 
 HashJoinIterator::HashJoinIterator(
     THD *thd, unique_ptr_destroy_only<RowIterator> build_input,
-    const std::vector<QEP_TAB *> &build_input_tables,
+    qep_tab_map build_input_tables,
     unique_ptr_destroy_only<RowIterator> probe_input,
     QEP_TAB *probe_input_table, size_t max_memory_available,
     const std::vector<Item_func_eq *> &join_conditions,
@@ -74,8 +75,8 @@ HashJoinIterator::HashJoinIterator(
       m_state(State::READING_ROW_FROM_PROBE_ITERATOR),
       m_build_input(move(build_input)),
       m_probe_input(move(probe_input)),
-      m_probe_input_table({probe_input_table}),
-      m_build_input_tables(build_input_tables),
+      m_probe_input_table(probe_input_table),
+      m_build_input_tables(probe_input_table->join(), build_input_tables),
       m_row_buffer(m_build_input_tables,
                    ItemToHashJoinConditions(join_conditions, thd->mem_root),
                    max_memory_available),