diff options
Diffstat (limited to 'sql/opt_split.cc')
| -rw-r--r-- | sql/opt_split.cc | 139 |
1 files changed, 82 insertions, 57 deletions
diff --git a/sql/opt_split.cc b/sql/opt_split.cc index 8e2b7e12..9ae3eb47 100644 --- a/sql/opt_split.cc +++ b/sql/opt_split.cc @@ -229,6 +229,7 @@ #include "mariadb.h" #include "sql_select.h" #include "opt_trace.h" +#include "optimizer_defaults.h" /* Info on a splitting field */ struct SplM_field_info @@ -286,10 +287,10 @@ public: List<SplM_plan_info> plan_cache; /* Cost of best execution plan for join when nothing is pushed */ double unsplit_cost; + /* Split operation cost (result form spl_postjoin_oper_cost()) */ + double unsplit_oper_cost; /* Cardinality of T when nothing is pushed */ double unsplit_card; - /* Lastly evaluated execution plan for 'join' with pushed equalities */ - SplM_plan_info *last_plan; double last_refills; SplM_plan_info *find_plan(TABLE *table, uint key, uint parts); @@ -665,7 +666,7 @@ add_ext_keyuse_for_splitting(Dynamic_array<KEYUSE_EXT> *ext_keyuses, keyuse_ext.sj_pred_no= added_key_field->sj_pred_no; keyuse_ext.validity_ref= 0; keyuse_ext.needed_in_prefix= added_key_field->val->used_tables() & - ~(OUTER_REF_TABLE_BIT | RAND_TABLE_BIT); + ~(OUTER_REF_TABLE_BIT | RAND_TABLE_BIT); keyuse_ext.validity_var= false; return ext_keyuses->push(keyuse_ext); } @@ -724,20 +725,28 @@ add_ext_keyuses_for_splitting_field(Dynamic_array<KEYUSE_EXT> *ext_keyuses, /* @brief Cost of the post join operation used in specification of splittable table + This does not include the cost of creating the temporary table as this + operation can be executed many times for the same temporary table. */ static double spl_postjoin_oper_cost(THD *thd, double join_record_count, uint rec_len) { double cost; - cost= get_tmp_table_write_cost(thd, join_record_count,rec_len) * - join_record_count; // cost to fill tmp table - cost+= get_tmp_table_lookup_cost(thd, join_record_count,rec_len) * - join_record_count; // cost to perform post join operation used here - cost+= get_tmp_table_lookup_cost(thd, join_record_count, rec_len) + - (join_record_count == 0 ? 0 : - join_record_count * log2 (join_record_count)) * - SORT_INDEX_CMP_COST; // cost to perform sorting + TMPTABLE_COSTS tmp_cost= get_tmp_table_costs(thd, join_record_count, + rec_len, 0, 1); + /* cost to fill tmp table */ + cost= tmp_cost.write * join_record_count; + /* cost to perform post join operation used here */ + cost+= tmp_cost.lookup * join_record_count; + /* cost to preform sorting */ + /* QQQ + We should use cost_of_filesort() for computing sort. + Do we always preform sorting ? If not, this should be done conditionally + */ + cost+= ((join_record_count == 0 ? 0 : + join_record_count * log2 (join_record_count)) * + SORT_INDEX_CMP_COST); return cost; } @@ -769,7 +778,6 @@ void JOIN::add_keyuses_for_splitting() size_t idx; KEYUSE_EXT *keyuse_ext; KEYUSE_EXT keyuse_ext_end; - double oper_cost; uint rec_len; uint added_keyuse_count; TABLE *table= select_lex->master_unit()->derived->table; @@ -792,14 +800,20 @@ void JOIN::add_keyuses_for_splitting() if (ext_keyuses_for_splitting->push(keyuse_ext_end)) goto err; // psergey-todo: trace anything here? - spl_opt_info->unsplit_card= join_record_count; + /* + Use the number of rows that was computed by + TABLE_LIST::fetch_number_of_rows(): + */ + spl_opt_info->unsplit_card= + rows2double(select_lex->master_unit()->derived->table->stat_records()); rec_len= table->s->rec_buff_length; - oper_cost= spl_postjoin_oper_cost(thd, join_record_count, rec_len); - - spl_opt_info->unsplit_cost= best_positions[table_count-1].read_time + - oper_cost; + spl_opt_info->unsplit_oper_cost= spl_postjoin_oper_cost(thd, + join_record_count, + rec_len); + spl_opt_info->unsplit_cost= (best_positions[table_count-1].read_time + + spl_opt_info->unsplit_oper_cost); if (!(save_qep= new Join_plan_state(table_count + 1))) goto err; @@ -963,6 +977,7 @@ SplM_plan_info * JOIN_TAB::choose_best_splitting(uint idx, uint best_key= 0; uint best_key_parts= 0; table_map best_param_tables= 0L; + bool chosen, already_printed; Json_writer_object trace_obj(thd, "choose_best_splitting"); Json_writer_array trace_arr(thd, "considered_keys"); /* @@ -1033,8 +1048,8 @@ SplM_plan_info * JOIN_TAB::choose_best_splitting(uint idx, while (keyuse_ext->table == table); } trace_arr.end(); + chosen= 0; - spl_opt_info->last_plan= 0; double refills= DBL_MAX; table_map excluded_tables= remaining_tables | this->join->sjm_lookup_tables; if (best_table) @@ -1078,7 +1093,7 @@ SplM_plan_info * JOIN_TAB::choose_best_splitting(uint idx, table_map all_table_map= (((table_map) 1) << join->table_count) - 1; reset_validity_vars_for_keyuses(best_key_keyuse_ext_start, best_table, best_key, excluded_tables, true); - choose_plan(join, all_table_map & ~join->const_table_map); + choose_plan(join, all_table_map & ~join->const_table_map, 0); wrapper.end(); /* @@ -1111,64 +1126,74 @@ SplM_plan_info * JOIN_TAB::choose_best_splitting(uint idx, spl_opt_info->unsplit_card : 1); uint rec_len= table->s->rec_buff_length; - double split_card= spl_opt_info->unsplit_card * spl_plan->split_sel; - double oper_cost= split_card * - spl_postjoin_oper_cost(thd, split_card, rec_len); - spl_plan->cost= join->best_positions[join->table_count-1].read_time + - + oper_cost; + double oper_cost= (split_card * + spl_postjoin_oper_cost(thd, split_card, rec_len)); + spl_plan->cost= (join->best_positions[join->table_count-1].read_time + + oper_cost); + + chosen= (refills * spl_plan->cost + COST_EPS < + spl_opt_info->unsplit_cost); + if (unlikely(thd->trace_started())) + { + //psergey-merge:Json_writer_object wrapper(thd); + Json_writer_object find_trace(thd, "split_materialized"); + find_trace. + add("table", best_table->alias.c_ptr()). + add("key", best_table->key_info[best_key].name). + add("org_cost",join->best_positions[join->table_count-1].read_time). + add("postjoin_cost", oper_cost). + add("one_splitting_cost", spl_plan->cost). + add("unsplit_postjoin_cost", spl_opt_info->unsplit_oper_cost). + add("unsplit_cost", spl_opt_info->unsplit_cost). + add("rows", split_card). + add("refills", refills). + add("total_splitting_cost", refills * spl_plan->cost). + add("chosen", chosen); + } memcpy((char *) spl_plan->best_positions, (char *) join->best_positions, sizeof(POSITION) * join->table_count); reset_validity_vars_for_keyuses(best_key_keyuse_ext_start, best_table, best_key, excluded_tables, false); + already_printed= 1; } else - trace_obj.add("cached_plan_found", 1); - - if (spl_plan) { - if (unlikely(thd->trace_started())) - { - trace_obj. - add("lead_table", spl_plan->table->alias.ptr()). - add("index", spl_plan->table->key_info[spl_plan->key].name). - add("parts", spl_plan->parts). - add("split_sel", spl_plan->split_sel). - add("cost", spl_plan->cost). - add("unsplit_cost", spl_opt_info->unsplit_cost). - add("records", (ha_rows) (records * spl_plan->split_sel)); - } - - if (refills * spl_plan->cost < spl_opt_info->unsplit_cost - 0.01) - { - /* - The best plan that employs splitting is cheaper than - the plan without splitting - */ - spl_opt_info->last_plan= spl_plan; - spl_opt_info->last_refills= refills; - trace_obj.add("chosen", true); - } - else - trace_obj.add("chosen", false); + trace_obj.add("cached_plan_found", 1); + chosen= (refills * spl_plan->cost + COST_EPS < + spl_opt_info->unsplit_cost); + already_printed= 0; } } /* Set the cost of the preferred materialization for this partial join */ - records= (ha_rows)spl_opt_info->unsplit_card; - spl_plan= spl_opt_info->last_plan; - if (spl_plan) + if (chosen) { + /* + The best plan that employs splitting is cheaper than + the plan without splitting + */ startup_cost= spl_opt_info->last_refills * spl_plan->cost; - records= (ha_rows) (records * spl_plan->split_sel); + records= (ha_rows) (spl_opt_info->unsplit_card * spl_plan->split_sel); + if (unlikely(thd->trace_started()) && ! already_printed) + { + Json_writer_object trace(thd, "split_materialized"); + trace. + add("one_splitting_cost", spl_plan->cost). + add("total_splitting_cost", startup_cost). + add("rows", records); + } } else { - startup_cost= spl_opt_info->unsplit_cost; - *spl_pd_boundary= 0; + /* Restore original values */ + startup_cost= spl_opt_info->unsplit_cost; + records= (ha_rows) spl_opt_info->unsplit_card; + spl_plan= 0; } + return spl_plan; } |