Bug #33521622: Allow developers to force certain subplans in the hypergraph join optimizer

Add a new debug option “subplan_tokens”.

If active, each access path gets a digest based on the subplan that it
represents. This can be used by developers to force a given subplan,
to investigate e.g. whether a given choice is actually faster in practice,
force-apply a plan from the old join optimizer (or at least the types of
subplans that are ever considered; e.g. aggregation through temporary
tables are not) into the hypergraph join optimizer (to see how it's costed),
or whether a given plan is even generated. If DEBUG contains
force_subplan_0x<token>, subplans with the given token are unconditionally
preferred over all others.

The token returned is “0x<digest>”, where <digest> is the first 64 bits
of the MD5 sum of this string:

  desc1,desc2,...,[child1_desc:]0xchild1,[child2_desc:]0xchild2,<more children>

where desc1, desc2, etc. are the description lines given by EXPLAIN,
and 0xchild1 is the token for children. The normal way to generate such
tokens is to use SET DEBUG='+d,subplan_tokens' and look at the EXPLAIN
FORMAT=tree, but in a pinch, you can also write them by hand and use
md5sum or a similar tool.

Only the hypergraph join optimizer honors token preferences, but EXPLAIN
FORMAT=tree shows computed tokens for both optimizers.

Change-Id: Ieaf35698dba5a54529ae86c61ed236999b6a65f0

Author: Steinar H. Gunderson

mysql-test/r/subplan_tokens.result

@@ -0,0 +1,49 @@
+CREATE TABLE t1 ( a INTEGER, KEY (a) );
+INSERT INTO t1 VALUES (1),(2),(3);
+ANALYZE TABLE t1;
+Table	Op	Msg_type	Msg_text
+test.t1	analyze	status	OK
+SET DEBUG='+d,subplan_tokens';
+EXPLAIN FORMAT=tree SELECT * FROM t1;
+EXPLAIN
+-> [0x383f9723be72015d] Table scan on t1  (cost=0.08..0.25 rows=3)
+
+To force this plan, use:
+SET DEBUG='+d,subplan_tokens,force_subplan_0x383f9723be72015d';
+
+EXPLAIN FORMAT=tree SELECT * FROM t1 ORDER BY a;
+EXPLAIN
+-> [0x4f56594d4fd521c9] Index scan on t1 using a  (cost=0.08..0.25 rows=3)
+
+To force this plan, use:
+SET DEBUG='+d,subplan_tokens,force_subplan_0x4f56594d4fd521c9';
+
+SET DEBUG='+d,subplan_tokens,force_subplan_0x383f9723be72015d';
+EXPLAIN FORMAT=tree SELECT * FROM t1 ORDER BY a;
+EXPLAIN
+-> [0x685afbd3f088dc87] Sort: t1.a  (cost=1.03..1.03 rows=3)
+    -> [0x383f9723be72015d] Table scan on t1  (cost=0.08..0.25 rows=3)
+
+To force this plan, use:
+SET DEBUG='+d,subplan_tokens,force_subplan_0x685afbd3f088dc87,force_subplan_0x383f9723be72015d';
+
+SET DEBUG='+d,subplan_tokens,force_subplan_0x90b6f02248424220';
+EXPLAIN FORMAT=tree SELECT * FROM t1 JOIN t1 AS t2 ON t1.a=t2.a ORDER BY t1.a;
+EXPLAIN
+-> [0x9fe1924c5f48742c] Sort: t1.a  (cost=2.09..2.09 rows=3)
+    -> [0x90b6f02248424220] Inner hash join (t1.a = t2.a)  (cost=0.80..1.31 rows=3)
+        -> [0x383f9723be72015d] Table scan on t1  (cost=0.08..0.25 rows=3)
+        -> Hash
+            -> [0xedd60db81c76aaf5] Table scan on t2  (cost=0.08..0.25 rows=3)
+
+To force this plan, use:
+SET DEBUG='+d,subplan_tokens,force_subplan_0x9fe1924c5f48742c,force_subplan_0x90b6f02248424220,force_subplan_0x383f9723be72015d,force_subplan_0xedd60db81c76aaf5';
+
+SET DEBUG='-d,subplan_tokens';
+EXPLAIN FORMAT=tree SELECT * FROM t1 JOIN t1 AS t2 ON t1.a=t2.a ORDER BY t1.a;
+EXPLAIN
+-> Nested loop inner join  (cost=0.33..1.00 rows=3)
+    -> Index scan on t2 using a  (cost=0.08..0.25 rows=3)
+    -> Index lookup on t1 using a (a=t2.a)  (cost=0.25..0.25 rows=1)
+
+DROP TABLE t1;

mysql-test/t/subplan_tokens.test

@@ -0,0 +1,29 @@
+--source include/have_debug.inc
+--source include/have_hypergraph.inc
+
+CREATE TABLE t1 ( a INTEGER, KEY (a) );
+INSERT INTO t1 VALUES (1),(2),(3);
+ANALYZE TABLE t1;
+
+# Simple table scan, with subplan tokens.
+SET DEBUG='+d,subplan_tokens';
+EXPLAIN FORMAT=tree SELECT * FROM t1;
+
+# Demonstrate that we'd normally use an index to satisfy ORDER BY.
+EXPLAIN FORMAT=tree SELECT * FROM t1 ORDER BY a;
+
+# However, if we force the table scan variant from earlier,
+# we should get a sort instead.
+SET DEBUG='+d,subplan_tokens,force_subplan_0x383f9723be72015d';
+EXPLAIN FORMAT=tree SELECT * FROM t1 ORDER BY a;
+
+# Force a hash join; this is the truncated MD5 checksum of:
+# Inner hash join (t1.a = t2.a),0x383f9723be72015d,Hash:0xedd60db81c76aaf5
+SET DEBUG='+d,subplan_tokens,force_subplan_0x90b6f02248424220';
+EXPLAIN FORMAT=tree SELECT * FROM t1 JOIN t1 AS t2 ON t1.a=t2.a ORDER BY t1.a;
+
+# When not forcing anything, we should prefer the nested loop join.
+SET DEBUG='-d,subplan_tokens';
+EXPLAIN FORMAT=tree SELECT * FROM t1 JOIN t1 AS t2 ON t1.a=t2.a ORDER BY t1.a;
+
+DROP TABLE t1;

sql/join_optimizer/access_path.h

@@ -275,6 +275,12 @@ struct AccessPath {
   /// Whether it is safe to get row IDs (for sorting) from this access path.
   Safety safe_for_rowid = SAFE;
 
+#ifndef NDEBUG
+  /// Whether this access path is forced preferred over all others by means
+  /// of a SET DEBUG force_subplan_0x... statement.
+  bool forced_by_dbug = false;
+#endif
+
   /// Which ordering the rows produced by this path follow, if any
   /// (see interesting_orders.h). This is really a LogicalOrderings::StateIndex,
   /// but we don't want to add a dependency on interesting_orders.h from

sql/join_optimizer/explain_access_path.cc

@@ -20,8 +20,10 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
 
-#include "sql/join_optimizer/access_path.h"
+#include "sql/join_optimizer/explain_access_path.h"
 
+#include "my_md5.h"
+#include "my_md5_size.h"
 #include "sql/filesort.h"
 #include "sql/item_sum.h"
 #include "sql/iterators/basic_row_iterators.h"
@@ -31,6 +33,7 @@
 #include "sql/iterators/ref_row_iterators.h"
 #include "sql/iterators/sorting_iterator.h"
 #include "sql/iterators/timing_iterator.h"
+#include "sql/join_optimizer/access_path.h"
 #include "sql/join_optimizer/print_utils.h"
 #include "sql/join_optimizer/relational_expression.h"
 #include "sql/range_optimizer/group_index_skip_scan_plan.h"
@@ -44,7 +47,6 @@
 #include <string>
 #include <vector>
 
-using std::function;
 using std::string;
 using std::vector;
 
@@ -179,7 +181,8 @@ vector<ExplainData::Child> GetAccessPathsFromSelectList(JOIN *join) {
   return ret;
 }
 
-ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join);
+ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join,
+                              bool include_costs);
 
 // The table iterator could be a slightly more complicated iterator than
 // the basic iterators (in particular, ALTERNATIVE), so show the entire
@@ -188,7 +191,8 @@ static void AddTableIteratorDescription(const AccessPath *path, JOIN *join,
                                         vector<string> *description) {
   const AccessPath *subpath = path;
   for (;;) {
-    ExplainData explain = ExplainAccessPath(subpath, join);
+    ExplainData explain =
+        ExplainAccessPath(subpath, join, /*include_costs=*/true);
     for (string str : explain.description) {
       if (explain.children.size() > 1) {
         // This can happen if we have AlternativeIterator.
@@ -466,7 +470,8 @@ static string PrintRanges(const QUICK_RANGE *const *ranges, unsigned num_ranges,
   return ret;
 }
 
-ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
+ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join,
+                              bool include_costs) {
   vector<string> description;
   vector<ExplainData::Child> children;
   switch (path->type) {
@@ -766,6 +771,17 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
       break;
     case AccessPath::SORT: {
       string ret;
+      if (path->sort().filesort == nullptr) {
+        // This is a hack for when computing digests for forcing subplans (which
+        // happens on non-finalized plans, which don't have a filesort object
+        // yet). It means that sorts won't be correctly forced.
+        // TODO(sgunders): Print based on the flags and order instead of the
+        // filesort object, when using the hypergraph join optimizer.
+        description.push_back("Sort");
+        children.push_back({path->sort().child});
+        break;
+      }
+
       if (path->sort().filesort->using_addon_fields()) {
         ret = "Sort";
       } else {
@@ -838,8 +854,8 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
       // We don't list the table iterator as an explicit child; we mark it in
       // our description instead. (Anything else would look confusingly much
       // like a join.)
-      ExplainData table_explain =
-          ExplainAccessPath(path->temptable_aggregate().table_path, join);
+      ExplainData table_explain = ExplainAccessPath(
+          path->temptable_aggregate().table_path, join, include_costs);
       description = move(table_explain.description);
       description.emplace_back("Aggregate using temporary table");
       children.push_back({path->temptable_aggregate().subquery_path});
@@ -1021,7 +1037,7 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
       break;
     }
   }
-  if (path->num_output_rows >= 0.0) {
+  if (include_costs && path->num_output_rows >= 0.0) {
     double first_row_cost;
     if (path->num_output_rows <= 1.0) {
       first_row_cost = path->cost;
@@ -1061,7 +1077,8 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
     }
     description.back() += str;
   }
-  if (current_thd->lex->is_explain_analyze && path->iterator != nullptr) {
+  if (include_costs && current_thd->lex->is_explain_analyze &&
+      path->iterator != nullptr) {
     if (path->num_output_rows < 0.0) {
       // We always want a double space between the iterator name and the costs.
       description.back().push_back(' ');
@@ -1073,21 +1090,31 @@ ExplainData ExplainAccessPath(const AccessPath *path, JOIN *join) {
 }
 
 string PrintQueryPlan(int level, AccessPath *path, JOIN *join,
-                      bool is_root_of_join) {
+                      bool is_root_of_join,
+                      vector<string> *tokens_for_force_subplan) {
   string ret;
 
   if (path == nullptr) {
     ret.assign(level * 4, ' ');
     return ret + "<not executable by iterator executor>\n";
   }
 
-  ExplainData explain = ExplainAccessPath(path, join);
+  ExplainData explain = ExplainAccessPath(path, join, /*include_costs=*/true);
 
   int top_level = level;
 
+  bool print_token = (tokens_for_force_subplan != nullptr);
   for (const string &str : explain.description) {
     ret.append(level * 4, ' ');
     ret += "-> ";
+    if (print_token) {
+      string token = GetForceSubplanToken(path, join);
+      ret += '[';
+      ret += token;
+      ret += "] ";
+      print_token = false;
+      tokens_for_force_subplan->push_back(move(token));
+    }
     ret += str;
     ret += "\n";
     ++level;
@@ -1113,10 +1140,11 @@ string PrintQueryPlan(int level, AccessPath *path, JOIN *join,
       ret.append("-> ");
       ret.append(child.description);
       ret.append("\n");
-      ret +=
-          PrintQueryPlan(level + 1, child.path, subjoin, child_is_root_of_join);
+      ret += PrintQueryPlan(level + 1, child.path, subjoin,
+                            child_is_root_of_join, tokens_for_force_subplan);
     } else {
-      ret += PrintQueryPlan(level, child.path, subjoin, child_is_root_of_join);
+      ret += PrintQueryPlan(level, child.path, subjoin, child_is_root_of_join,
+                            tokens_for_force_subplan);
     }
   }
   if (is_root_of_join) {
@@ -1134,8 +1162,42 @@ string PrintQueryPlan(int level, AccessPath *path, JOIN *join,
       ret.append(child.description);
       ret.append("\n");
       ret += PrintQueryPlan(top_level + 1, child.path, child.join,
-                            /*is_root_of_join=*/true);
+                            /*is_root_of_join=*/true, tokens_for_force_subplan);
+    }
+  }
+  return ret;
+}
+
+// 0x
+// truncated_md5(desc1,desc2,...,[child1_desc:]0xchild1,[child2_desc:]0xchild2,...)
+string GetForceSubplanToken(AccessPath *path, JOIN *join) {
+  if (path == nullptr) {
+    return "";
+  }
+  ExplainData explain = ExplainAccessPath(path, join, /*include_costs=*/false);
+
+  string digest = explain.description[0];
+  for (size_t desc_idx = 1; desc_idx < explain.description.size(); ++desc_idx) {
+    digest += ',';
+    digest += explain.description[desc_idx];
+  }
+
+  for (const ExplainData::Child &child : explain.children) {
+    digest += ',';
+    if (!child.description.empty()) {
+      digest += child.description;
+      digest += ':';
     }
+    digest += GetForceSubplanToken(child.path, join);
   }
+
+  unsigned char md5sum[MD5_HASH_SIZE];
+  compute_md5_hash(pointer_cast<char *>(md5sum), digest.data(), digest.size());
+
+  char ret[8 * 2 + 2 + 1];
+  snprintf(ret, sizeof(ret), "0x%02x%02x%02x%02x%02x%02x%02x%02x", md5sum[0],
+           md5sum[1], md5sum[2], md5sum[3], md5sum[4], md5sum[5], md5sum[6],
+           md5sum[7]);
+
   return ret;
 }

sql/join_optimizer/explain_access_path.h

@@ -24,6 +24,7 @@
 #define SQL_JOIN_OPTIMIZER_EXPLAIN_ACCESS_PATH_H
 
 #include <string>
+#include <vector>
 
 struct AccessPath;
 class JOIN;
@@ -34,7 +35,36 @@ class JOIN;
   "join" should be set to the JOIN that "path" is part of (or nullptr
   if it is not, e.g. if it's part of executing a UNION).
  */
-std::string PrintQueryPlan(int level, AccessPath *path, JOIN *join,
-                           bool is_root_of_join);
+std::string PrintQueryPlan(
+    int level, AccessPath *path, JOIN *join, bool is_root_of_join,
+    std::vector<std::string> *tokens_for_force_subplan = nullptr);
+
+/**
+  Generate a digest based on the subplan that the given access path
+  represents. This can be used by developers to force a given subplan,
+  to investigate e.g. whether a given choice is actually faster in practice,
+  force-apply a plan from the old join optimizer (or at least the types of
+  subplans that are ever considered; e.g. aggregation through temporary
+  tables are not) into the hypergraph join optimizer (to see how it's costed),
+  or whether a given plan is even generated. If DEBUG contains
+  force_subplan_0x<token>, subplans with the given token are unconditionally
+  preferred over all others.
+
+  The token returned is “0x<digest>”, where <digest> is the first 64 bits
+  of the MD5 sum of this string:
+
+    desc1,desc2,...,[child1_desc:]0xchild1,[child2_desc:]0xchild2,<more
+  children>
+
+  where desc1, desc2, etc. are the description lines given by EXPLAIN,
+  and 0xchild1 is the token for children. The normal way to generate such
+  tokens is to use SET DEBUG='+d,subplan_tokens' and look at the EXPLAIN
+  FORMAT=tree, but in a pinch, you can also write them by hand and use
+  md5sum or a similar tool.
+
+  Only the hypergraph join optimizer honors token preferences, but EXPLAIN
+  FORMAT=tree shows computed tokens for both optimizers.
+ */
+std::string GetForceSubplanToken(AccessPath *path, JOIN *join);
 
 #endif  // SQL_JOIN_OPTIMIZER_EXPLAIN_ACCESS_PATH_H

sql/join_optimizer/join_optimizer.cc

@@ -2262,6 +2262,16 @@ enum class PathComparisonResult {
 static inline PathComparisonResult CompareAccessPaths(
     const LogicalOrderings &orderings, const AccessPath &a, const AccessPath &b,
     OrderingSet obsolete_orderings) {
+#ifndef NDEBUG
+  // Manual preference overrides everything else.
+  // If they're both preferred, tie-break by ordering.
+  if (a.forced_by_dbug) {
+    return PathComparisonResult::FIRST_DOMINATES;
+  } else if (b.forced_by_dbug) {
+    return PathComparisonResult::SECOND_DOMINATES;
+  }
+#endif
+
   bool a_is_better = false, b_is_better = false;
   if (a.cost < b.cost) {
     a_is_better = true;
@@ -2469,6 +2479,12 @@ AccessPath *CostingReceiver::ProposeAccessPath(
     }
   }
 
+  DBUG_EXECUTE_IF("subplan_tokens", {
+    string token =
+        "force_subplan_" + GetForceSubplanToken(path, m_query_block->join);
+    DBUG_EXECUTE_IF(token.c_str(), path->forced_by_dbug = true;);
+  });
+
   if (existing_paths->empty()) {
     if (m_trace != nullptr) {
       *m_trace += " - " + PrintCost(*path, m_graph, description_for_trace) +