Bug#33364732: Preliminary fixes for WL#14673 [force_sort_rowids]

Rename Filesort::m_force_sort_positions to m_force_sort_rowids.
“sort_positions” is a name that is left over after some old filesort
code, and it's not that descriptive.

Change-Id: I369eb34bc436aca66521c3cb3a4a601425f0536c

Author: kahatlen

sql/filesort.cc

@@ -160,7 +160,7 @@ static bool check_if_pq_applicable(Opt_trace_context *trace, Sort_param *param,
 
 void Sort_param::decide_addon_fields(Filesort *file_sort,
                                      const Mem_root_array<TABLE *> &tables,
-                                     bool force_sort_positions) {
+                                     bool force_sort_rowids) {
   if (m_addon_fields_status != Addon_fields_status::unknown_status) {
     // Already decided.
     return;
@@ -194,7 +194,7 @@ void Sort_param::decide_addon_fields(Filesort *file_sort,
     }
   }
 
-  if (force_sort_positions) {
+  if (force_sort_rowids) {
     m_addon_fields_status = Addon_fields_status::keep_rowid;
   } else {
     /*
@@ -230,7 +230,7 @@ void Sort_param::init_for_filesort(Filesort *file_sort,
 
   local_sortorder = sf_array;
 
-  decide_addon_fields(file_sort, tables, file_sort->m_force_sort_positions);
+  decide_addon_fields(file_sort, tables, file_sort->m_force_sort_rowids);
   if (using_addon_fields()) {
     fixed_res_length = m_addon_length;
   } else {
@@ -357,7 +357,7 @@ static void trace_filesort_information(Opt_trace_context *trace,
                              applying WHERE condition.
 
   @note
-    If we sort by position (like if sort_positions is 1) filesort() will
+    If we sort row IDs (as opposed to addon fields), filesort() will
     call table->prepare_for_position().
 
   @returns   False if success, true if error
@@ -669,7 +669,7 @@ void filesort_free_buffers(TABLE *table, bool full) {
 
 Filesort::Filesort(THD *thd, Mem_root_array<TABLE *> tables_arg,
                    bool keep_buffers_arg, ORDER *order, ha_rows limit_arg,
-                   bool remove_duplicates, bool sort_positions,
+                   bool remove_duplicates, bool force_sort_rowids,
                    bool unwrap_rollup)
     : m_thd(thd),
       tables(std::move(tables_arg)),
@@ -678,7 +678,7 @@ Filesort::Filesort(THD *thd, Mem_root_array<TABLE *> tables_arg,
       sortorder(nullptr),
       using_pq(false),
       m_remove_duplicates(remove_duplicates),
-      m_force_sort_positions(sort_positions),
+      m_force_sort_rowids(force_sort_rowids),
       m_sort_order_length(make_sortorder(order, unwrap_rollup)) {}
 
 uint Filesort::make_sortorder(ORDER *order, bool unwrap_rollup) {
@@ -2297,7 +2297,7 @@ Addon_fields *Filesort::get_addon_fields(
 bool Filesort::using_addon_fields() {
   if (m_sort_param.m_addon_fields_status ==
       Addon_fields_status::unknown_status) {
-    m_sort_param.decide_addon_fields(this, tables, m_force_sort_positions);
+    m_sort_param.decide_addon_fields(this, tables, m_force_sort_rowids);
   }
   return m_sort_param.using_addon_fields();
 }

sql/filesort.h

@@ -66,7 +66,7 @@ class Filesort {
   // If true, we will always sort references to rows on table (and crucially,
   // the result iterators used will always position the underlying table on
   // the original row before returning from Read()).
-  bool m_force_sort_positions;
+  bool m_force_sort_rowids;
   // TODO: Consider moving this into private members of Filesort.
   Sort_param m_sort_param;
 
@@ -75,7 +75,7 @@ class Filesort {
   // so we can't do that yet.
   Filesort(THD *thd, Mem_root_array<TABLE *> tables, bool keep_buffers,
            ORDER *order, ha_rows limit_arg, bool remove_duplicates,
-           bool force_sort_positions, bool unwrap_rollup);
+           bool force_sort_rowids, bool unwrap_rollup);
 
   Addon_fields *get_addon_fields(Addon_fields_status *addon_fields_status,
                                  uint *plength, uint *ppackable_length);

sql/sort_param.h

@@ -330,7 +330,7 @@ class Sort_param {
   /// precise estimation of packed row size.
   void decide_addon_fields(Filesort *file_sort,
                            const Mem_root_array<TABLE *> &tables,
-                           bool sort_positions);
+                           bool force_sort_rowids);
 
   /// Reset the decision made in decide_addon_fields(). Only used in exceptional
   /// circumstances (see NewWeedoutAccessPathForTables()).

sql/sql_delete.cc

@@ -530,7 +530,7 @@ bool Sql_cmd_delete::delete_from_single_table(THD *thd) {
       fsort.reset(new (thd->mem_root) Filesort(
           thd, {table}, /*keep_buffers=*/false, order, HA_POS_ERROR,
           /*remove_duplicates=*/false,
-          /*force_sort_positions=*/true, /*unwrap_rollup=*/false));
+          /*force_sort_rowids=*/true, /*unwrap_rollup=*/false));
       path = NewSortAccessPath(thd, path, fsort.get(),
                                /*count_examined_rows=*/false);
       iterator = CreateIteratorFromAccessPath(thd, path, &join,

sql/sql_executor.cc

@@ -1187,7 +1187,7 @@ static AccessPath *NewWeedoutAccessPathForTables(
           // the previous (now wrong) decision there.
           filesort->clear_addon_fields();
         }
-        filesort->m_force_sort_positions = true;
+        filesort->m_force_sort_rowids = true;
       }
     }
   }
@@ -3029,7 +3029,7 @@ AccessPath *JOIN::create_root_access_path_for_join() {
         // Only const fields.
         limit_1_for_dup_filesort = true;
       } else {
-        bool force_sort_positions = false;
+        bool force_sort_rowids = false;
         if (all_order_fields_used) {
           // The ordering for DISTINCT already gave us the right sort order,
           // so no need to sort again.
@@ -3043,27 +3043,27 @@ AccessPath *JOIN::create_root_access_path_for_join() {
         } else if (filesort != nullptr && !filesort->using_addon_fields()) {
           // We have the rather unusual situation here that we have two sorts
           // directly after each other, with no temporary table in-between,
-          // and filesort expects to be able to refer to rows by their position.
+          // and filesort expects to be able to refer to rows by their row ID.
           // Usually, the sort for DISTINCT would be a superset of the sort for
           // ORDER BY, but not always (e.g. when sorting by some expression),
           // so we could end up in a situation where the first sort is by addon
           // fields and the second one is by positions.
           //
-          // Thus, in this case, we force the first sort to be by positions,
+          // Thus, in this case, we force the first sort to use row IDs,
           // so that the result comes from SortFileIndirectIterator or
           // SortBufferIndirectIterator. These will both position the cursor
           // on the underlying temporary table correctly before returning it,
-          // so that the successive filesort will save the right position
+          // so that the successive filesort will save the right row ID
           // for the row.
-          force_sort_positions = true;
+          force_sort_rowids = true;
         }
 
         // Switch to the right slice if applicable, so that we fetch out the
         // correct items from order_arg.
         Switch_ref_item_slice slice_switch(this, qep_tab->ref_item_slice);
         dup_filesort = new (thd->mem_root) Filesort(
             thd, {qep_tab->table()}, /*keep_buffers=*/false, order,
-            HA_POS_ERROR, /*remove_duplicates=*/true, force_sort_positions,
+            HA_POS_ERROR, /*remove_duplicates=*/true, force_sort_rowids,
             /*unwrap_rollup=*/false);
 
         if (desired_order != nullptr && filesort == nullptr) {
@@ -3072,7 +3072,7 @@ AccessPath *JOIN::create_root_access_path_for_join() {
           // potentially addon fields. Create a new one.
           filesort = new (thd->mem_root) Filesort(
               thd, {qep_tab->table()}, /*keep_buffers=*/false, desired_order,
-              HA_POS_ERROR, /*remove_duplicates=*/false, force_sort_positions,
+              HA_POS_ERROR, /*remove_duplicates=*/false, force_sort_rowids,
               /*unwrap_rollup=*/false);
         }
       }

sql/sql_select.cc

@@ -4815,7 +4815,7 @@ bool JOIN::add_sorting_to_table(uint idx, ORDER_with_src *sort_order,
   // by row ID), so if this table is part of a weedout operation, we need
   // to force sorting by row IDs -- sorting rows with addon fields returns
   // rows that have no reference to the underlying table object.
-  bool force_sort_position = false;
+  bool force_sort_rowids = false;
   for (plan_idx i = 0; i <= static_cast<plan_idx>(idx); ++i) {
     if (!qep_tab[i].starts_weedout()) {
       continue;
@@ -4830,7 +4830,7 @@ bool JOIN::add_sorting_to_table(uint idx, ORDER_with_src *sort_order,
     }
     if (weedout_end != NO_PLAN_IDX &&
         weedout_end > static_cast<plan_idx>(idx)) {
-      force_sort_position = true;
+      force_sort_rowids = true;
       break;
     }
   }
@@ -4851,7 +4851,7 @@ bool JOIN::add_sorting_to_table(uint idx, ORDER_with_src *sort_order,
     Switch_ref_item_slice slice_switch(this, tab->ref_item_slice);
     tab->filesort = new (thd->mem_root)
         Filesort(thd, {tab->table()}, keep_buffers, sort_order->order,
-                 HA_POS_ERROR, /*remove_duplicates=*/false, force_sort_position,
+                 HA_POS_ERROR, /*remove_duplicates=*/false, force_sort_rowids,
                  /*unwrap_rollup=*/sort_before_group);
     tab->filesort_pushed_order = sort_order->order;
   }

sql/sql_table.cc

@@ -18114,7 +18114,7 @@ static int copy_data_between_tables(
     }
     fsort.reset(new (thd->mem_root) Filesort(
         thd, {from}, /*keep_buffers=*/false, order, HA_POS_ERROR,
-        /*remove_duplicates=*/false, /*force_sort_positions=*/true,
+        /*remove_duplicates=*/false, /*force_sort_rowids=*/true,
         /*unwrap_rollup=*/false));
     path = NewSortAccessPath(thd, path, fsort.get(),
                              /*count_examined_rows=*/false);

sql/sql_update.cc

@@ -664,7 +664,7 @@ bool Sql_cmd_update::update_single_table(THD *thd) {
         fsort.reset(new (thd->mem_root) Filesort(
             thd, {table}, /*keep_buffers=*/false, order, limit,
             /*remove_duplicates=*/false,
-            /*force_sort_positions=*/true, /*unwrap_rollup=*/false));
+            /*force_sort_rowids=*/true, /*unwrap_rollup=*/false));
         path = NewSortAccessPath(thd, path, fsort.get(),
                                  /*count_examined_rows=*/false);
         iterator = CreateIteratorFromAccessPath(