Function best_access_path

sql/sql_select.cc:8755–10117

void
best_access_path(JOIN      *join,
                 JOIN_TAB  *s,
                 table_map remaining_tables,
                 const POSITION *join_positions,
                 uint      idx,
                 bool      disable_jbuf,
                 double    record_count,
                 POSITION *pos,
                 POSITION *loose_scan_pos)
{
  THD *thd= join->thd;
  uint use_cond_selectivity=
    thd->variables.optimizer_use_condition_selectivity;
  TABLE *table= s->table;
  handler *file= table->file;
  my_bool found_constraint= 0;
  /*
    key_dependent is 0 if all key parts could be used or if there was an
    EQ_REF table found (which uses all key parts). In other words, we cannot
    find a better key for the table even if remaining_tables is reduced.
    Otherwise it's a bitmap of tables that could improve key usage.
  */
  table_map key_dependent= 0;
  ALL_READ_COST tmp;
  ha_rows rec;
  MY_BITMAP *eq_join_set= &s->table->eq_join_set;
  KEYUSE *hj_start_key= 0;
  table_map spl_pd_boundary= 0;
  Loose_scan_opt loose_scan_opt;
  struct best_plan best;
  Json_writer_object trace_wrapper(thd, "best_access_path");
  DBUG_ENTER("best_access_path");

  /*
    Assume that there is at least one accepted row from previous table
    combinations.
    This fixes a problem when the selectivity for the preceding table
    combinations becomes so high that record_count becomes << 1.0,
    which makes the cost for the current table so low that it does not
    matter when calculating the best plans.
  */
  set_if_bigger(record_count, 1.0);

  best.cost= DBL_MAX;
  best.records= DBL_MAX;
  best.records_read= DBL_MAX;
  best.records_out= MY_MIN(table->stat_records() * table->cond_selectivity,
                           table->opt_range_condition_rows);
  best.identical_keys= 0;
  best.filter= 0;
  best.key= 0;
  best.max_key_part= 0;
  best.type= JT_UNKNOWN;
  best.forced_index= MAX_KEY;
  best.found_ref= 0;
  best.ref_depends_map= 0;
  best.refills= 0;