Bug#36533080: Remove the field cached_table from class Item_ident

Removed the field cached_table from class Item_ident.
Replaced its use with a new field m_table_ref in the same class.
Also removed the field table_ref from class Item_field.
The field Item_ident::cached_table was used to reference a base table if
the column reference was against a base table, and it was used to
reference a view or derived table if the column reference was against
a view or derived table. The same purpose is now handled by m_table_ref.

Some obsolete code in Item_field::fix_fields() that was used for
repeated resolving when cached_table was set, was removed. This also
made it possible to remove the "outer_fixed" local variable.

Commented-out code in transform_table_subquery_to_join_with_derived()
was also deleted.

The field m_cached_table in class copy_field_info was also obsolete
and could be deleted.

Change-Id: I51565ad744060d3342e8fbb881fd1e32f652db08

Author: roylyseng

sql/aggregate_check.cc

@@ -399,7 +399,7 @@ bool Group_check::is_fd_on_source(Item *item) {
 
       Item_field *const item_field = down_cast<Item_field *>(item2);
       /**
-        @todo make table_ref non-NULL for gcols, then use it for 'tl'.
+        @todo make m_table_ref non-NULL for gcols, then use it for 'tl'.
         Do the same in Item_field::used_tables_for_level().
       */
       Table_ref *const tl = item_field->field->table->pos_in_table_list;
@@ -767,11 +767,7 @@ bool Group_check::is_in_fd_of_underlying(Item_ident *item) {
     Used_tables ut(select);
     (void)item->walk(&Item::used_tables_for_level, enum_walk::POSTFIX,
                      pointer_cast<uchar *>(&ut));
-    /*
-      todo When we eliminate all uses of cached_table, we can probably add a
-      derived_table_ref field to Item_view_ref objects and use it here.
-    */
-    Table_ref *const tl = item->cached_table;
+    Table_ref *const tl = item->m_table_ref;
     assert(tl->is_view_or_derived());
     /*
       We might find expression-based FDs in the result of the view's query
@@ -801,7 +797,7 @@ bool Group_check::is_in_fd_of_underlying(Item_ident *item) {
   else if (item->type() == Item::FIELD_ITEM) {
     Item_field *const item_field = down_cast<Item_field *>(item);
     /**
-      @todo make table_ref non-NULL for gcols, then use it for 'tl'.
+      @todo make m_table_ref non-NULL for gcols, then use it for 'tl'.
       Do the same in Item_field::used_tables_for_level().
     */
     Table_ref *const tl = item_field->field->table->pos_in_table_list;
@@ -1216,7 +1212,7 @@ bool Group_check::do_ident_check(Item_ident *i, table_map tm,
   switch (type) {
     case CHECK_GROUP:
       if (i->type() == Item::FIELD_ITEM &&
-          down_cast<Item_field *>(i)->table_ref->m_was_scalar_subquery) {
+          down_cast<Item_field *>(i)->m_table_ref->m_was_scalar_subquery) {
         // The table has exactly one row, thus this column is FD
         return false;
       }

sql/item.cc

@@ -4185,16 +4185,23 @@ class Item_ident : public Item {
     field_name is normally identical to Item::item_name.
   */
   const char *field_name;
-
-  /*
-    Cached pointer to table which contains this field, used for the same reason
-    by prep. stmt. too in case then we have not-fully qualified field.
-    0 - means no cached value.
-    @todo Notice that this is usually the same as Item_field::table_ref.
-          cached_table should be replaced by table_ref ASAP.
+  /**
+    Points to the Table_ref object of the table or view that the column or
+    reference is resolved against (only valid after resolving).
+    Notice that for the following types of "tables", no Table_ref object is
+    assigned and hence m_table_ref is NULL:
+     - Temporary tables assigned by join optimizer for sorting and aggregation.
+     - Stored procedure dummy tables.
+    For fields referencing such tables, table number is always 0, and other
+    uses of m_table_ref is not needed.
   */
-  Table_ref *cached_table;
-  Query_block *depended_from;
+  Table_ref *m_table_ref{nullptr};
+  /**
+    For a column or reference that is an outer reference, depended_from points
+    to the qualifying query block, otherwise it is NULL
+    (only valid after resolving).
+  */
+  Query_block *depended_from{nullptr};
 
   Item_ident(Name_resolution_context *context_arg, const char *db_name_arg,
              const char *table_name_arg, const char *field_name_arg)
@@ -4205,9 +4212,7 @@ class Item_ident : public Item {
         context(context_arg),
         db_name(db_name_arg),
         table_name(table_name_arg),
-        field_name(field_name_arg),
-        cached_table(nullptr),
-        depended_from(nullptr) {
+        field_name(field_name_arg) {
     item_name.set(field_name_arg);
   }
 
@@ -4220,9 +4225,7 @@ class Item_ident : public Item {
         m_alias_of_expr(false),
         db_name(db_name_arg),
         table_name(table_name_arg),
-        field_name(field_name_arg),
-        cached_table(nullptr),
-        depended_from(nullptr) {
+        field_name(field_name_arg) {
     item_name.set(field_name_arg);
   }
 
@@ -4238,7 +4241,7 @@ class Item_ident : public Item {
         db_name(item->db_name),
         table_name(item->table_name),
         field_name(item->field_name),
-        cached_table(item->cached_table),
+        m_table_ref(item->m_table_ref),
         depended_from(item->depended_from) {}
 
   bool do_itemize(Parse_context *pc, Item **res) override;
@@ -4380,16 +4383,6 @@ class Item_field : public Item_ident {
                                              bool no_conversions) override;
 
  public:
-  /**
-    Table containing this resolved field. This is required e.g for calculation
-    of table map. Notice that for the following types of "tables",
-    no Table_ref object is assigned and hence table_ref is NULL:
-     - Temporary tables assigned by join optimizer for sorting and aggregation.
-     - Stored procedure dummy tables.
-    For fields referencing such tables, table number is always 0, and other
-    uses of table_ref is not needed.
-  */
-  Table_ref *table_ref{nullptr};
   /// Source field
   Field *field{nullptr};
 
@@ -4581,7 +4574,7 @@ class Item_field : public Item_ident {
              enum_query_type query_type) const override;
   bool is_outer_field() const override {
     assert(fixed);
-    return table_ref->outer_join || table_ref->outer_join_nest();
+    return m_table_ref->outer_join || m_table_ref->outer_join_nest();
   }
   Field::geometry_type get_geometry_type() const override {
     assert(data_type() == MYSQL_TYPE_GEOMETRY);
@@ -6147,21 +6140,21 @@ class Item_view_ref final : public Item_ref {
   Item_view_ref(Name_resolution_context *context_arg, Item **item,
                 const char *db_name_arg, const char *alias_name_arg,
                 const char *table_name_arg, const char *field_name_arg,
-                Table_ref *tl)
+                Table_ref *tr)
       : Item_ref(context_arg, item, db_name_arg, alias_name_arg,
                  field_name_arg),
         first_inner_table(nullptr) {
-    if (tl->is_view()) {
+    if (tr->is_view()) {
       m_orig_db_name = db_name_arg;
       m_orig_table_name = table_name_arg;
     } else {
       assert(db_name_arg == nullptr);
       m_orig_table_name = table_name_arg;
     }
-    cached_table = tl;
-    if (cached_table->is_inner_table_of_outer_join()) {
+    m_table_ref = tr;
+    if (m_table_ref->is_inner_table_of_outer_join()) {
       set_nullable(true);
-      first_inner_table = cached_table->any_outer_leaf_table();
+      first_inner_table = m_table_ref->any_outer_leaf_table();
     }
   }
 
@@ -6198,7 +6191,7 @@ class Item_view_ref final : public Item_ref {
     return !(inner_map & ~INNER_TABLE_BIT) && first_inner_table != nullptr
                ? ref_item()->real_item()->type() == FIELD_ITEM
                      ? down_cast<Item_field *>(ref_item()->real_item())
-                           ->table_ref->map()
+                           ->m_table_ref->map()
                      : first_inner_table->map()
                : inner_map;
   }
@@ -6899,8 +6892,8 @@ class Item_cache : public Item_basic_constant {
     add_accum_properties(item);
     if (item->type() == FIELD_ITEM) {
       cached_field = down_cast<Item_field *>(item);
-      if (cached_field->table_ref != nullptr)
-        used_table_map = cached_field->table_ref->map();
+      if (cached_field->m_table_ref != nullptr)
+        used_table_map = cached_field->m_table_ref->map();
     } else {
       used_table_map = item->used_tables();
     }

sql/item.h

@@ -7719,7 +7719,7 @@ bool Item_func_match::fix_fields(THD *thd, Item **ref) {
     my_error(ER_WRONG_ARGUMENTS, MYF(0), "MATCH");
     return true;
   }
-  table_ref = ((Item_field *)item)->table_ref;
+  table_ref = down_cast<Item_field *>(item)->m_table_ref;
 
   if (table_ref != nullptr) table_ref->set_fulltext_searched();
 
@@ -7732,8 +7732,9 @@ bool Item_func_match::fix_fields(THD *thd, Item **ref) {
     a generated column's generation expression it's not. Thus
     we use field's table, at this moment it's already available.
   */
-  TABLE *const table =
-      table_ref ? table_ref->table : ((Item_field *)item)->field->table;
+  TABLE *const table = table_ref != nullptr
+                           ? table_ref->table
+                           : down_cast<Item_field *>(item)->field->table;
 
   if (!(table->file->ha_table_flags() & HA_CAN_FULLTEXT)) {
     my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
@@ -7787,7 +7788,7 @@ bool Item_func_match::fix_index(const THD *thd) {
   uint ft_to_key[MAX_KEY], ft_cnt[MAX_KEY], fts = 0, keynr;
   uint max_cnt = 0, mkeys = 0, i;
 
-  if (!table_ref) goto err;
+  if (table_ref == nullptr) goto err;
 
   /*
     We will skip execution if the item is not fixed

sql/item_func.cc

@@ -717,7 +717,7 @@ static bool do_json_schema_validation(
     assert(!json_schema->const_item() ||
            (json_schema->real_item()->type() == Item::FIELD_ITEM &&
             down_cast<const Item_field *>(json_schema->real_item())
-                ->table_ref->table->const_table));
+                ->m_table_ref->table->const_table));
 
     assert(is_convertible_to_json(json_schema));
 

sql/item_json_func.cc

@@ -357,9 +357,9 @@ bool OrderItemsReferenceUnavailableTables(
                  [materialized_base_tables](Item *item) {
                    if (item->type() == Item::FIELD_ITEM) {
                      Item_field *item_field = down_cast<Item_field *>(item);
-                     return item_field->table_ref != nullptr &&
+                     return item_field->m_table_ref != nullptr &&
                             !item_field->is_outer_reference() &&
-                            Overlaps(item_field->table_ref->map(),
+                            Overlaps(item_field->m_table_ref->map(),
                                      materialized_base_tables);
                    }
                    return false;

sql/join_optimizer/finalize_plan.cc

@@ -472,7 +472,7 @@ bool optimize_aggregated_query(THD *thd, Query_block *select,
 
             ref.key_buff = key_buff;
             Item_field *item_field = down_cast<Item_field *>(expr);
-            Table_ref *tr = item_field->table_ref;
+            Table_ref *tr = item_field->m_table_ref;
             TABLE *table = tr->table;
             /*
               If table already has been read, we may use the values already
@@ -1067,7 +1067,7 @@ static bool find_key_for_maxmin(bool max_fl, Index_lookup *ref,
         key_part_map key_part_used = 0;
         *range_fl = NO_MIN_RANGE | NO_MAX_RANGE;
         if (matching_cond(max_fl, ref, keyinfo, part, cond,
-                          item_field->table_ref->map(), &key_part_used,
+                          item_field->m_table_ref->map(), &key_part_used,
                           range_fl, prefix_len) &&
             !(key_part_to_use & ~key_part_used)) {
           if (!max_fl && key_part_used == key_part_to_use && part->null_bit) {
@@ -1156,7 +1156,9 @@ static bool maxmin_in_range(bool max_fl, Item_field *item_field, Item *cond) {
   }
 
   // Check that condition actually references the specific table
-  if ((cond->used_tables() & item_field->table_ref->map()) == 0) return false;
+  if ((cond->used_tables() & item_field->m_table_ref->map()) == 0) {
+    return false;
+  }
   bool less_fl = false;
   switch (down_cast<Item_func *>(cond)->functype()) {
     case Item_func::BETWEEN:

sql/opt_sum.cc

@@ -773,15 +773,15 @@ static SEL_TREE *get_full_func_mm_tree(THD *thd, RANGE_OPT_PARAM *param,
     Item_field *item_field = static_cast<Item_field *>(predicand);
     Field *field = item_field->field;
 
-    if (!((ref_tables | item_field->table_ref->map()) & param_comp))
+    if (!((ref_tables | item_field->m_table_ref->map()) & param_comp))
       ftree = get_func_mm_tree(thd, param, prev_tables, read_tables,
                                remove_jump_scans, predicand, op, value, inv);
     Item_equal *item_equal = item_field->multi_equality();
     if (item_equal != nullptr) {
       for (Item_field &item : item_equal->get_fields()) {
         Field *f = item.field;
         if (!field->eq(f) &&
-            !((ref_tables | item.table_ref->map()) & param_comp)) {
+            !((ref_tables | item.m_table_ref->map()) & param_comp)) {
           tree = get_func_mm_tree(thd, param, prev_tables, read_tables,
                                   remove_jump_scans, &item, op, value, inv);
           ftree = !ftree ? tree : tree_and(param, ftree, tree);
@@ -977,7 +977,7 @@ SEL_TREE *get_mm_tree(THD *thd, RANGE_OPT_PARAM *param, table_map prev_tables,
       for (Item_field &field_item : item_equal->get_fields()) {
         Field *field = field_item.field;
         table_map param_comp = ~(prev_tables | read_tables | current_table);
-        if (!((ref_tables | field_item.table_ref->map()) & param_comp)) {
+        if (!((ref_tables | field_item.m_table_ref->map()) & param_comp)) {
           SEL_TREE *tree =
               get_mm_parts(thd, param, prev_tables, read_tables, item_equal,
                            field, Item_func::EQ_FUNC, value);

sql/range_optimizer/range_analysis.cc

@@ -8010,7 +8010,7 @@ Field *find_field_in_table_ref(THD *thd, Table_ref *table_list,
           return WRONG_GRANT;
       } else {
         assert(ref && *ref && (*ref)->fixed);
-        assert(*actual_table == (down_cast<Item_ident *>(*ref))->cached_table);
+        assert(*actual_table == down_cast<Item_ident *>(*ref)->m_table_ref);
 
         const Column_privilege_tracker tracker(thd, want_privilege);
         if ((*ref)->walk(&Item::check_column_privileges, enum_walk::PREFIX,
@@ -8118,7 +8118,7 @@ Field *find_field_in_tables(THD *thd, Item_ident *item, Table_ref *first_table,
 
   allow_rowid = table_name || (first_table && !first_table->next_local);
 
-  if (item->cached_table) {
+  if (item->m_table_ref != nullptr) {
     /*
       This shortcut is used by prepared statements. We assume that
       Table_ref *first_table is not changed during query execution (which
@@ -8128,21 +8128,18 @@ Field *find_field_in_tables(THD *thd, Item_ident *item, Table_ref *first_table,
       field makes some prepared query ambiguous and so erroneous, but we
       accept this trade off.
     */
-    Table_ref *table_ref = item->cached_table;
+    Table_ref *table_ref = item->m_table_ref;
 
     /*
       @todo WL#6570 - is this reasonable???
-      Also refactor this code to replace "cached_table" with "table_ref" -
-      as there is no longer need for more than one resolving, hence
-      no "caching" as well.
     */
     if (item->type() == Item::FIELD_ITEM)
       field_index = down_cast<Item_field *>(item)->field_index;
 
     /*
-      The condition (table_ref->view == NULL) ensures that we will call
+      The condition (m_table_ref->view == NULL) ensures that we will call
       find_field_in_table even in the case of information schema tables
-      when table_ref->field_translation != NULL.
+      when m_table_ref->field_translation != NULL.
     */
 
     if (table_ref->table && !table_ref->is_view()) {
@@ -8205,12 +8202,12 @@ Field *find_field_in_tables(THD *thd, Item_ident *item, Table_ref *first_table,
     if ((cur_field == nullptr && thd->is_error()) || cur_field == WRONG_GRANT)
       return nullptr;
 
-    if (cur_field) {
+    if (cur_field != nullptr) {
       /*
         Store the original table of the field, which may be different from
         cur_table in the case of NATURAL/USING join.
       */
-      item->cached_table =
+      item->m_table_ref =
           (!actual_table->cacheable_table || found) ? nullptr : actual_table;
 
       // @todo WL#6570 move this assignment to a more strategic place?
@@ -9255,7 +9252,7 @@ bool setup_fields(THD *thd, ulong want_privilege, bool allow_sum_func,
         my_error(ER_INVALID_ASSIGNMENT_TARGET, MYF(0), str.c_ptr());
         return true;
       }
-      Table_ref *tr = field->table_ref;
+      Table_ref *tr = field->m_table_ref;
       if ((want_privilege & UPDATE_ACL) && !tr->is_updatable()) {
         /*
           The base table of the column may have beeen referenced through a view
@@ -9573,7 +9570,7 @@ bool insert_fields(THD *thd, Query_block *query_block, const char *db_name,
         if (is_hidden) continue;
 
         /* cache the table for the Item_fields inserted by expanding stars */
-        if (tables->cacheable_table) field->cached_table = tables;
+        if (tables->cacheable_table) field->m_table_ref = tables;
       }
 
       if (!found) {
@@ -9719,7 +9716,7 @@ bool fill_record(THD *thd, TABLE *table, const mem_root_deque<Item *> &fields,
   auto value_it = VisibleFields(values).begin();
   for (Item *fld : VisibleFields(fields)) {
     Item_field *const field = fld->field_for_view_update();
-    assert(field != nullptr && field->table_ref->table == table);
+    assert(field != nullptr && field->m_table_ref->table == table);
 
     Field *const rfield = field->field;
     Item *value = *value_it++;