Bug#17234723: Shortcut execution path in JOIN::optimize()

This is a partial fix for bug no. 68825/16598320:
Performance regressions for single-threaded workloads.

This patch shortcuts processing for some special cases, by skipping
some functions calls. Shortcuts are made based on the following conditions:

 - plan_is_const()
 - materialized_table_count == 0
 - partitioned_table_count == 0
 - outer_join == 0
 - select_lex->sj_nests.elements == 0
 - unit->item == 0 (query block is not a subquery)

Some loops are also made into functions, so that branching in case the
function is skipped is minimized, thus avoiding cache misses.

The gain is up to 5% on a simple synthetic benchmark (see benchmark
BM-1 in bug 68825 for a description), but notice that the expected gain
is platform-dependent.

Author: roylyseng

sql/sql_lex.h

@@ -760,6 +760,12 @@ class st_select_lex: public st_select_lex_node
   /// Array of pointers to top elements of all_fields list
   Ref_ptr_array ref_pointer_array;
 
+  /// Number of derived tables and views
+  uint derived_table_count;
+  /// Number of materialized derived tables and views
+  uint materialized_table_count;
+  /// Number of partitioned tables
+  uint partitioned_table_count;
   /*
     number of items in select_list and HAVING clause used to get number
     bigger then can be number of entries that will be added to all item

sql/sql_optimizer.cc

@@ -189,7 +189,6 @@ JOIN::optimize()
     }
   }
 #endif
-  SELECT_LEX *sel= thd->lex->current_select;
   if (first_optimization)
   {
     /*
@@ -224,7 +223,7 @@ JOIN::optimize()
       st_select_lex::fix_prepare_information(), and remove this second copy
       below.
     */
-    sel->prep_where=
+    select_lex->prep_where=
       conds ? conds->copy_andor_structure(thd, true) : NULL;
   }
 
@@ -266,29 +265,11 @@ JOIN::optimize()
   }
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (select_lex->partitioned_table_count && prune_table_partitions(thd))
   {
-    TABLE_LIST *tbl;
-    for (tbl= select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)
-    {
-      /* 
-        If tbl->embedding!=NULL that means that this table is in the inner
-        part of the nested outer join, and we can't do partition pruning
-        (TODO: check if this limitation can be lifted. 
-               This also excludes semi-joins.  Is that intentional?)
-        This will try to prune non-static conditions, which can
-        be used after the tables are locked.
-      */
-      if (!tbl->embedding)
-      {
-        Item *prune_cond= tbl->join_cond() ? tbl->join_cond() : conds;
-        if (prune_partitions(thd, tbl->table, prune_cond))
-        {
-          error= 1;
-          DBUG_PRINT("error", ("Error from prune_partitions"));
-          DBUG_RETURN(1);
-        }
-      }
-    }
+    error= 1;
+    DBUG_PRINT("error", ("Error from prune_partitions"));
+    DBUG_RETURN(1);
   }
 #endif
 
@@ -431,11 +412,14 @@ JOIN::optimize()
   }
 
   error= 0;
-  reset_nj_counters(join_list);
-  make_outerjoin_info(this);
-
+  if (outer_join)
+  {
+    reset_nj_counters(join_list);
+    make_outerjoin_info(this);
+  }
   // Assign map of "available" tables to all tables belonging to query block
-  set_prefix_tables();
+  if (!plan_is_const())
+    set_prefix_tables();
 
   /*
     Among the equal fields belonging to the same multiple equality
@@ -485,7 +469,8 @@ JOIN::optimize()
     conds=new Item_int((longlong) 0,1);	// Always false
   }
 
-  drop_unused_derived_keys();
+  if (select_lex->materialized_table_count)
+    drop_unused_derived_keys();
 
   if (set_access_methods())
   {
@@ -796,7 +781,7 @@ JOIN::optimize()
   }
 
   /* Cache constant expressions in WHERE, HAVING, ON clauses. */
-  if (cache_const_exprs())
+  if (!plan_is_const() && cache_const_exprs())
     DBUG_RETURN(1);
 
   // See if this subquery can be evaluated with subselect_indexsubquery_engine
@@ -1051,6 +1036,45 @@ JOIN::optimize()
 }
 
 
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+
+/**
+  Prune partitions for all tables of a join (query block).
+
+  Requires that tables have been locked.
+
+  @param thd Thread pointer
+
+  @returns false if success, true if error
+*/
+bool JOIN::prune_table_partitions(THD *thd)
+{
+  DBUG_ASSERT(select_lex->partitioned_table_count);
+
+  for (TABLE_LIST *tbl= select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)
+  {
+    /* 
+      If tbl->embedding!=NULL that means that this table is in the inner
+      part of the nested outer join, and we can't do partition pruning
+      (TODO: check if this limitation can be lifted. 
+             This also excludes semi-joins.  Is that intentional?)
+      This will try to prune non-static conditions, which can
+      be used after the tables are locked.
+    */
+    if (!tbl->embedding)
+    {
+      if (prune_partitions(thd, tbl->table,
+                           tbl->join_cond() ? tbl->join_cond() : conds))
+        return true;
+    }
+  }
+
+  return false;
+}
+
+#endif
+
+
 /**
   Set NESTED_JOIN::counter=0 in all nested joins in passed list.
 
@@ -3020,6 +3044,7 @@ bool JOIN::update_equalities_for_sjm()
 
 void JOIN::set_prefix_tables()
 {
+  DBUG_ASSERT(!plan_is_const());
   /*
     The const tables are available together with the first non-const table in
     the join order.
@@ -3154,7 +3179,7 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, Item *conds,
     DBUG_RETURN(true);
 
   // Up to one extra slot per semi-join nest is needed (if materialized)
-  const uint sj_nests= join->select_lex->sj_nests.elements;
+  uint sj_nests= join->select_lex->sj_nests.elements;
   if (!(join->best_positions=
       new (thd->mem_root) POSITION[table_count + sj_nests + 1]))
     DBUG_RETURN(true);
@@ -3310,10 +3335,11 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, Item *conds,
     throughout the lifetime of a query, so this operation can be performed
     on the first optimization only.
   */
-  if (first_optimization)
+  if (first_optimization && sj_nests)
   {
     if (pull_out_semijoin_tables(join))
       DBUG_RETURN(true);
+    sj_nests= join->select_lex->sj_nests.elements;
   }
 
   /*
@@ -3720,39 +3746,19 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, Item *conds,
     }
   }
 
-  /*
-    Set pointer to embedding semi-join nest for all semi-joined tables.
-    Note that this must be done for every table inside all semi-join nests,
-    even for tables within outer join nests embedded in semi-join nests.
-    A table can never be part of multiple semi-join nests, hence no
-    ambiguities can ever occur.
-    Note also that the pointer is not set for TABLE_LIST objects that
-    are outer join nests within semi-join nests.
-  */
-  for (s= stat; s < stat_end; s++)
-  {
-    for (TABLE_LIST *tables= s->table->pos_in_table_list;
-         tables->embedding;
-         tables= tables->embedding)
-    {
-      if (tables->embedding->sj_on_expr)
-      {
-        s->emb_sj_nest= tables->embedding;
-        break;
-      }
-    }
-  }
-
   join->join_tab=stat;
   join->map2table=stat_ref;
   join->const_tables=const_count;
 
+  if (sj_nests)
+    join->set_semijoin_embedding();
+
   if (!join->plan_is_const())
     optimize_keyuse(join, keyuse_array);
 
   join->allow_outer_refs= true;
 
-  if (optimize_semijoin_nests_for_materialization(join))
+  if (sj_nests && optimize_semijoin_nests_for_materialization(join))
     DBUG_RETURN(true);
 
   if (Optimize_table_order(thd, join, NULL).choose_table_order())
@@ -3762,7 +3768,7 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, Item *conds,
   if (thd->killed || thd->is_error())
     DBUG_RETURN(true);
 
-  if (join->decide_subquery_strategy())
+  if (join->unit->item && join->decide_subquery_strategy())
     DBUG_RETURN(true);
 
   join->refine_best_rowcount();
@@ -3806,6 +3812,40 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, Item *conds,
 }
 
 
+/**
+  Set semi-join embedding join nest pointers.
+
+  Set pointer to embedding semi-join nest for all semi-joined tables.
+  Note that this must be done for every table inside all semi-join nests,
+  even for tables within outer join nests embedded in semi-join nests.
+  A table can never be part of multiple semi-join nests, hence no
+  ambiguities can ever occur.
+  Note also that the pointer is not set for TABLE_LIST objects that
+  are outer join nests within semi-join nests.
+*/
+
+void JOIN::set_semijoin_embedding()
+{
+  DBUG_ASSERT(!select_lex->sj_nests.is_empty());
+
+  JOIN_TAB *const tab_end= join_tab + primary_tables;
+
+  for (JOIN_TAB *tab= join_tab; tab < tab_end; tab++)
+  {
+    for (TABLE_LIST *tr= tab->table->pos_in_table_list;
+         tr->embedding;
+         tr= tr->embedding)
+    {
+      if (tr->embedding->sj_on_expr)
+      {
+        tab->emb_sj_nest= tr->embedding;
+        break;
+      }
+    }
+  }
+}
+
+
 /**
   @brief Check if semijoin's compared types allow materialization.
 
@@ -4454,8 +4494,7 @@ static bool pull_out_semijoin_tables(JOIN *join)
   TABLE_LIST *sj_nest;
   DBUG_ENTER("pull_out_semijoin_tables");
 
-  if (join->select_lex->sj_nests.is_empty())
-    DBUG_RETURN(FALSE);
+  DBUG_ASSERT(!join->select_lex->sj_nests.is_empty());
 
   List_iterator<TABLE_LIST> sj_list_it(join->select_lex->sj_nests);
   Opt_trace_context * const trace= &join->thd->opt_trace;
@@ -5864,20 +5903,22 @@ update_ref_and_keys(THD *thd, Key_use_array *keyuse,JOIN_TAB *join_tab,
   }
 
   /* Generate keys descriptions for derived tables */
-  if (select_lex->join->generate_derived_keys())
-    return TRUE;
-
+  if (select_lex->materialized_table_count)
+  {
+    if (select_lex->join->generate_derived_keys())
+      return true;
+  }
   /* fill keyuse with found key parts */
   for ( ; field != end ; field++)
   {
     if (add_key_part(keyuse,field))
-      return TRUE;
+      return true;
   }
 
   if (select_lex->ftfunc_list->elements)
   {
     if (add_ft_keys(keyuse,join_tab,cond,normal_tables))
-      return TRUE;
+      return true;
   }
 
   /*
@@ -5942,7 +5983,8 @@ update_ref_and_keys(THD *thd, Key_use_array *keyuse,JOIN_TAB *join_tab,
     keyuse->chop(i);
   }
   print_keyuse_array(&thd->opt_trace, keyuse);
-  return FALSE;
+
+  return false;
 }
 
 
@@ -6061,6 +6103,9 @@ static void
 make_outerjoin_info(JOIN *join)
 {
   DBUG_ENTER("make_outerjoin_info");
+
+  DBUG_ASSERT(join->outer_join);
+
   for (uint i= join->const_tables; i < join->tables; i++)
   {
     JOIN_TAB   *const tab= join->join_tab + i;
@@ -6710,6 +6755,10 @@ static bool convert_subquery_to_semijoin(JOIN *parent_join,
   parent_join->tables+= subq_lex->join->tables;
   parent_join->primary_tables+= subq_lex->join->tables;
 
+  parent_lex->derived_table_count+= subq_lex->derived_table_count;
+  parent_lex->materialized_table_count+= subq_lex->materialized_table_count;
+  parent_lex->partitioned_table_count+= subq_lex->partitioned_table_count;
+
   nested_join->sj_outer_exprs.empty();
   nested_join->sj_inner_exprs.empty();
 
@@ -7120,6 +7169,8 @@ void JOIN::remove_subq_pushed_predicates(Item **where)
 
 bool JOIN::generate_derived_keys()
 {
+  DBUG_ASSERT(select_lex->materialized_table_count);
+
   for (TABLE_LIST *table= select_lex->leaf_tables;
        table;
        table= table->next_leaf)
@@ -7146,6 +7197,8 @@ bool JOIN::generate_derived_keys()
 
 void JOIN::drop_unused_derived_keys()
 {
+  DBUG_ASSERT(select_lex->materialized_table_count);
+
   for (uint i= 0 ; i < tables ; i++)
   {
     JOIN_TAB *tab= join_tab + i;
@@ -7203,8 +7256,7 @@ void JOIN::drop_unused_derived_keys()
 bool JOIN::cache_const_exprs()
 {
   /* No need in cache if all tables are constant. */
-  if (plan_is_const())
-    return false;
+  DBUG_ASSERT(!plan_is_const());
 
   for (uint i= const_tables; i < tables; i++)
   {
@@ -9443,8 +9495,7 @@ static void calculate_materialization_costs(JOIN *join,
  */
 bool JOIN::decide_subquery_strategy()
 {
-  if (!unit->item)
-    return false;
+  DBUG_ASSERT(unit->item);
 
   switch (unit->item->substype())
   {