PS-9647: MySQL Perf Improvements

https://perconadev.atlassian.net/browse/PS-9647

This patch uses list instead of deque for memory efficiency reasons,
primarily to optimize operations like bulk insert

Author: Venkatesh Prasad

include/mem_root_deque.h

@@ -575,9 +575,10 @@ inline bool param_type_uses_non_param_inner(THD *thd, uint arg_count,
           return false;
         if (args[j]->type() == Item::ROW_ITEM)
           arguments[j] = down_cast<Item_row *>(args[j])->element_index(i);
-        else if (args[j]->type() == Item::SUBSELECT_ITEM)
+        else if (args[j]->type() == Item::SUBSELECT_ITEM) {
           arguments[j] = (*down_cast<Item_subselect *>(args[j])
                                ->unit->get_unit_column_types())[i];
+        }
       }
       if (param_type_uses_non_param_inner(thd, arg_count, arguments, def))
         return true;

sql/item_func.cc

@@ -9482,7 +9482,8 @@ bool insert_fields(THD *thd, Query_block *query_block, const char *db_name,
         **it = item; /* Replace '*' with the first found item. */
       } else {
         /* Add 'item' to the SELECT list, after the current one. */
-        *it = fields->insert(*it + 1, item);
+        mem_root_deque<Item *>::iterator next_it = ++(*it);
+        *it = fields->insert(next_it, item);
       }
 
       /*

sql/sql_base.cc

@@ -545,10 +545,9 @@ bool copy_field_info(THD *thd, Item *orig_expr, Item *cloned_expr) {
                  }
                  if (inner_item->type() == Item::FIELD_ITEM) {
                    Item_field *field = down_cast<Item_field *>(inner_item);
-                   if (field_info.push_back(
+                   field_info.push_back(
                            Field_info(context, field->table_ref, depended_from,
-                                      field->cached_table, field->field)))
-                     return true;
+                                      field->cached_table, field->field));
                  }
                  return false;
                }))

sql/sql_derived.cc

@@ -4345,7 +4345,7 @@ bool change_to_use_tmp_fields(mem_root_deque<Item *> *fields, THD *thd,
         Item_field *new_field = new Item_field(field);
         if (!suv || !new_field) return true;  // Fatal error
         mem_root_deque<Item *> list(thd->mem_root);
-        if (list.push_back(new_field)) return true;
+        list.push_back(new_field);
         if (suv->set_arguments(&list, true)) return true;
         new_item = suv;
       } else

sql/sql_executor.cc

@@ -7048,11 +7048,13 @@ static uint get_semi_join_select_list_index(Item_field *item_field) {
   if (emb_sj_nest && emb_sj_nest->is_sj_or_aj_nest()) {
     const mem_root_deque<Item *> &items =
         emb_sj_nest->nested_join->sj_inner_exprs;
-    for (size_t i = 0; i < items.size(); i++) {
-      const Item *sel_item = items[i];
+    size_t i = 0;
+    for (auto it = items.begin(); it != items.end(); ++it) {
+      const Item *sel_item = *it;
       if (sel_item->type() == Item::FIELD_ITEM &&
           down_cast<const Item_field *>(sel_item)->field->eq(item_field->field))
         return i;
+      i++;
     }
   }
   return UINT_MAX;

sql/sql_optimizer.cc

@@ -1304,7 +1304,9 @@ void free_items(Item *item) {
 */
 void cleanup_items(Item *item) {
   DBUG_TRACE;
-  for (; item; item = item->next_free) item->cleanup();
+  for (; item; item = item->next_free) {
+    item->cleanup();
+  }
 }
 
 /**

sql/sql_parse.cc

@@ -5324,6 +5324,7 @@ bool Query_block::resolve_table_value_constructor_values(THD *thd) {
     }
 
     size_t item_index = 0;
+    auto field_it = fields.begin();
     for (auto it = values_row->begin(); it != values_row->end(); ++it) {
       Item *item = *it;
       if ((!item->fixed && item->fix_fields(thd, &*it)) ||
@@ -5356,7 +5357,9 @@ bool Query_block::resolve_table_value_constructor_values(THD *thd) {
         // Make sure to also replace the reference in item_list. In the case
         // where fix_fields transforms an item, it.ref() will only update the
         // reference of values_row.
-        if (first_execution) fields[item_index] = item;
+        if (first_execution) {
+          *field_it = item;
+        }
       } else {
         Item_values_column *column = down_cast<Item_values_column *>(
             GetNthVisibleField(fields, item_index));
@@ -5365,6 +5368,7 @@ bool Query_block::resolve_table_value_constructor_values(THD *thd) {
         column->fixed = true;  // Does not have regular fix_fields()
       }
 
+      field_it++;
       ++item_index;
     }
 
@@ -5561,8 +5565,12 @@ bool Query_block::transform_table_subquery_to_join_with_derived(
 
     // Append inner expressions of decorrelated equalities to the SELECT
     // list. Correct context info of outer expressions.
-    auto it_outer = sj_outer_exprs.begin() + initial_sj_inner_exprs_count;
-    auto it_inner = sj_inner_exprs.begin() + initial_sj_inner_exprs_count;
+    auto it_outer = sj_outer_exprs.begin();
+    auto it_inner = sj_inner_exprs.begin();
+    for (int i = 0; i < initial_sj_inner_exprs_count; i++) {
+      it_outer++;
+      it_inner++;
+    }
     for (int i = 0; it_outer != sj_outer_exprs.end();
          ++it_outer, ++it_inner, ++i) {
       Item *inner = *it_inner;
@@ -6738,12 +6746,13 @@ bool Query_block::nest_derived(THD *thd, Item *join_cond,
                            return tl->join_cond() == join_cond;
                          });
   assert(it != copy_list.end());  // assert that we found it
-  const size_t idx = it - copy_list.begin();
-
-  // Insert back all outer tables to the inner containing the condition.
-  // Normally only one.
-  for (size_t i = 0; i < idx; i++) {
-    jlist.push_front(copy_list[i]);
+  size_t idx = 0;
+  for (auto tmp = copy_list.begin(); tmp != copy_list.end(); ++tmp) {
+    if (it == tmp) {
+      break;
+    }
+    jlist.push_front(*tmp);
+    idx++;
   }
 
   // Insert the derived table and nest it with the outer(s)
@@ -6854,11 +6863,6 @@ bool Query_block::decorrelate_derived_scalar_subquery_pre(
       if (selected_field == nullptr || f->field != selected_field->field) {
         m_added_non_hidden_fields++;
 
-        // If f->hidden, f should be among the hidden fields in 'fields'.
-        assert(std::any_of(fields.cbegin(), fields.cbegin() + first_non_hidden,
-                           [&f](const Item *item) { return f == item; }) ==
-               f->hidden);
-
         Item_field *inner_field;
 
         if (f->hidden) {

sql/sql_resolver.cc

@@ -2125,7 +2125,8 @@ static bool AddRowIdAsTempTableField(THD *thd, TABLE *table,
   Item_field *ifield = new (thd->mem_root) Item_field(field);
   if (ifield == nullptr) return true;
   ifield->set_nullable(false);
-  return fields->push_back(ifield);
+  fields->push_back(ifield);
+  return false;
 }
 
 /// Stores the current row ID of "table" in the specified field of "tmp_table".

sql/sql_update.cc

@@ -142,7 +142,6 @@ SET(TESTS
   like_range
   m_string
   mdl
-  mem_root_deque
   mutex_lock
   my_alloc
   my_bitmap