sql_select.cc
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:185k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* mysql_select and join optimization */
  14. #ifdef __GNUC__
  15. #pragma implementation // gcc: Class implementation
  16. #endif
  17. #include "mysql_priv.h"
  18. #include "sql_select.h"
  19. #include "opt_ft.h"
  20. #include <m_ctype.h>
  21. #include <hash.h>
  22. #include <ft_global.h>
  23. #include <assert.h>
  24. const char *join_type_str[]={ "UNKNOWN","system","const","eq_ref","ref",
  25.       "MAYBE_REF","ALL","range","index","fulltext" };
  26. static bool make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds,
  27.                         DYNAMIC_ARRAY *keyuse,List<Item_func_match> &ftfuncs);
  28. static bool update_ref_and_keys(DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
  29.                                 uint tables,COND *conds,table_map table_map,
  30.                                 List<Item_func_match> &ftfuncs);
  31. static int sort_keyuse(KEYUSE *a,KEYUSE *b);
  32. static void set_position(JOIN *join,uint index,JOIN_TAB *table,KEYUSE *key);
  33. static void find_best_combination(JOIN *join,table_map rest_tables);
  34. static void find_best(JOIN *join,table_map rest_tables,uint index,
  35.       double record_count,double read_time);
  36. static uint cache_record_length(JOIN *join,uint index);
  37. static double prev_record_reads(JOIN *join,table_map found_ref);
  38. static bool get_best_combination(JOIN *join);
  39. static store_key *get_store_key(KEYUSE *keyuse, table_map used_tables,
  40. KEY_PART_INFO *key_part, char *key_buff,
  41. uint maybe_null);
  42. static bool make_simple_join(JOIN *join,TABLE *tmp_table);
  43. static bool make_join_select(JOIN *join,SQL_SELECT *select,COND *item);
  44. static void make_join_readinfo(JOIN *join,uint options);
  45. static void join_free(JOIN *join);
  46. static bool only_eq_ref_tables(JOIN *join,ORDER *order,table_map tables);
  47. static void update_depend_map(JOIN *join);
  48. static void update_depend_map(JOIN *join, ORDER *order);
  49. static ORDER *remove_const(JOIN *join,ORDER *first_order,COND *cond,
  50.    bool *simple_order);
  51. static int return_zero_rows(select_result *res,TABLE_LIST *tables,
  52.     List<Item> &fields, bool send_row,
  53.     uint select_options, const char *info,
  54.     Item *having, Procedure *proc);
  55. static COND *optimize_cond(COND *conds,Item::cond_result *cond_value);
  56. static COND *remove_eq_conds(COND *cond,Item::cond_result *cond_value);
  57. static bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
  58. static bool open_tmp_table(TABLE *table);
  59. static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param,
  60.     uint options);
  61. static int do_select(JOIN *join,List<Item> *fields,TABLE *tmp_table,
  62.      Procedure *proc);
  63. static int sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records);
  64. static int sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records);
  65. static int flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skipp_last);
  66. static int end_send(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
  67. static int end_send_group(JOIN *join, JOIN_TAB *join_tab,bool end_of_records);
  68. static int end_write(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
  69. static int end_update(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
  70. static int end_unique_update(JOIN *join,JOIN_TAB *join_tab,
  71.      bool end_of_records);
  72. static int end_write_group(JOIN *join, JOIN_TAB *join_tab,
  73.    bool end_of_records);
  74. static int test_if_group_changed(List<Item_buff> &list);
  75. static int join_read_const_tables(JOIN *join);
  76. static int join_read_system(JOIN_TAB *tab);
  77. static int join_read_const(JOIN_TAB *tab);
  78. static int join_read_key(JOIN_TAB *tab);
  79. static int join_read_always_key(JOIN_TAB *tab);
  80. static int join_no_more_records(READ_RECORD *info);
  81. static int join_read_next(READ_RECORD *info);
  82. static int join_init_quick_read_record(JOIN_TAB *tab);
  83. static int test_if_quick_select(JOIN_TAB *tab);
  84. static int join_init_read_record(JOIN_TAB *tab);
  85. static int join_init_read_first_with_key(JOIN_TAB *tab);
  86. static int join_init_read_next_with_key(READ_RECORD *info);
  87. static int join_init_read_last_with_key(JOIN_TAB *tab);
  88. static int join_init_read_prev_with_key(READ_RECORD *info);
  89. static int join_ft_read_first(JOIN_TAB *tab);
  90. static int join_ft_read_next(READ_RECORD *info);
  91. static COND *make_cond_for_table(COND *cond,table_map table,
  92.  table_map used_table);
  93. static Item* part_of_refkey(TABLE *form,Field *field);
  94. static uint find_shortest_key(TABLE *table, key_map usable_keys);
  95. static bool test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,
  96.     ha_rows select_limit);
  97. static int create_sort_index(JOIN_TAB *tab,ORDER *order,ha_rows select_limit);
  98. static int remove_duplicates(JOIN *join,TABLE *entry,List<Item> &fields);
  99. static int remove_dup_with_compare(THD *thd, TABLE *entry, Field **field,
  100.    ulong offset);
  101. static int remove_dup_with_hash_index(THD *thd, TABLE *table,
  102.       uint field_count, Field **first_field,
  103.       ulong key_length);
  104. static int join_init_cache(THD *thd,JOIN_TAB *tables,uint table_count);
  105. static ulong used_blob_length(CACHE_FIELD **ptr);
  106. static bool store_record_in_cache(JOIN_CACHE *cache);
  107. static void reset_cache(JOIN_CACHE *cache);
  108. static void read_cached_record(JOIN_TAB *tab);
  109. static bool cmp_buffer_with_ref(JOIN_TAB *tab);
  110. static int setup_group(THD *thd,TABLE_LIST *tables,List<Item> &fields,
  111.        List<Item> &all_fields, ORDER *order, bool *hidden);
  112. static bool setup_new_fields(THD *thd,TABLE_LIST *tables,List<Item> &fields,
  113.      List<Item> &all_fields,ORDER *new_order);
  114. static ORDER *create_distinct_group(ORDER *order, List<Item> &fields);
  115. static bool test_if_subpart(ORDER *a,ORDER *b);
  116. static TABLE *get_sort_by_table(ORDER *a,ORDER *b,TABLE_LIST *tables);
  117. static void calc_group_buffer(JOIN *join,ORDER *group);
  118. static bool alloc_group_fields(JOIN *join,ORDER *group);
  119. static bool make_sum_func_list(JOIN *join,List<Item> &fields);
  120. static bool change_to_use_tmp_fields(List<Item> &func);
  121. static bool change_refs_to_tmp_fields(THD *thd, List<Item> &func);
  122. static void init_tmptable_sum_functions(Item_sum **func);
  123. static void update_tmptable_sum_func(Item_sum **func,TABLE *tmp_table);
  124. static void copy_sum_funcs(Item_sum **func_ptr);
  125. static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab);
  126. static void init_sum_functions(Item_sum **func);
  127. static bool update_sum_func(Item_sum **func);
  128. static void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
  129.     bool distinct);
  130. static void describe_info(THD *thd, const char *info);
  131. /*****************************************************************************
  132. ** check fields, find best join, do the select and output fields.
  133. ** mysql_select assumes that all tables are allready opened
  134. *****************************************************************************/
  135. int
  136. mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &fields,COND *conds,
  137.              List<Item_func_match> &ftfuncs,
  138.      ORDER *order, ORDER *group,Item *having,ORDER *proc_param,
  139.      uint select_options,select_result *result)
  140. {
  141.   TABLE *tmp_table;
  142.   int error,tmp;
  143.   bool need_tmp,hidden_group_fields;
  144.   bool simple_order,simple_group,no_order;
  145.   Item::cond_result cond_value;
  146.   SQL_SELECT *select;
  147.   DYNAMIC_ARRAY keyuse;
  148.   JOIN join;
  149.   Procedure *procedure;
  150.   List<Item> all_fields(fields);
  151.   bool select_distinct;
  152.   DBUG_ENTER("mysql_select");
  153.   /* Check that all tables, fields, conds and order are ok */
  154.   select_distinct=test(select_options & SELECT_DISTINCT);
  155.   tmp_table=0;
  156.   select=0;
  157.   no_order=0;
  158.   bzero((char*) &keyuse,sizeof(keyuse));
  159.   thd->proc_info="init";
  160.   thd->used_tables=0; // Updated by setup_fields
  161.   if (setup_fields(thd,tables,fields,1,&all_fields) ||
  162.       setup_conds(thd,tables,&conds) ||
  163.       setup_order(thd,tables,fields,all_fields,order) ||
  164.       setup_group(thd,tables,fields,all_fields,group,&hidden_group_fields) ||
  165.       setup_ftfuncs(thd,tables,ftfuncs))
  166.     DBUG_RETURN(-1); /* purecov: inspected */
  167.   if (having)
  168.   {
  169.     thd->where="having clause";
  170.     thd->allow_sum_func=1;
  171.     if (having->fix_fields(thd,tables) || thd->fatal_error)
  172.       DBUG_RETURN(-1); /* purecov: inspected */
  173.     if (having->with_sum_func)
  174.       having->split_sum_func(all_fields);
  175.   }
  176.   /*
  177.     Check if one one uses a not constant column with group functions
  178.     and no GROUP BY.
  179.     TODO:  Add check of calculation of GROUP functions and fields:
  180.    SELECT COUNT(*)+table.col1 from table1;
  181.     */
  182.   join.table=0;
  183.   join.tables=0;
  184.   {
  185.     if (!group)
  186.     {
  187.       uint flag=0;
  188.       List_iterator<Item> it(fields);
  189.       Item *item;
  190.       while ((item= it++))
  191.       {
  192. if (item->with_sum_func)
  193.   flag|=1;
  194. else if (!item->const_item())
  195.   flag|=2;
  196.       }
  197.       if (flag == 3)
  198.       {
  199. my_error(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,MYF(0));
  200. DBUG_RETURN(-1);
  201.       }
  202.     }
  203.     TABLE_LIST *table;
  204.     for (table=tables ; table ; table=table->next)
  205.       join.tables++;
  206.   }
  207.   procedure=setup_procedure(thd,proc_param,result,fields,&error);
  208.   if (error)
  209.     DBUG_RETURN(-1); /* purecov: inspected */
  210.   if (procedure)
  211.   {
  212.     if (setup_new_fields(thd,tables,fields,all_fields,procedure->param_fields))
  213.     { /* purecov: inspected */
  214.       delete procedure; /* purecov: inspected */
  215.       DBUG_RETURN(-1); /* purecov: inspected */
  216.     }
  217.     if (procedure->group)
  218.     {
  219.       if (!test_if_subpart(procedure->group,group))
  220.       { /* purecov: inspected */
  221. my_message(0,"Can't handle procedures with differents groups yet",
  222.    MYF(0)); /* purecov: inspected */
  223. delete procedure; /* purecov: inspected */
  224. DBUG_RETURN(-1); /* purecov: inspected */
  225.       }
  226.     }
  227. #ifdef NOT_NEEDED
  228.     else if (!group && procedure->flags & PROC_GROUP)
  229.     {
  230.       my_message(0,"Select must have a group with this procedure",MYF(0));
  231.       delete procedure;
  232.       DBUG_RETURN(-1);
  233.     }
  234. #endif
  235.     if (order && (procedure->flags & PROC_NO_SORT))
  236.     { /* purecov: inspected */
  237.       my_message(0,"Can't use order with this procedure",MYF(0)); /* purecov: inspected */
  238.       delete procedure; /* purecov: inspected */
  239.       DBUG_RETURN(-1); /* purecov: inspected */
  240.     }
  241.   }
  242.   /* Init join struct */
  243.   join.thd=thd;
  244.   join.lock=thd->lock;
  245.   join.join_tab=0;
  246.   join.tmp_table_param.copy_field=0;
  247.   join.sum_funcs=0;
  248.   join.send_records=join.found_records=0;
  249.   join.tmp_table_param.end_write_records= HA_POS_ERROR;
  250.   join.first_record=join.sort_and_group=0;
  251.   join.select_options=select_options;
  252.   join.result=result;
  253.   count_field_types(&join.tmp_table_param,all_fields,0);
  254.   join.const_tables=0;
  255.   join.having=0;
  256.   join.group= group != 0;
  257. #ifdef RESTRICTED_GROUP
  258.   if (join.sum_func_count && !group && (join.func_count || join.field_count))
  259.   {
  260.     my_message(ER_WRONG_SUM_SELECT,ER(ER_WRONG_SUM_SELECT));
  261.     delete procedure;
  262.     DBUG_RETURN(-1);
  263.   }
  264. #endif
  265.   if (!procedure && result->prepare(fields))
  266.   { /* purecov: inspected */
  267.     DBUG_RETURN(-1); /* purecov: inspected */
  268.   }
  269. #ifdef HAVE_REF_TO_FIELDS // Not done yet
  270.   /* Add HAVING to WHERE if possible */
  271.   if (having && !group && ! join.sum_func_count)
  272.   {
  273.     if (!conds)
  274.     {
  275.       conds=having;
  276.       having=0;
  277.     }
  278.     else if ((conds=new Item_cond_and(conds,having)))
  279.     {
  280.       conds->fix_fields(thd,tables);
  281.       conds->change_ref_to_fields(thd,tables);
  282.       having=0;
  283.     }
  284.   }
  285. #endif
  286.   conds=optimize_cond(conds,&cond_value);
  287.   if (thd->fatal_error) // Out of memory
  288.   {
  289.     delete procedure;
  290.     DBUG_RETURN(0);
  291.   }
  292.   if (cond_value == Item::COND_FALSE || !thd->select_limit)
  293.   { /* Impossible cond */
  294.     error=return_zero_rows(result, tables, fields,
  295.    join.tmp_table_param.sum_func_count != 0 && !group,
  296.    select_options,"Impossible WHERE",having,
  297.    procedure);
  298.     delete procedure;
  299.     DBUG_RETURN(error);
  300.   }
  301.   /* Optimize count(*), min() and max() */
  302.   if (tables && join.tmp_table_param.sum_func_count && ! group)
  303.   {
  304.     int res;
  305.     if ((res=opt_sum_query(tables, all_fields, conds)))
  306.     {
  307.       if (res < 0)
  308.       {
  309. error=return_zero_rows(result, tables, fields, !group,
  310.        select_options,"No matching min/max row",
  311.        having,procedure);
  312. delete procedure;
  313. DBUG_RETURN(error);
  314.       }
  315.       if (select_options & SELECT_DESCRIBE)
  316.       {
  317. describe_info(thd,"Select tables optimized away");
  318. delete procedure;
  319. DBUG_RETURN(0);
  320.       }
  321.       tables=0; // All tables resolved
  322.     }
  323.   }
  324.   if (!tables)
  325.   { // Only test of functions
  326.     error=0;
  327.     if (select_options & SELECT_DESCRIBE)
  328.       describe_info(thd,"No tables used");
  329.     else
  330.     {
  331.       result->send_fields(fields,1);
  332.       if (!having || having->val_int())
  333.       {
  334. if (result->send_data(fields))
  335. {
  336.   result->send_error(0,NullS); /* purecov: inspected */
  337.   error=1;
  338. }
  339. else
  340.   error=(int) result->send_eof();
  341.       }
  342.       else
  343. error=(int) result->send_eof();
  344.     }
  345.     delete procedure;
  346.     DBUG_RETURN(0);
  347.   }
  348.   error = -1;
  349.   join.sort_by_table=get_sort_by_table(order,group,tables);
  350.   /* Calculate how to do the join */
  351.   thd->proc_info="statistics";
  352.   if (make_join_statistics(&join,tables,conds,&keyuse,ftfuncs) ||
  353.       thd->fatal_error)
  354.     goto err;
  355.   thd->proc_info="preparing";
  356.   if ((tmp=join_read_const_tables(&join)) > 0)
  357.     goto err;
  358.   if (tmp && !(select_options & SELECT_DESCRIBE))
  359.   {
  360.     error=return_zero_rows(result,tables,fields,
  361.    join.tmp_table_param.sum_func_count != 0 &&
  362.    !group,0,"",having,procedure);
  363.     goto err;
  364.   }
  365.   if (!(thd->options & OPTION_BIG_SELECTS) &&
  366.       join.best_read > (double) thd->max_join_size &&
  367.       !(select_options & SELECT_DESCRIBE))
  368.   { /* purecov: inspected */
  369.     result->send_error(ER_TOO_BIG_SELECT,ER(ER_TOO_BIG_SELECT)); /* purecov: inspected */
  370.     error= 1; /* purecov: inspected */
  371.     goto err; /* purecov: inspected */
  372.   }
  373.   if (join.const_tables && !thd->locked_tables)
  374.     mysql_unlock_some_tables(thd, join.table,join.const_tables);
  375.   if (!conds && join.outer_join)
  376.   {
  377.     /* Handle the case where we have an OUTER JOIN without a WHERE */
  378.     conds=new Item_int((longlong) 1,1); // Always true
  379.   }
  380.   select=make_select(*join.table, join.const_table_map,
  381.      join.const_table_map,conds,&error);
  382.   if (error)
  383.   { /* purecov: inspected */
  384.     error= -1; /* purecov: inspected */
  385.     goto err; /* purecov: inspected */
  386.   }
  387.   if (make_join_select(&join,select,conds))
  388.   {
  389.     error=return_zero_rows(result,tables,fields,
  390.    join.tmp_table_param.sum_func_count != 0 && !group,
  391.    select_options,
  392.    "Impossible WHERE noticed after reading const tables",
  393.    having,procedure);
  394.     goto err;
  395.   }
  396.   error= -1; /* if goto err */
  397.   /* Optimize distinct away if possible */
  398.   order=remove_const(&join,order,conds,&simple_order);
  399.   if (group || join.tmp_table_param.sum_func_count)
  400.   {
  401.     if (! hidden_group_fields)
  402.       select_distinct=0;
  403.   }
  404.   else if (select_distinct && join.tables - join.const_tables == 1 &&
  405.    (order || thd->select_limit == HA_POS_ERROR))
  406.   {
  407.     if ((group=create_distinct_group(order,fields)))
  408.     {
  409.       select_distinct=0;
  410.       no_order= !order;
  411.       join.group=1; // For end_write_group
  412.     }
  413.     else if (thd->fatal_error) // End of memory
  414.       goto err;
  415.   }
  416.   group=remove_const(&join,group,conds,&simple_group);
  417.   if (!group && join.group)
  418.   {
  419.     order=0; // The output has only one row
  420.     simple_order=1;
  421.   }
  422.   calc_group_buffer(&join,group);
  423.   join.send_group_parts=join.tmp_table_param.group_parts; /* Save org parts */
  424.   if (procedure && procedure->group)
  425.   {
  426.     group=procedure->group=remove_const(&join,procedure->group,conds,
  427. &simple_group);
  428.     calc_group_buffer(&join,group);
  429.   }
  430.   if (test_if_subpart(group,order) ||
  431.       (!group && join.tmp_table_param.sum_func_count))
  432.     order=0;
  433.   // Can't use sort on head table if using cache
  434.   if (join.full_join)
  435.   {
  436.     if (group)
  437.       simple_group=0;
  438.     if (order)
  439.       simple_order=0;
  440.   }
  441.   need_tmp= (join.const_tables != join.tables &&
  442.      ((select_distinct || !simple_order || !simple_group) ||
  443.       (group && order) ||
  444.       test(select_options & OPTION_BUFFER_RESULT)));
  445.   make_join_readinfo(&join, (select_options & SELECT_DESCRIBE) | 
  446.            (ftfuncs.elements ? 0 : SELECT_USE_CACHE)); // No cache for MATCH
  447.   /* Need to tell Innobase that to play it safe, it should fetch all
  448.      columns of the tables: this is because MySQL
  449.      may build row pointers for the rows, and for all columns of the primary
  450.      key the field->query_id has not necessarily been set to thd->query_id
  451.      by MySQL. */
  452. #ifdef HAVE_INNOBASE_DB
  453.   if (need_tmp || select_distinct || group || order)
  454.   {
  455.     for (uint i_h = join.const_tables; i_h < join.tables; i_h++)
  456.     {
  457.       TABLE*   table_h = join.join_tab[i_h].table;
  458.       if (table_h->db_type == DB_TYPE_INNOBASE)
  459. table_h->file->extra(HA_EXTRA_DONT_USE_CURSOR_TO_UPDATE);
  460.     }
  461.   }
  462. #endif
  463.   DBUG_EXECUTE("info",TEST_join(&join););
  464.   /*
  465.     Because filesort always does a full table scan or a quick range scan
  466.     we must add the removed reference to the select for the table.
  467.     We only need to do this when we have a simple_order or simple_group
  468.     as in other cases the join is done before the sort.
  469.     */
  470.   if ((order || group) && join.join_tab[join.const_tables].type != JT_ALL &&
  471.       join.join_tab[join.const_tables].type != JT_FT &&
  472.       (order && simple_order || group && simple_group))
  473.   {
  474.     if (add_ref_to_table_cond(thd,&join.join_tab[join.const_tables]))
  475.       goto err;
  476.   }
  477.   if (!(select_options & SELECT_BIG_RESULT) &&
  478.       ((group && join.const_tables != join.tables &&
  479. !test_if_skip_sort_order(&join.join_tab[join.const_tables], group,
  480.  HA_POS_ERROR)) ||
  481.        select_distinct) &&
  482.       join.tmp_table_param.quick_group && !procedure)
  483.   {
  484.     need_tmp=1; simple_order=simple_group=0; // Force tmp table without sort
  485.   }
  486.   if (select_options & SELECT_DESCRIBE)
  487.   {
  488.     if (!order && !no_order)
  489.       order=group;
  490.     if (order &&
  491. (join.const_tables == join.tables ||
  492.  test_if_skip_sort_order(&join.join_tab[join.const_tables], order,
  493.  (having || group ||
  494.   join.const_tables != join.tables - 1) ?
  495.  HA_POS_ERROR : thd->select_limit)))
  496.       order=0;
  497.     select_describe(&join,need_tmp,
  498.     (order != 0 &&
  499.      (!need_tmp || order != group || simple_group)),
  500.     select_distinct);
  501.     error=0;
  502.     goto err;
  503.   }
  504.   /* Perform FULLTEXT search before all regular searches */
  505.   if (ftfuncs.elements)
  506.   {
  507.     List_iterator<Item_func_match> li(ftfuncs);
  508.     Item_func_match *ifm;
  509.     DBUG_PRINT("info",("Performing FULLTEXT search"));
  510.     thd->proc_info="FULLTEXT searching";
  511.     while ((ifm=li++))
  512.     {
  513.       ifm->init_search(test(order));
  514.     }
  515.   }
  516.   /* Create a tmp table if distinct or if the sort is too complicated */
  517.   if (need_tmp)
  518.   {
  519.     DBUG_PRINT("info",("Creating tmp table"));
  520.     thd->proc_info="Creating tmp table";
  521.     if (!(tmp_table =
  522.   create_tmp_table(thd,&join.tmp_table_param,all_fields,
  523.    ((!simple_group && !procedure &&
  524.      !(test_flags & TEST_NO_KEY_GROUP)) ?
  525.     group : (ORDER*) 0),
  526.    group ? 0 : select_distinct,
  527.    group && simple_group,
  528.    order == 0,
  529.    join.select_options)))
  530.       goto err; /* purecov: inspected */
  531.     if (having && (join.sort_and_group || (tmp_table->distinct && !group)))
  532.       join.having=having;
  533.     /* if group or order on first table, sort first */
  534.     if (group && simple_group)
  535.     {
  536.       DBUG_PRINT("info",("Sorting for group"));
  537.       thd->proc_info="Sorting for group";
  538.       if (create_sort_index(&join.join_tab[join.const_tables],group,
  539.     HA_POS_ERROR) ||
  540.   make_sum_func_list(&join,all_fields) ||
  541.   alloc_group_fields(&join,group))
  542. goto err;
  543.       group=0;
  544.     }
  545.     else
  546.     {
  547.       if (make_sum_func_list(&join,all_fields))
  548. goto err;
  549.       if (!group && ! tmp_table->distinct && order && simple_order)
  550.       {
  551. DBUG_PRINT("info",("Sorting for order"));
  552. thd->proc_info="Sorting for order";
  553. if (create_sort_index(&join.join_tab[join.const_tables],order,
  554.       HA_POS_ERROR))
  555.   goto err; /* purecov: inspected */
  556. order=0;
  557.       }
  558.     }
  559.     /*
  560.       Optimize distinct when used on some of the tables
  561.       SELECT DISTINCT t1.a FROM t1,t2 WHERE t1.b=t2.b
  562.       In this case we can stop scanning t2 when we have found one t1.a
  563.     */
  564.     if (tmp_table->distinct)
  565.     {
  566.       table_map used_tables= thd->used_tables;
  567.       JOIN_TAB *join_tab=join.join_tab+join.tables-1;
  568.       do
  569.       {
  570. if (used_tables & join_tab->table->map)
  571.   break;
  572. join_tab->not_used_in_distinct=1;
  573.       } while (join_tab-- != join.join_tab);
  574.     }
  575.     /* Copy data to the temporary table */
  576.     thd->proc_info="Copying to tmp table";
  577.     if (do_select(&join,(List<Item> *) 0,tmp_table,0))
  578.       goto err; /* purecov: inspected */
  579.     if (join.having)
  580.       join.having=having=0; // Allready done
  581.     /* Change sum_fields reference to calculated fields in tmp_table */
  582.     if (join.sort_and_group || tmp_table->group)
  583.     {
  584.       if (change_to_use_tmp_fields(all_fields))
  585. goto err;
  586.       join.tmp_table_param.field_count+=join.tmp_table_param.sum_func_count+
  587. join.tmp_table_param.func_count;
  588.       join.tmp_table_param.sum_func_count=join.tmp_table_param.func_count=0;
  589.     }
  590.     else
  591.     {
  592.       if (change_refs_to_tmp_fields(thd,all_fields))
  593. goto err;
  594.       join.tmp_table_param.field_count+=join.tmp_table_param.func_count;
  595.       join.tmp_table_param.func_count=0;
  596.     }
  597.     if (procedure)
  598.       procedure->update_refs();
  599.     if (tmp_table->group)
  600.     { // Already grouped
  601.       if (!order && !no_order)
  602. order=group; /* order by group */
  603.       group=0;
  604.     }
  605.     /*
  606.     ** If we have different sort & group then we must sort the data by group
  607.     ** and copy it to another tmp table
  608.     ** This code is also used if we are using distinct something
  609.     ** we haven't been able to store in the temporary table yet
  610.     ** like SEC_TO_TIME(SUM(...)).
  611.     */
  612.     if (group && (!test_if_subpart(group,order) || select_distinct) ||
  613. (select_distinct &&
  614.  join.tmp_table_param.using_indirect_summary_function))
  615.     { /* Must copy to another table */
  616.       TABLE *tmp_table2;
  617.       DBUG_PRINT("info",("Creating group table"));
  618.       /* Free first data from old join */
  619.       join_free(&join);
  620.       if (make_simple_join(&join,tmp_table))
  621. goto err;
  622.       calc_group_buffer(&join,group);
  623.       count_field_types(&join.tmp_table_param,all_fields,
  624. select_distinct && !group);
  625.       join.tmp_table_param.hidden_field_count=(all_fields.elements-
  626.        fields.elements);
  627.       /* group data to new table */
  628.       if (!(tmp_table2 = create_tmp_table(thd,&join.tmp_table_param,all_fields,
  629.   (ORDER*) 0,
  630.   select_distinct && !group,
  631.   1, 0,
  632.   join.select_options)))
  633. goto err; /* purecov: inspected */
  634.       if (group)
  635.       {
  636. thd->proc_info="Creating sort index";
  637. if (create_sort_index(join.join_tab,group,HA_POS_ERROR) ||
  638.     alloc_group_fields(&join,group))
  639. {
  640.   free_tmp_table(thd,tmp_table2); /* purecov: inspected */
  641.   goto err; /* purecov: inspected */
  642. }
  643. group=0;
  644.       }
  645.       thd->proc_info="Copying to group table";
  646.       if (make_sum_func_list(&join,all_fields) ||
  647.   do_select(&join,(List<Item> *) 0,tmp_table2,0))
  648.       {
  649. free_tmp_table(thd,tmp_table2);
  650. goto err; /* purecov: inspected */
  651.       }
  652.       end_read_record(&join.join_tab->read_record);
  653.       free_tmp_table(thd,tmp_table);
  654.       join.const_tables=join.tables; // Mark free for join_free()
  655.       tmp_table=tmp_table2;
  656.       join.join_tab[0].table=0; // Table is freed
  657.       if (change_to_use_tmp_fields(all_fields)) // No sum funcs anymore
  658. goto err;
  659.       join.tmp_table_param.field_count+=join.tmp_table_param.sum_func_count;
  660.       join.tmp_table_param.sum_func_count=0;
  661.     }
  662.     if (tmp_table->distinct)
  663.       select_distinct=0; /* Each row is uniq */
  664.     join_free(&join); /* Free quick selects */
  665.     if (select_distinct && ! group)
  666.     {
  667.       thd->proc_info="Removing duplicates";
  668.       if (remove_duplicates(&join,tmp_table,fields))
  669. goto err; /* purecov: inspected */
  670.       select_distinct=0;
  671.     }
  672.     tmp_table->reginfo.lock_type=TL_UNLOCK;
  673.     if (make_simple_join(&join,tmp_table))
  674.       goto err;
  675.     calc_group_buffer(&join,group);
  676.     count_field_types(&join.tmp_table_param,all_fields,0);
  677.   }
  678.   if (procedure)
  679.   {
  680.     if (procedure->change_columns(fields) ||
  681. result->prepare(fields))
  682.       goto err;
  683.     count_field_types(&join.tmp_table_param,all_fields,0);
  684.   }
  685.   if (join.group || join.tmp_table_param.sum_func_count ||
  686.       (procedure && (procedure->flags & PROC_GROUP)))
  687.   {
  688.     alloc_group_fields(&join,group);
  689.     setup_copy_fields(&join.tmp_table_param,all_fields);
  690.     if (make_sum_func_list(&join,all_fields) || thd->fatal_error)
  691.       goto err; /* purecov: inspected */
  692.   }
  693.   if (group || order)
  694.   {
  695.     DBUG_PRINT("info",("Sorting for send_fields"));
  696.     thd->proc_info="Sorting result";
  697.     /* If we have already done the group, add HAVING to sorted table */
  698.     if (having && ! group && ! join.sort_and_group)
  699.     {
  700.       having->update_used_tables(); // Some tables may have been const
  701.       JOIN_TAB *table=&join.join_tab[join.const_tables];
  702.       table_map used_tables= join.const_table_map | table->table->map;
  703.       Item* sort_table_cond=make_cond_for_table(having,used_tables,used_tables);
  704.       if (sort_table_cond)
  705.       {
  706. if (!table->select)
  707.   if (!(table->select=new SQL_SELECT))
  708.     goto err;
  709. if (!table->select->cond)
  710.   table->select->cond=sort_table_cond;
  711. else // This should never happen
  712.   if (!(table->select->cond=new Item_cond_and(table->select->cond,
  713.       sort_table_cond)))
  714.     goto err;
  715. table->select_cond=table->select->cond;
  716. DBUG_EXECUTE("where",print_where(table->select->cond,
  717.  "select and having"););
  718. having=make_cond_for_table(having,~ (table_map) 0,~used_tables);
  719. DBUG_EXECUTE("where",print_where(conds,"having after sort"););
  720.       }
  721.     }
  722.     if (create_sort_index(&join.join_tab[join.const_tables],
  723.   group ? group : order,
  724.   (having || group ||
  725.    join.const_tables != join.tables - 1) ?
  726.   HA_POS_ERROR : thd->select_limit))
  727.       goto err; /* purecov: inspected */
  728.   }
  729.   join.having=having; // Actually a parameter
  730.   thd->proc_info="Sending data";
  731.   error=do_select(&join,&fields,NULL,procedure);
  732. err:
  733.   thd->proc_info="end";
  734.   join.lock=0; // It's faster to unlock later
  735.   join_free(&join);
  736.   thd->proc_info="end2"; // QQ
  737.   if (tmp_table)
  738.     free_tmp_table(thd,tmp_table);
  739.   thd->proc_info="end3"; // QQ
  740.   delete select;
  741.   delete_dynamic(&keyuse);
  742.   delete procedure;
  743.   thd->proc_info="end4"; // QQ
  744.   DBUG_RETURN(error);
  745. }
  746. /*****************************************************************************
  747. ** Create JOIN_TABS, make a guess about the table types,
  748. ** Approximate how many records will be used in each table
  749. *****************************************************************************/
  750. static ha_rows get_quick_record_count(SQL_SELECT *select,TABLE *table,
  751.       key_map keys)
  752. {
  753.   int error;
  754.   DBUG_ENTER("get_quick_record_count");
  755.   if (select)
  756.   {
  757.     select->head=table;
  758.     table->reginfo.impossible_range=0;
  759.     if ((error=select->test_quick_select(keys,(table_map) 0,HA_POS_ERROR))
  760. == 1)
  761.       DBUG_RETURN(select->quick->records);
  762.     if (error == -1)
  763.     {
  764.       table->reginfo.impossible_range=1;
  765.       DBUG_RETURN(0);
  766.     }
  767.     DBUG_PRINT("warning",("Couldn't use record count on const keypart"));
  768.   }
  769.   DBUG_RETURN(HA_POS_ERROR); /* This shouldn't happend */
  770. }
  771. static bool
  772. make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds,
  773.      DYNAMIC_ARRAY *keyuse_array,
  774.      List<Item_func_match> &ftfuncs)
  775. {
  776.   int error;
  777.   uint i,table_count,const_count,found_ref,refs,key,const_ref,eq_part;
  778.   table_map const_table_map,all_table_map;
  779.   TABLE **table_vector;
  780.   JOIN_TAB *stat,*stat_end,*s,**stat_ref;
  781.   SQL_SELECT *select;
  782.   KEYUSE *keyuse,*start_keyuse;
  783.   table_map outer_join=0;
  784.   JOIN_TAB *stat_vector[MAX_TABLES+1];
  785.   DBUG_ENTER("make_join_statistics");
  786.   table_count=join->tables;
  787.   stat=(JOIN_TAB*) join->thd->calloc(sizeof(JOIN_TAB)*table_count);
  788.   stat_ref=(JOIN_TAB**) join->thd->alloc(sizeof(JOIN_TAB*)*MAX_TABLES);
  789.   table_vector=(TABLE**) join->thd->alloc(sizeof(TABLE**)*(table_count*2));
  790.   if (!stat || !stat_ref || !table_vector)
  791.     DBUG_RETURN(1); // Eom /* purecov: inspected */
  792.   select=0;
  793.   join->best_ref=stat_vector;
  794.   stat_end=stat+table_count;
  795.   const_table_map=all_table_map=0;
  796.   const_count=0;
  797.   for (s=stat,i=0 ; tables ; s++,tables=tables->next,i++)
  798.   {
  799.     TABLE *table;
  800.     stat_vector[i]=s;
  801.     table_vector[i]=s->table=table=tables->table;
  802.     table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);// record count
  803.     table->quick_keys=0;
  804.     table->reginfo.join_tab=s;
  805.     table->reginfo.not_exists_optimize=0;
  806.     bzero((char*) table->const_key_parts, sizeof(key_part_map)*table->keys);
  807.     all_table_map|= table->map;
  808.     if ((s->on_expr=tables->on_expr))
  809.     {
  810.       // table->maybe_null=table->outer_join=1; // Mark for send fields
  811.       if (!table->file->records)
  812.       { // Empty table
  813. s->key_dependent=s->dependent=0;
  814. s->type=JT_SYSTEM;
  815. const_table_map|=table->map;
  816. set_position(join,const_count++,s,(KEYUSE*) 0);
  817. continue;
  818.       }
  819.       s->key_dependent=s->dependent=
  820. s->on_expr->used_tables() & ~(table->map);
  821.       if (table->outer_join & JOIN_TYPE_LEFT)
  822. s->dependent|=stat_vector[i-1]->dependent | table_vector[i-1]->map;
  823.       if (tables->outer_join & JOIN_TYPE_RIGHT)
  824. s->dependent|=tables->next->table->map;
  825.       outer_join|=table->map;
  826.       continue;
  827.     }
  828.     if (tables->straight) // We don't have to move this
  829.       s->dependent= table_vector[i-1]->map | stat_vector[i-1]->dependent;
  830.     else
  831.       s->dependent=(table_map) 0;
  832.     s->key_dependent=(table_map) 0;
  833.     if ((table->system || table->file->records <= 1) && ! s->dependent &&
  834. !(table->file->option_flag() & HA_NOT_EXACT_COUNT))
  835.     {
  836.       s->type=JT_SYSTEM;
  837.       const_table_map|=table->map;
  838.       set_position(join,const_count++,s,(KEYUSE*) 0);
  839.     }
  840.   }
  841.   stat_vector[i]=0;
  842.   join->outer_join=outer_join;
  843.   /*
  844.   ** If outer join: Re-arrange tables in stat_vector so that outer join
  845.   ** tables are after all tables it is dependent of.
  846.   ** For example: SELECT * from A LEFT JOIN B ON B.c=C.c, C WHERE A.C=C.C
  847.   ** Will shift table B after table C.
  848.   */
  849.   if (outer_join)
  850.   {
  851.     table_map used_tables=0L;
  852.     for (i=0 ; i < join->tables-1 ; i++)
  853.     {
  854.       if (stat_vector[i]->dependent & ~used_tables)
  855.       {
  856. JOIN_TAB *save= stat_vector[i];
  857. uint j;
  858. for (j=i+1;
  859.      j < join->tables && stat_vector[j]->dependent & ~used_tables;
  860.      j++)
  861. {
  862.   JOIN_TAB *tmp=stat_vector[j]; // Move element up
  863.   stat_vector[j]=save;
  864.   save=tmp;
  865. }
  866. if (j == join->tables)
  867. {
  868.   join->tables=0; // Don't use join->table
  869.   my_error(ER_WRONG_OUTER_JOIN,MYF(0));
  870.   DBUG_RETURN(1);
  871. }
  872. stat_vector[i]=stat_vector[j];
  873. stat_vector[j]=save;
  874.       }
  875.       used_tables|= stat_vector[i]->table->map;
  876.     }
  877.   }
  878.   if (conds || outer_join)
  879.     if (update_ref_and_keys(keyuse_array,stat,join->tables,
  880.                             conds,~outer_join,ftfuncs))
  881.       DBUG_RETURN(1);
  882.   /* loop until no more const tables are found */
  883.   int ref_changed;
  884.   do
  885.   {
  886.     ref_changed = 0;
  887.     found_ref=0;
  888.     for (JOIN_TAB **pos=stat_vector+const_count; (s= *pos) ; pos++)
  889.     {
  890.       if (s->dependent) // If dependent on some table
  891.       {
  892. if (s->dependent & ~(const_table_map)) // All dep. must be constants
  893.   continue;
  894. if (s->table->file->records <= 1L &&
  895.     !(s->table->file->option_flag() & HA_NOT_EXACT_COUNT))
  896. { // system table
  897.   s->type=JT_SYSTEM;
  898.   const_table_map|=s->table->map;
  899.   set_position(join,const_count++,s,(KEYUSE*) 0);
  900.   continue;
  901. }
  902.       }
  903.       /* check if table can be read by key or table only uses const refs */
  904.       if ((keyuse=s->keyuse))
  905.       {
  906. TABLE *table=s->table;
  907. s->type= JT_REF;
  908. while (keyuse->table == table)
  909. {
  910.   start_keyuse=keyuse;
  911.   key=keyuse->key;
  912.   s->keys|= (key_map) 1 << key; // QQ: remove this ?
  913.   refs=const_ref=eq_part=0;
  914.   do
  915.   {
  916.     if (keyuse->val->type() != Item::NULL_ITEM)
  917.     {
  918.       if (!((~const_table_map) & keyuse->used_tables))
  919. const_ref|= (key_map) 1 << keyuse->keypart;
  920.       else
  921. refs|=keyuse->used_tables;
  922.       eq_part|= (uint) 1 << keyuse->keypart;
  923.     }
  924.     keyuse++;
  925.   } while (keyuse->table == table && keyuse->key == key);
  926.   if (eq_part == PREV_BITS(uint,table->key_info[key].key_parts) &&
  927.       (table->key_info[key].flags & HA_NOSAME))
  928.   {
  929.     if (const_ref == eq_part)
  930.     { // Found everything for ref.
  931.       s->type=JT_CONST;
  932.       const_table_map|=table->map;
  933.       set_position(join,const_count++,s,start_keyuse);
  934.       ref_changed = 1;
  935.       break;
  936.     }
  937.     else
  938.       found_ref|= refs; // Table is const if all refs are const
  939.   }
  940. }
  941.       }
  942.     }
  943.   } while (const_table_map & found_ref && ref_changed);
  944.   /* Calc how many (possible) matched records in each table */
  945.   for (s=stat ; s < stat_end ; s++)
  946.   {
  947.     if (s->type == JT_SYSTEM || s->type == JT_CONST)
  948.     {
  949.       /* Only one matching row */
  950.       s->found_records=s->records=s->read_time=1; s->worst_seeks=1.0;
  951.       continue;
  952.     }
  953.     /* Approximate found rows and time to read them */
  954.     s->found_records=s->records=s->table->file->records;
  955.     s->read_time=(ha_rows) s->table->file->scan_time();
  956.     /* Set a max range of how many seeks we can expect when using keys */
  957.     s->worst_seeks= (double) (s->read_time*2);
  958.     if (s->worst_seeks < 2.0) // Fix for small tables
  959.       s->worst_seeks=2.0;
  960.     /* if (s->type == JT_EQ_REF)
  961.       continue; */
  962.     if (s->const_keys)
  963.     {
  964.       ha_rows records;
  965.       if (!select)
  966. select=make_select(s->table,const_table_map,
  967.    0,
  968.    and_conds(conds,s->on_expr),&error);
  969.       records=get_quick_record_count(select,s->table, s->const_keys);
  970.       s->quick=select->quick;
  971.       s->needed_reg=select->needed_reg;
  972.       select->quick=0;
  973.       select->read_tables=const_table_map;
  974.       if (records != HA_POS_ERROR)
  975.       {
  976. s->found_records=records;
  977. s->read_time= (ha_rows) (s->quick ? s->quick->read_time : 0.0);
  978.       }
  979.     }
  980.   }
  981.   delete select;
  982.   /* Find best combination and return it */
  983.   join->join_tab=stat;
  984.   join->map2table=stat_ref;
  985.   join->table= join->all_tables=table_vector;
  986.   join->const_tables=const_count;
  987.   join->const_table_map=const_table_map;
  988.   if (join->const_tables != join->tables)
  989.     find_best_combination(join,all_table_map & ~const_table_map);
  990.   else
  991.   {
  992.     memcpy((gptr) join->best_positions,(gptr) join->positions,
  993.    sizeof(POSITION)*join->const_tables);
  994.     join->best_read=1.0;
  995.   }
  996.   DBUG_RETURN(get_best_combination(join));
  997. }
  998. /*****************************************************************************
  999. ** check with keys are used and with tables references with tables
  1000. ** updates in stat:
  1001. **   keys      Bitmap of all used keys
  1002. **   const_keys Bitmap of all keys with may be used with quick_select
  1003. **   keyuse     Pointer to possible keys
  1004. *****************************************************************************/
  1005. typedef struct key_field_t { // Used when finding key fields
  1006.   Field *field;
  1007.   Item *val; // May be empty if diff constant
  1008.   uint level,const_level; // QQ: Remove const_level
  1009.   bool eq_func;
  1010.   bool exists_optimize;
  1011. } KEY_FIELD;
  1012. /* merge new key definitions to old ones, remove those not used in both */
  1013. static KEY_FIELD *
  1014. merge_key_fields(KEY_FIELD *start,KEY_FIELD *new_fields,KEY_FIELD *end,
  1015.  uint and_level)
  1016. {
  1017.   if (start == new_fields)
  1018.     return start; // Impossible or
  1019.   if (new_fields == end)
  1020.     return start; // No new fields, skipp all
  1021.   KEY_FIELD *first_free=new_fields;
  1022.   /* Mark all found fields in old array */
  1023.   for (; new_fields != end ; new_fields++)
  1024.   {
  1025.     for (KEY_FIELD *old=start ; old != first_free ; old++)
  1026.     {
  1027.       if (old->field == new_fields->field)
  1028.       {
  1029. if (new_fields->val->used_tables())
  1030. {
  1031.   if (old->val->eq(new_fields->val))
  1032.   {
  1033.     old->level=old->const_level=and_level;
  1034.     old->exists_optimize&=new_fields->exists_optimize;
  1035.   }
  1036. }
  1037. else if (old->val->eq(new_fields->val) && old->eq_func &&
  1038.  new_fields->eq_func)
  1039. {
  1040.   old->level=old->const_level=and_level;
  1041.   old->exists_optimize&=new_fields->exists_optimize;
  1042. }
  1043. else // Impossible; remove it
  1044. {
  1045.   if (old == --first_free) // If last item
  1046.     break;
  1047.   *old= *first_free; // Remove old value
  1048.   old--; // Retry this value
  1049. }
  1050.       }
  1051.     }
  1052.   }
  1053.   /* Remove all not used items */
  1054.   for (KEY_FIELD *old=start ; old != first_free ;)
  1055.   {
  1056.     if (old->level != and_level && old->const_level != and_level)
  1057.     { // Not used in all levels
  1058.       if (old == --first_free)
  1059. break;
  1060.       *old= *first_free; // Remove old value
  1061.       continue;
  1062.     }
  1063.     old++;
  1064.   }
  1065.   return first_free;
  1066. }
  1067. static void
  1068. add_key_field(KEY_FIELD **key_fields,uint and_level,
  1069.       Field *field,bool eq_func,Item *value,
  1070.       table_map usable_tables)
  1071. {
  1072.   bool exists_optimize=0;
  1073.   if (!(field->flags & PART_KEY_FLAG))
  1074.   {
  1075.     // Don't remove column IS NULL on a LEFT JOIN table
  1076.     if (!eq_func || !value || value->type() != Item::NULL_ITEM ||
  1077. !field->table->maybe_null || field->null_ptr)
  1078.       return; // Not a key. Skipp it
  1079.     exists_optimize=1;
  1080.   }
  1081.   else
  1082.   {
  1083.     table_map used_tables=0;
  1084.     if (value && (used_tables=value->used_tables()) &
  1085. (field->table->map | RAND_TABLE_BIT))
  1086.       return;
  1087.     if (!(usable_tables & field->table->map))
  1088.     {
  1089.       if (!eq_func || !value || value->type() != Item::NULL_ITEM ||
  1090.   !field->table->maybe_null || field->null_ptr)
  1091. return; // Can't use left join optimize
  1092.       exists_optimize=1;
  1093.     }
  1094.     else
  1095.     {
  1096.       JOIN_TAB *stat=field->table->reginfo.join_tab;
  1097.       stat[0].keys|=field->key_start; // Add possible keys
  1098.       if (!value)
  1099.       { // Probably BETWEEN or IN
  1100. stat[0].const_keys |= field->key_start;
  1101. return; // Can't be used as eq key
  1102.       }
  1103.       /* Save the following cases:
  1104.  Field op constant
  1105.  Field LIKE constant where constant doesn't start with a wildcard
  1106.  Field = field2 where field2 is in a different table
  1107.  Field op formula
  1108.  Field IS NULL
  1109.  Field IS NOT NULL
  1110.       */
  1111.       stat[0].key_dependent|=used_tables;
  1112.       if (value->const_item())
  1113. stat[0].const_keys |= field->key_start;
  1114.       /* We can't always use indexes when comparing a string index to a
  1115.  number. cmp_type() is checked to allow compare of dates to numbers */
  1116.       if (!eq_func ||
  1117.   field->result_type() == STRING_RESULT &&
  1118.   value->result_type() != STRING_RESULT &&
  1119.   field->cmp_type() != value->result_type())
  1120. return;
  1121.     }
  1122.   }
  1123.   /* Store possible eq field */
  1124.   (*key_fields)->field=field;
  1125.   (*key_fields)->eq_func=eq_func;
  1126.   (*key_fields)->val=value;
  1127.   (*key_fields)->level=(*key_fields)->const_level=and_level;
  1128.   (*key_fields)->exists_optimize=exists_optimize;
  1129.   (*key_fields)++;
  1130. }
  1131. static void
  1132. add_key_fields(JOIN_TAB *stat,KEY_FIELD **key_fields,uint *and_level,
  1133.        COND *cond, table_map usable_tables)
  1134. {
  1135.   if (cond->type() == Item_func::COND_ITEM)
  1136.   {
  1137.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  1138.     KEY_FIELD *org_key_fields= *key_fields;
  1139.     if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
  1140.     {
  1141.       Item *item;
  1142.       while ((item=li++))
  1143. add_key_fields(stat,key_fields,and_level,item,usable_tables);
  1144.       for (; org_key_fields != *key_fields ; org_key_fields++)
  1145.       {
  1146. if (org_key_fields->const_level == org_key_fields->level)
  1147.   org_key_fields->const_level=org_key_fields->level= *and_level;
  1148. else
  1149.   org_key_fields->const_level= *and_level;
  1150.       }
  1151.     }
  1152.     else
  1153.     {
  1154.       (*and_level)++;
  1155.       add_key_fields(stat,key_fields,and_level,li++,usable_tables);
  1156.       Item *item;
  1157.       while ((item=li++))
  1158.       {
  1159. KEY_FIELD *start_key_fields= *key_fields;
  1160. (*and_level)++;
  1161. add_key_fields(stat,key_fields,and_level,item,usable_tables);
  1162. *key_fields=merge_key_fields(org_key_fields,start_key_fields,
  1163.      *key_fields,++(*and_level));
  1164.       }
  1165.     }
  1166.     return;
  1167.   }
  1168.   /* If item is of type 'field op field/constant' add it to key_fields */
  1169.   if (cond->type() != Item::FUNC_ITEM)
  1170.     return;
  1171.   Item_func *cond_func= (Item_func*) cond;
  1172.   switch (cond_func->select_optimize()) {
  1173.   case Item_func::OPTIMIZE_NONE:
  1174.     break;
  1175.   case Item_func::OPTIMIZE_KEY:
  1176.     if (cond_func->key_item()->type() == Item::FIELD_ITEM)
  1177.       add_key_field(key_fields,*and_level,
  1178.     ((Item_field*) (cond_func->key_item()))->field,
  1179.     0,(Item*) 0,usable_tables);
  1180.     break;
  1181.   case Item_func::OPTIMIZE_OP:
  1182.   {
  1183.     bool equal_func=(cond_func->functype() == Item_func::EQ_FUNC ||
  1184.      cond_func->functype() == Item_func::EQUAL_FUNC);
  1185.     if (cond_func->arguments()[0]->type() == Item::FIELD_ITEM)
  1186.     {
  1187.       add_key_field(key_fields,*and_level,
  1188.     ((Item_field*) (cond_func->arguments()[0]))->field,
  1189.     equal_func,
  1190.     (cond_func->arguments()[1]),usable_tables);
  1191.     }
  1192.     if (cond_func->arguments()[1]->type() == Item::FIELD_ITEM &&
  1193. cond_func->functype() != Item_func::LIKE_FUNC)
  1194.     {
  1195.       add_key_field(key_fields,*and_level,
  1196.     ((Item_field*) (cond_func->arguments()[1]))->field,
  1197.     equal_func,
  1198.     (cond_func->arguments()[0]),usable_tables);
  1199.     }
  1200.     break;
  1201.   }
  1202.   case Item_func::OPTIMIZE_NULL:
  1203.     /* column_name IS [NOT] NULL */
  1204.     if (cond_func->arguments()[0]->type() == Item::FIELD_ITEM)
  1205.     {
  1206.       add_key_field(key_fields,*and_level,
  1207.     ((Item_field*) (cond_func->arguments()[0]))->field,
  1208.     cond_func->functype() == Item_func::ISNULL_FUNC,
  1209.     new Item_null, usable_tables);
  1210.     }
  1211.     break;
  1212.   }
  1213.   return;
  1214. }
  1215. /*
  1216. ** Add all keys with uses 'field' for some keypart
  1217. ** If field->and_level != and_level then only mark key_part as const_part
  1218. */
  1219. static uint
  1220. max_part_bit(key_map bits)
  1221. {
  1222.   uint found;
  1223.   for (found=0; bits & 1 ; found++,bits>>=1) ;
  1224.   return found;
  1225. }
  1226. static void
  1227. add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)
  1228. {
  1229.   Field *field=key_field->field;
  1230.   TABLE *form= field->table;
  1231.   KEYUSE keyuse;
  1232.   if (key_field->eq_func && !key_field->exists_optimize)
  1233.   {
  1234.     for (uint key=0 ; key < form->keys ; key++)
  1235.     {
  1236.       if (!(form->keys_in_use_for_query & (((key_map) 1) << key)))
  1237. continue;
  1238.       if (form->key_info[key].flags & HA_FULLTEXT)
  1239. continue;    // ToDo: ft-keys in non-ft queries.   SerG
  1240.       uint key_parts= (uint) form->key_info[key].key_parts;
  1241.       for (uint part=0 ; part <  key_parts ; part++)
  1242.       {
  1243. if (field->eq(form->key_info[key].key_part[part].field))
  1244. {
  1245.   keyuse.table= field->table;
  1246.   keyuse.val =  key_field->val;
  1247.   keyuse.key =  key;
  1248.   keyuse.keypart=part;
  1249.   keyuse.used_tables=key_field->val->used_tables();
  1250.   VOID(insert_dynamic(keyuse_array,(gptr) &keyuse));
  1251. }
  1252.       }
  1253.     }
  1254.   }
  1255.   /* Mark that we can optimize LEFT JOIN */
  1256.   if (key_field->val->type() == Item::NULL_ITEM &&
  1257.       !key_field->field->real_maybe_null())
  1258.     key_field->field->table->reginfo.not_exists_optimize=1;
  1259. }
  1260. static void
  1261. add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
  1262.             JOIN_TAB *stat,COND *cond,table_map usable_tables)
  1263. {
  1264.   Item_func_match *cond_func=NULL;
  1265.   if (!cond)
  1266.     return;
  1267.   if (cond->type() == Item::FUNC_ITEM)
  1268.   {
  1269.     Item_func *func=(Item_func *)cond,
  1270.               *arg0=(Item_func *)(func->arguments()[0]),
  1271.               *arg1=(Item_func *)(func->arguments()[1]);
  1272.     if (func->functype() == Item_func::FT_FUNC)
  1273.       cond_func=(Item_func_match *)cond;
  1274.     else if ((func->functype() == Item_func::GE_FUNC ||
  1275.               func->functype() == Item_func::GT_FUNC)  &&
  1276.               arg0->type() == Item::FUNC_ITEM          &&
  1277.               arg0->functype() == Item_func::FT_FUNC   &&
  1278.               arg1->const_item() && arg1->val()>=0)
  1279.       cond_func=(Item_func_match *)arg0;
  1280.     else if ((func->functype() == Item_func::LE_FUNC ||
  1281.               func->functype() == Item_func::LT_FUNC)  &&
  1282.               arg1->type() == Item::FUNC_ITEM          &&
  1283.               arg1->functype() == Item_func::FT_FUNC   &&
  1284.               arg0->const_item() && arg0->val()>=0)
  1285.       cond_func=(Item_func_match *)arg1;
  1286.   }
  1287.   else if (cond->type() == Item::COND_ITEM)
  1288.   {
  1289.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  1290.     if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
  1291.     {
  1292.       Item *item;
  1293.       /* I'm too lazy to implement proper recursive descent here,
  1294.          and anyway, nobody will use such a stupid queries
  1295.          that will require it :-)
  1296.          May be later...
  1297.        */
  1298.       while ((item=li++))
  1299.         if (item->type() == Item::FUNC_ITEM &&
  1300.             ((Item_func *)item)->functype() == Item_func::FT_FUNC)
  1301.         {
  1302.           cond_func=(Item_func_match *)item;
  1303.           break;
  1304.         }
  1305.     }
  1306.   }
  1307.   if(!cond_func)
  1308.     return;
  1309.   KEYUSE keyuse;
  1310.   keyuse.table= cond_func->table;
  1311.   keyuse.val =  cond_func;
  1312.   keyuse.key =  cond_func->key;
  1313. #define FT_KEYPART   (MAX_REF_PARTS+10)
  1314.   keyuse.keypart=FT_KEYPART;
  1315.   keyuse.used_tables=cond_func->key_item()->used_tables();
  1316.   VOID(insert_dynamic(keyuse_array,(gptr) &keyuse));
  1317. }
  1318. static int
  1319. sort_keyuse(KEYUSE *a,KEYUSE *b)
  1320. {
  1321.   if (a->table->tablenr != b->table->tablenr)
  1322.     return (int) (a->table->tablenr - b->table->tablenr);
  1323.   if (a->key != b->key)
  1324.     return (int) (a->key - b->key);
  1325.   if (a->keypart != b->keypart)
  1326.     return (int) (a->keypart - b->keypart);
  1327.   return test(a->used_tables) - test(b->used_tables); // Place const first
  1328. }
  1329. /*
  1330. ** Update keyuse array with all possible keys we can use to fetch rows
  1331. ** join_tab is a array in tablenr_order
  1332. ** stat is a reference array in 'prefered' order.
  1333. */
  1334. static bool
  1335. update_ref_and_keys(DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,uint tables,
  1336.         COND *cond, table_map normal_tables,List<Item_func_match> &ftfuncs)
  1337. {
  1338.   uint and_level,i,found_eq_constant;
  1339.   {
  1340.     KEY_FIELD *key_fields,*end;
  1341.     if (!(key_fields=(KEY_FIELD*)
  1342.   my_malloc(sizeof(key_fields[0])*
  1343.     (current_thd->cond_count+1)*2,MYF(0))))
  1344.       return TRUE; /* purecov: inspected */
  1345.     and_level=0; end=key_fields;
  1346.     if (cond)
  1347.       add_key_fields(join_tab,&end,&and_level,cond,normal_tables);
  1348.     for (i=0 ; i < tables ; i++)
  1349.     {
  1350.       if (join_tab[i].on_expr)
  1351.       {
  1352. add_key_fields(join_tab,&end,&and_level,join_tab[i].on_expr,
  1353.        join_tab[i].table->map);
  1354.       }
  1355.     }
  1356.     if (init_dynamic_array(keyuse,sizeof(KEYUSE),20,64))
  1357.     {
  1358.       my_free((gptr) key_fields,MYF(0));
  1359.       return TRUE;
  1360.     }
  1361.     /* fill keyuse with found key parts */
  1362.     for (KEY_FIELD *field=key_fields ; field != end ; field++)
  1363.       add_key_part(keyuse,field);
  1364.     my_free((gptr) key_fields,MYF(0));
  1365.   }
  1366.   if (ftfuncs.elements)
  1367.   {
  1368.     add_ft_keys(keyuse,join_tab,cond,normal_tables);
  1369.   }
  1370.   /*
  1371.   ** remove ref if there is a keypart which is a ref and a const.
  1372.   ** remove keyparts without previous keyparts.
  1373.   ** Special treatment for ft-keys. SerG.
  1374.   */
  1375.   if (keyuse->elements)
  1376.   {
  1377.     KEYUSE end,*prev,*save_pos,*use;
  1378.     qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
  1379.   (qsort_cmp) sort_keyuse);
  1380.     bzero((char*) &end,sizeof(end)); /* Add for easy testing */
  1381.     VOID(insert_dynamic(keyuse,(gptr) &end));
  1382.     use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
  1383.     prev=&end;
  1384.     found_eq_constant=0;
  1385.     for (i=0 ; i < keyuse->elements-1 ; i++,use++)
  1386.     {
  1387.       if (!use->used_tables)
  1388. use->table->const_key_parts[use->key] |=
  1389.   (key_part_map) 1 << use->keypart;
  1390.       if (use->keypart != FT_KEYPART)
  1391.       {
  1392. if (use->key == prev->key && use->table == prev->table)
  1393. {
  1394.   if (prev->keypart+1 < use->keypart ||
  1395.       prev->keypart == use->keypart && found_eq_constant)
  1396.     continue; /* remove */
  1397. }
  1398. else if (use->keypart != 0) // First found must be 0
  1399.   continue;
  1400.       }
  1401.       *save_pos= *use;
  1402.       prev=use;
  1403.       found_eq_constant= !use->used_tables;
  1404.       /* Save ptr to first use */
  1405.       if (!use->table->reginfo.join_tab->keyuse)
  1406. use->table->reginfo.join_tab->keyuse=save_pos;
  1407.       use->table->reginfo.join_tab->checked_keys|= (key_map) 1 << use->key;
  1408.       save_pos++;
  1409.     }
  1410.     i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);
  1411.     VOID(set_dynamic(keyuse,(gptr) &end,i));
  1412.     keyuse->elements=i;
  1413.   }
  1414.   return FALSE;
  1415. }
  1416. /*****************************************************************************
  1417. ** Go through all combinations of not marked tables and find the one
  1418. ** which uses least records
  1419. *****************************************************************************/
  1420. /* Save const tables first as used tables */
  1421. static void
  1422. set_position(JOIN *join,uint idx,JOIN_TAB *table,KEYUSE *key)
  1423. {
  1424.   join->positions[idx].table= table;
  1425.   join->positions[idx].key=key;
  1426.   join->positions[idx].records_read=1.0; /* This is a const table */
  1427.   /* Move the const table as down as possible in best_ref */
  1428.   JOIN_TAB **pos=join->best_ref+idx+1;
  1429.   JOIN_TAB *next=join->best_ref[idx];
  1430.   for ( ;next != table ; pos++)
  1431.   {
  1432.     JOIN_TAB *tmp=pos[0];
  1433.     pos[0]=next;
  1434.     next=tmp;
  1435.   }
  1436.   join->best_ref[idx]=table;
  1437. }
  1438. static void
  1439. find_best_combination(JOIN *join, table_map rest_tables)
  1440. {
  1441.   DBUG_ENTER("find_best_combination");
  1442.   join->best_read=DBL_MAX;
  1443.   find_best(join,rest_tables, join->const_tables,1.0,0.0);
  1444.   DBUG_VOID_RETURN;
  1445. }
  1446. static void
  1447. find_best(JOIN *join,table_map rest_tables,uint idx,double record_count,
  1448.   double read_time)
  1449. {
  1450.   ulong rec;
  1451.   double tmp;
  1452.   if (!rest_tables)
  1453.   {
  1454.     DBUG_PRINT("best",("read_time: %g  record_count: %g",read_time,
  1455.        record_count));
  1456.     read_time+=record_count/(double) TIME_FOR_COMPARE;
  1457.     if (join->sort_by_table &&
  1458. join->sort_by_table != join->positions[join->const_tables].table->table)
  1459.       read_time+=record_count; // We have to make a temp table
  1460.     if (read_time < join->best_read)
  1461.     {
  1462.       memcpy((gptr) join->best_positions,(gptr) join->positions,
  1463.      sizeof(POSITION)*idx);
  1464.       join->best_read=read_time;
  1465.     }
  1466.     return;
  1467.   }
  1468.   if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)
  1469.     return; /* Found better before */
  1470.   JOIN_TAB *s;
  1471.   double best_record_count=DBL_MAX,best_read_time=DBL_MAX;
  1472.   for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)
  1473.   {
  1474.     table_map real_table_bit=s->table->map;
  1475.     if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent))
  1476.     {
  1477.       double best,best_time,records;
  1478.       best=best_time=records=DBL_MAX;
  1479.       KEYUSE *best_key=0;
  1480.       uint best_max_key_part=0;
  1481.       if (s->keyuse)
  1482.       { /* Use key if possible */
  1483. TABLE *table=s->table;
  1484. KEYUSE *keyuse,*start_key=0;
  1485. double best_records=DBL_MAX;
  1486. uint max_key_part=0;
  1487. /* Test how we can use keys */
  1488. rec= s->records/MATCHING_ROWS_IN_OTHER_TABLE;  /* Assumed records/key */
  1489. for (keyuse=s->keyuse ; keyuse->table == table ;)
  1490. {
  1491.   key_map found_part=0;
  1492.   table_map found_ref=0;
  1493.   uint key=keyuse->key;
  1494.   KEY *keyinfo=table->key_info+key;
  1495.           bool ft_key=(keyuse->keypart == FT_KEYPART);
  1496.   start_key=keyuse;
  1497.   do
  1498.   {
  1499.             uint keypart=keyuse->keypart;
  1500.     do
  1501.     {
  1502.               if (!ft_key)
  1503.               {
  1504. table_map map;
  1505. if (!(rest_tables & keyuse->used_tables))
  1506. {
  1507.   found_part|= (key_part_map) 1 << keypart;
  1508.   found_ref|= keyuse->used_tables;
  1509. }
  1510. /*
  1511. ** If we find a ref, assume this table matches a proportional
  1512. ** part of this table.
  1513. ** For example 100 records matching a table with 5000 records
  1514. ** gives 5000/100 = 50 records per key
  1515. ** Constant tables are ignored and to avoid bad matches,
  1516. ** we don't make rec less than 100.
  1517. */
  1518. if (keyuse->used_tables &
  1519.     (map=(keyuse->used_tables & ~join->const_table_map)))
  1520. {
  1521.   uint tablenr;
  1522.   for (tablenr=0 ; ! (map & 1) ; map>>=1, tablenr++) ;
  1523.   if (map == 1) // Only one table
  1524.   {
  1525.     TABLE *tmp_table=join->all_tables[tablenr];
  1526.     if (rec > tmp_table->file->records && rec > 100)
  1527.       rec=max(tmp_table->file->records,100);
  1528.   }
  1529. }
  1530.               }
  1531.       keyuse++;
  1532.     } while (keyuse->table == table && keyuse->key == key &&
  1533.      keyuse->keypart == keypart);
  1534.   } while (keyuse->table == table && keyuse->key == key);
  1535.   /*
  1536.   ** Assume that that each key matches a proportional part of table.
  1537.   */
  1538.           if (!found_part && !ft_key)
  1539.     continue; // Nothing usable found
  1540.   if (rec == 0)
  1541.     rec=1L; // Fix for small tables
  1542.           /*
  1543.           ** ft-keys require special treatment
  1544.           */
  1545.           if (ft_key)
  1546.           {
  1547.             /*
  1548.             ** Really, there should be records=0.0 (yes!)
  1549.             ** but 1.0 would be probably safer
  1550.             */
  1551.             tmp=prev_record_reads(join,found_ref);
  1552.             records=1.0;
  1553.           }
  1554.           else
  1555.           {
  1556.   /*
  1557.   ** Check if we found full key
  1558.   */
  1559.   if (found_part == PREV_BITS(uint,keyinfo->key_parts))
  1560.   { /* use eq key */
  1561.     max_key_part= (uint) ~0;
  1562.     if ((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME)
  1563.     {
  1564.       tmp=prev_record_reads(join,found_ref);
  1565.       records=1.0;
  1566.     }
  1567.     else
  1568.     {
  1569.       if (!found_ref)
  1570.       { // We found a const key
  1571. if (table->quick_keys & ((key_map) 1 << key))
  1572.   records= (double) table->quick_rows[key];
  1573. else
  1574.   records= (double) s->records/rec; // quick_range couldn't use key!
  1575.       }
  1576.       else
  1577.       {
  1578. if (!(records=keyinfo->rec_per_key[keyinfo->key_parts-1]))
  1579. { // Prefere longer keys
  1580.   records=
  1581.     ((double) s->records / (double) rec *
  1582.      (1.0 +
  1583.       ((double) (table->max_key_length-keyinfo->key_length) /
  1584.        (double) table->max_key_length)));
  1585.   if (records < 2.0)
  1586.     records=2.0; // Can't be as good as a unique
  1587. }
  1588.       }
  1589.       if (table->used_keys & ((key_map) 1 << key))
  1590.       {
  1591. /* we can use only index tree */
  1592. uint keys_per_block= table->file->block_size/2/
  1593.   keyinfo->key_length+1;
  1594. tmp=(record_count*(records+keys_per_block-1)/
  1595.      keys_per_block);
  1596.       }
  1597.       else
  1598. tmp=record_count*min(records,s->worst_seeks);
  1599.     }
  1600.   }
  1601.   else
  1602.   {
  1603.     /*
  1604.     ** Use as much key-parts as possible and a uniq key is better
  1605.     ** than a not unique key
  1606.     ** Set tmp to (previous record count) * (records / combination)
  1607.     */
  1608.     if ((found_part & 1) &&
  1609. !(table->file->option_flag() & HA_ONLY_WHOLE_INDEX))
  1610.     {
  1611.       max_key_part=max_part_bit(found_part);
  1612.       /* Check if quick_range could determinate how many rows we
  1613.  will match */
  1614.       if (table->quick_keys & ((key_map) 1 << key) &&
  1615.   table->quick_key_parts[key] <= max_key_part)
  1616. tmp=records= (double) table->quick_rows[key];
  1617.       else
  1618.       {
  1619. /* Check if we have statistic about the distribution */
  1620. if ((records=keyinfo->rec_per_key[max_key_part-1]))
  1621.   tmp=records;
  1622. else
  1623. {
  1624.   /*
  1625.   ** Assume that the first key part matches 1% of the file
  1626.   ** and that the hole key matches 10 (dupplicates) or 1
  1627.   ** (unique) records.
  1628.   ** Assume also that more key matches proportionally more
  1629.   ** records
  1630.   ** This gives the formula:
  1631.   ** records= (x * (b-a) + a*c-b)/(c-1)
  1632.   **
  1633.   ** b = records matched by whole key
  1634.   ** a = records matched by first key part (10% of all records?)
  1635.   ** c = number of key parts in key
  1636.   ** x = used key parts (1 <= x <= c)
  1637.   */
  1638.   double rec_per_key;
  1639.   if (!(rec_per_key=(double)
  1640. keyinfo->rec_per_key[keyinfo->key_parts-1]))
  1641.     rec_per_key=(double) s->records/rec+1;
  1642.   if (!s->records)
  1643.     tmp=0;
  1644.   else if (rec_per_key/(double) s->records >= 0.01)
  1645.     tmp=rec_per_key;
  1646.   else
  1647.   {
  1648.     double a=s->records*0.01;
  1649.     tmp=(max_key_part * (rec_per_key - a) +
  1650.  a*keyinfo->key_parts - rec_per_key)/
  1651.       (keyinfo->key_parts-1);
  1652.     set_if_bigger(tmp,1.0);
  1653.   }
  1654.   records=(ulong) tmp;
  1655. }
  1656.       }
  1657.       if (table->used_keys & ((key_map) 1 << key))
  1658.       {
  1659. /* we can use only index tree */
  1660. uint keys_per_block= table->file->block_size/2/
  1661.   keyinfo->key_length+1;
  1662. tmp=record_count*(tmp+keys_per_block-1)/keys_per_block;
  1663.       }
  1664.       else
  1665. tmp=record_count*min(tmp,s->worst_seeks);
  1666.     }
  1667.     else
  1668.       tmp=best_time; // Do nothing
  1669.   }
  1670.           } /* not ft_key */
  1671.   if (tmp < best_time - records/(double) TIME_FOR_COMPARE)
  1672.   {
  1673.     best_time=tmp + records/(double) TIME_FOR_COMPARE;
  1674.     best=tmp;
  1675.     best_records=records;
  1676.     best_key=start_key;
  1677.     best_max_key_part=max_key_part;
  1678.   }
  1679. }
  1680. records=best_records;
  1681.       }
  1682.       /*
  1683. Don't test table scan if it can't be better.
  1684. Prefer key lookup if we would use the same key for scanning.
  1685.       */
  1686.       if ((records >= s->found_records || best > s->read_time) &&
  1687.   !(s->quick && best_key && s->quick->index == best_key->key &&
  1688.     best_max_key_part >= s->table->quick_key_parts[best_key->key]))
  1689.       { // Check full join
  1690. if (s->on_expr)
  1691. {
  1692.   tmp=s->found_records; // Can't use read cache
  1693. }
  1694. else
  1695. {
  1696.   tmp=(double) s->read_time;
  1697.   /* Calculate time to read through cache */
  1698.   tmp*=(1.0+floor((double) cache_record_length(join,idx)*
  1699.   record_count/(double) join_buff_size));
  1700. }
  1701. if (best == DBL_MAX ||
  1702.     (tmp  + record_count/(double) TIME_FOR_COMPARE*s->found_records <
  1703.      best + record_count/(double) TIME_FOR_COMPARE*records))
  1704. {
  1705.   /*
  1706.     If the table has a range (s->quick is set) make_join_select()
  1707.     will ensure that this will be used
  1708.   */
  1709.   best=tmp;
  1710.   records=s->found_records;
  1711.   best_key=0;
  1712. }
  1713.       }
  1714.       join->positions[idx].records_read=(double) records;
  1715.       join->positions[idx].key=best_key;
  1716.       join->positions[idx].table= s;
  1717.       if (!best_key && idx == join->const_tables &&
  1718.   s->table == join->sort_by_table)
  1719. join->sort_by_table= (TABLE*) 1; // Must use temporary table
  1720.      /*
  1721. Go to the next level only if there hasn't been a better key on
  1722. this level! This will cut down the search for a lot simple cases!
  1723.        */
  1724.       double current_record_count=record_count*records;
  1725.       double current_read_time=read_time+best;
  1726.       if (best_record_count > current_record_count ||
  1727.   best_read_time > current_read_time ||
  1728.   idx == join->const_tables && s->table == join->sort_by_table)
  1729.       {
  1730. if (best_record_count >= current_record_count &&
  1731.     best_read_time >= current_read_time &&
  1732.     (!(s->key_dependent & rest_tables) || records < 2.0))
  1733. {
  1734.   best_record_count=current_record_count;
  1735.   best_read_time=current_read_time;
  1736. }
  1737. swap(JOIN_TAB*,join->best_ref[idx],*pos);
  1738. find_best(join,rest_tables & ~real_table_bit,idx+1,
  1739.   current_record_count,current_read_time);
  1740. swap(JOIN_TAB*,join->best_ref[idx],*pos);
  1741.       }
  1742.       if (join->select_options & SELECT_STRAIGHT_JOIN)
  1743. break; // Don't test all combinations
  1744.     }
  1745.   }
  1746. }
  1747. /*
  1748. ** Find how much space the prevous read not const tables takes in cache
  1749. */
  1750. static uint
  1751. cache_record_length(JOIN *join,uint idx)
  1752. {
  1753.   uint length;
  1754.   JOIN_TAB **pos,**end;
  1755.   THD *thd=current_thd;
  1756.   length=0;
  1757.   for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;
  1758.        pos != end ;
  1759.        pos++)
  1760.   {
  1761.     JOIN_TAB *join_tab= *pos;
  1762.     if (!join_tab->used_fieldlength)
  1763.     { /* Not calced yet */
  1764.       uint null_fields,blobs,fields,rec_length;
  1765.       null_fields=blobs=fields=rec_length=0;
  1766.       Field **f_ptr,*field;
  1767.       for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)
  1768.       {
  1769. if (field->query_id == thd->query_id)
  1770. {
  1771.   uint flags=field->flags;
  1772.   fields++;
  1773.   rec_length+=field->pack_length();
  1774.   if (flags & BLOB_FLAG)
  1775.     blobs++;
  1776.   if (!(flags & NOT_NULL_FLAG))
  1777.     null_fields++;
  1778. }
  1779.       }
  1780.       if (null_fields)
  1781. rec_length+=(join_tab->table->null_fields+7)/8;
  1782.       if (join_tab->table->maybe_null)
  1783. rec_length+=sizeof(my_bool);
  1784.       if (blobs)
  1785.       {
  1786. uint blob_length=(uint) (join_tab->table->file->mean_rec_length-
  1787.  (join_tab->table->reclength- rec_length));
  1788. rec_length+=(uint) max(4,blob_length);
  1789.       }
  1790.       join_tab->used_fields=fields;
  1791.       join_tab->used_fieldlength=rec_length;
  1792.       join_tab->used_blobs=blobs;
  1793.     }
  1794.     length+=join_tab->used_fieldlength;
  1795.   }
  1796.   return length;
  1797. }
  1798. static double
  1799. prev_record_reads(JOIN *join,table_map found_ref)
  1800. {
  1801.   double found=1.0;
  1802.   for (POSITION *pos=join->positions ; found_ref ; pos++)
  1803.   {
  1804.     if (pos->table->table->map & found_ref)
  1805.     {
  1806.       found_ref&= ~pos->table->table->map;
  1807.       found*=pos->records_read;
  1808.     }
  1809.   }
  1810.   return found;
  1811. }
  1812. /*****************************************************************************
  1813. ** Set up join struct according to best position.
  1814. *****************************************************************************/
  1815. static bool
  1816. get_best_combination(JOIN *join)
  1817. {
  1818.   uint i,key,tablenr;
  1819.   table_map used_tables;
  1820.   TABLE *table;
  1821.   JOIN_TAB *join_tab,*j;
  1822.   KEYUSE *keyuse;
  1823.   KEY *keyinfo;
  1824.   uint table_count;
  1825.   table_count=join->tables;
  1826.   if (!(join->join_tab=join_tab=
  1827. (JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB)*table_count)))
  1828.     return TRUE;
  1829.   join->const_tables=0; /* for checking */
  1830.   join->const_table_map=0;
  1831.   join->full_join=0;
  1832.   used_tables=0;
  1833.   for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)
  1834.   {
  1835.     TABLE *form;
  1836.     *j= *join->best_positions[tablenr].table;
  1837.     form=join->table[tablenr]=j->table;
  1838.     j->ref.key = -1;
  1839.     j->ref.key_parts=0;
  1840.     j->info=0; // For describe
  1841.     used_tables|= form->map;
  1842.     form->reginfo.join_tab=j;
  1843.     if (!j->on_expr)
  1844.       form->reginfo.not_exists_optimize=0; // Only with LEFT JOIN
  1845.     if (j->type == JT_SYSTEM)
  1846.     {
  1847.       j->table->const_table=1;
  1848.       if (join->const_tables == tablenr)
  1849.       {
  1850. join->const_tables++;
  1851. join->const_table_map|=form->map;
  1852.       }
  1853.       continue;
  1854.     }
  1855.     if (!j->keys || !(keyuse= join->best_positions[tablenr].key))
  1856.     {
  1857.       j->type=JT_ALL;
  1858.       if (tablenr != join->const_tables)
  1859. join->full_join=1;
  1860.     }
  1861.     else
  1862.     {
  1863.       uint keyparts,length;
  1864.       bool ftkey=(keyuse->keypart == FT_KEYPART);
  1865.       /*
  1866.       ** Use best key from find_best
  1867.       */
  1868.       table=j->table;
  1869.       key=keyuse->key;
  1870.       keyinfo=table->key_info+key;
  1871.       if (ftkey)
  1872.       {
  1873.         Item_func_match *ifm=(Item_func_match *)keyuse->val;
  1874.         length=0;
  1875.         keyparts=1;
  1876.         ifm->join_key=1;
  1877.       }
  1878.       else
  1879.       {
  1880.         keyparts=length=0;
  1881.         do
  1882.         {
  1883.           if (!((~used_tables) & keyuse->used_tables))
  1884.           {
  1885.             if (keyparts == keyuse->keypart)
  1886.             {
  1887.               keyparts++;
  1888.               length+=keyinfo->key_part[keyuse->keypart].store_length;
  1889.             }
  1890.           }
  1891.           keyuse++;
  1892.         } while (keyuse->table == table && keyuse->key == key);
  1893.       } /* not ftkey */
  1894.       /* set up fieldref */
  1895.       keyinfo=table->key_info+key;
  1896.       j->ref.key_parts=keyparts;
  1897.       j->ref.key_length=length;
  1898.       j->ref.key=(int) key;
  1899.       if (!(j->ref.key_buff= (byte*) sql_calloc(ALIGN_SIZE(length)*2)) ||
  1900.   !(j->ref.key_copy= (store_key**) sql_alloc((sizeof(store_key*) *
  1901.       (keyparts+1)))) ||
  1902.   !(j->ref.items=    (Item**) sql_alloc(sizeof(Item*)*keyparts)))
  1903.       {
  1904. return TRUE;
  1905.       }
  1906.       j->ref.key_buff2=j->ref.key_buff+ALIGN_SIZE(length);
  1907.       j->ref.key_err=1;
  1908.       keyuse=join->best_positions[tablenr].key;
  1909.       store_key **ref_key=j->ref.key_copy;
  1910.       byte *key_buff=j->ref.key_buff;
  1911.       if (ftkey)
  1912.       {
  1913.         j->ref.items[0]=((Item_func*)(keyuse->val))->key_item();
  1914.         if (keyuse->used_tables)
  1915.           return TRUE; // not supported yet. SerG
  1916.         j->type=JT_FT;
  1917.       }
  1918.       else
  1919.       {
  1920. THD *thd=current_thd;
  1921. for (i=0 ; i < keyparts ; keyuse++,i++)
  1922. {
  1923.   while (keyuse->keypart != i ||
  1924.  ((~used_tables) & keyuse->used_tables))
  1925.     keyuse++; /* Skipp other parts */
  1926.   uint maybe_null= test(keyinfo->key_part[i].null_bit);
  1927.   j->ref.items[i]=keyuse->val; // Save for cond removal
  1928.   if (!keyuse->used_tables &&
  1929.       !(join->select_options & SELECT_DESCRIBE))
  1930.   { // Compare against constant
  1931.     store_key_item *tmp=new store_key_item(keyinfo->key_part[i].field,
  1932.    (char*)key_buff +
  1933.    maybe_null,
  1934.    maybe_null ?
  1935.    (char*) key_buff : 0,
  1936.    keyinfo->key_part[i].length,
  1937.    keyuse->val);
  1938.     if (thd->fatal_error)
  1939.     {
  1940.       return TRUE;
  1941.     }
  1942.     tmp->copy();
  1943.   }
  1944.   else
  1945.     *ref_key++= get_store_key(keyuse,join->const_table_map,
  1946.       &keyinfo->key_part[i],
  1947.       (char*) key_buff,maybe_null);
  1948.   key_buff+=keyinfo->key_part[i].store_length;
  1949. }
  1950.       } /* not ftkey */
  1951.       *ref_key=0; // end_marker
  1952.       if (j->type == JT_FT)  /* no-op */;
  1953.       else if (j->type == JT_CONST)
  1954.       {
  1955. j->table->const_table=1;
  1956. if (join->const_tables == tablenr)
  1957. {
  1958.   join->const_tables++;
  1959.   join->const_table_map|=form->map;
  1960. }
  1961.       }
  1962.       else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||
  1963.        keyparts != keyinfo->key_parts)
  1964. j->type=JT_REF; /* Must read with repeat */
  1965.       else if (ref_key == j->ref.key_copy)
  1966.       { /* Should never be reached */
  1967. j->type=JT_CONST; /* purecov: deadcode */
  1968. if (join->const_tables == tablenr)
  1969. {
  1970.   join->const_tables++; /* purecov: deadcode */
  1971.   join->const_table_map|=form->map;
  1972. }
  1973.       }
  1974.       else
  1975. j->type=JT_EQ_REF;
  1976.     }
  1977.   }
  1978.   for (i=0 ; i < table_count ; i++)
  1979.     join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;
  1980.   update_depend_map(join);
  1981.   return 0;
  1982. }
  1983. static store_key *
  1984. get_store_key(KEYUSE *keyuse, table_map used_tables, KEY_PART_INFO *key_part,
  1985.       char *key_buff, uint maybe_null)
  1986. {
  1987.   if (!((~used_tables) & keyuse->used_tables)) // if const item
  1988.   {
  1989.     return new store_key_const_item(key_part->field,
  1990.     key_buff + maybe_null,
  1991.     maybe_null ? key_buff : 0,
  1992.     key_part->length,
  1993.     keyuse->val);
  1994.   }
  1995.   else if (keyuse->val->type() == Item::FIELD_ITEM)
  1996.     return new store_key_field(key_part->field,
  1997.        key_buff + maybe_null,
  1998.        maybe_null ? key_buff : 0,
  1999.        key_part->length,
  2000.        ((Item_field*) keyuse->val)->field,
  2001.        keyuse->val->full_name());
  2002.   return new store_key_item(key_part->field,
  2003.     key_buff + maybe_null,
  2004.     maybe_null ? key_buff : 0,
  2005.     key_part->length,
  2006.     keyuse->val);
  2007. }
  2008. /*
  2009. ** This function is only called for const items on fields which are keys
  2010. ** returns 1 if there was some conversion made when the field was stored.
  2011. */
  2012. bool
  2013. store_val_in_field(Field *field,Item *item)
  2014. {
  2015.   THD *thd=current_thd;
  2016.   ulong cuted_fields=thd->cuted_fields;
  2017.   thd->count_cuted_fields=1;
  2018.   item->save_in_field(field);
  2019.   thd->count_cuted_fields=0;
  2020.   return cuted_fields != thd->cuted_fields;
  2021. }
  2022. static bool
  2023. make_simple_join(JOIN *join,TABLE *tmp_table)
  2024. {
  2025.   TABLE **tableptr;
  2026.   JOIN_TAB *join_tab;
  2027.   if (!(tableptr=(TABLE**) join->thd->alloc(sizeof(TABLE*))) ||
  2028.       !(join_tab=(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))
  2029.     return TRUE;
  2030.   join->join_tab=join_tab;
  2031.   join->table=tableptr; tableptr[0]=tmp_table;
  2032.   join->tables=1;
  2033.   join->const_tables=0;
  2034.   join->const_table_map=0;
  2035.   join->tmp_table_param.copy_field_count=join->tmp_table_param.field_count=
  2036.     join->tmp_table_param.sum_func_count= join->tmp_table_param.func_count=0;
  2037.   join->tmp_table_param.copy_field=0;
  2038.   join->first_record=join->sort_and_group=0;
  2039.   join->sum_funcs=0;
  2040.   join->send_records=(ha_rows) 0;
  2041.   join->group=0;
  2042.   join_tab->cache.buff=0; /* No cacheing */
  2043.   join_tab->table=tmp_table;
  2044.   join_tab->select=0;
  2045.   join_tab->select_cond=0;
  2046.   join_tab->quick=0;
  2047.   join_tab->type= JT_ALL; /* Map through all records */
  2048.   join_tab->keys= (uint) ~0; /* test everything in quick */
  2049.   join_tab->info=0;
  2050.   join_tab->on_expr=0;
  2051.   join_tab->ref.key = -1;
  2052.   join_tab->not_used_in_distinct=0;
  2053.   join_tab->read_first_record= join_init_read_record;
  2054.   bzero((char*) &join_tab->read_record,sizeof(join_tab->read_record));
  2055.   tmp_table->status=0;
  2056.   tmp_table->null_row=0;
  2057.   return FALSE;
  2058. }
  2059. static bool
  2060. make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
  2061. {
  2062.   DBUG_ENTER("make_join_select");
  2063.   if (select)
  2064.   {
  2065.     table_map used_tables;
  2066.     if (join->tables > 1)
  2067.       cond->update_used_tables(); // Tablenr may have changed
  2068.     { // Check const tables
  2069.       COND *const_cond=
  2070. make_cond_for_table(cond,join->const_table_map,(table_map) 0);
  2071.       DBUG_EXECUTE("where",print_where(const_cond,"constants"););
  2072.       if (const_cond && !const_cond->val_int())
  2073.       {
  2074. DBUG_PRINT("info",("Found impossible WHERE condition"));
  2075. DBUG_RETURN(1); // Impossible const condition
  2076.       }
  2077.     }
  2078.     used_tables=(select->const_tables=join->const_table_map) | RAND_TABLE_BIT;
  2079.     for (uint i=join->const_tables ; i < join->tables ; i++)
  2080.     {
  2081.       JOIN_TAB *tab=join->join_tab+i;
  2082.       table_map current_map= tab->table->map;
  2083.       used_tables|=current_map;
  2084.       COND *tmp=make_cond_for_table(cond,used_tables,current_map);
  2085.       if (!tmp && tab->quick)
  2086.       { // Outer join
  2087. /*
  2088.   Hack to handle the case where we only refer to a table
  2089.   in the ON part of an OUTER JOIN.
  2090. */
  2091. tmp=new Item_int((longlong) 1,1); // Always true
  2092.       }
  2093.       if (tmp)
  2094.       {
  2095. DBUG_EXECUTE("where",print_where(tmp,tab->table->table_name););
  2096. SQL_SELECT *sel=tab->select=(SQL_SELECT*)
  2097.   sql_memdup((gptr) select, sizeof(SQL_SELECT));
  2098. if (!sel)
  2099.   DBUG_RETURN(1); // End of memory
  2100. tab->select_cond=sel->cond=tmp;
  2101. sel->head=tab->table;
  2102. if (tab->quick)
  2103. {
  2104.   /* Use quick key read if it's a constant and it's not used
  2105.      with key reading */
  2106.   if (tab->needed_reg == 0 && tab->type != JT_EQ_REF
  2107.       && tab->type != JT_FT && (tab->type != JT_REF ||
  2108.        (uint) tab->ref.key == tab->quick->index))
  2109.   {
  2110.     sel->quick=tab->quick; // Use value from get_quick_...
  2111.     sel->quick_keys=0;
  2112.     sel->needed_reg=0;
  2113.   }
  2114.   else
  2115.   {
  2116.     delete tab->quick;
  2117.   }
  2118.   tab->quick=0;
  2119. }
  2120. uint ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;
  2121. if (i == join->const_tables && ref_key)
  2122. {
  2123.   if (tab->const_keys && tab->table->reginfo.impossible_range)
  2124.     DBUG_RETURN(1);
  2125. }
  2126. else if (tab->type == JT_ALL)
  2127. {
  2128.   if (tab->const_keys &&
  2129.       tab->table->reginfo.impossible_range)
  2130.     DBUG_RETURN(1); // Impossible range
  2131.   /*
  2132.     We plan to scan all rows.
  2133.     Check again if we should use an index.
  2134.     We could have used an column from a previous table in
  2135.     the index if we are using limit and this is the first table
  2136.   */
  2137.   if ((tab->keys & ~ tab->const_keys && i > 0) ||
  2138.       tab->const_keys && i == join->const_tables &&
  2139.       join->thd->select_limit < join->best_positions[i].records_read)
  2140.   {
  2141.     /* Join with outer join condition */
  2142.     COND *orig_cond=sel->cond;
  2143.     sel->cond=and_conds(sel->cond,tab->on_expr);
  2144.     if (sel->test_quick_select(tab->keys,
  2145.        used_tables & ~ current_map,
  2146.        join->thd->select_limit) < 0)
  2147.       DBUG_RETURN(1); // Impossible range
  2148.     sel->cond=orig_cond;
  2149.   }
  2150.   else
  2151.   {
  2152.     sel->needed_reg=tab->needed_reg;
  2153.     sel->quick_keys=0;
  2154.   }
  2155.   if ((sel->quick_keys | sel->needed_reg) & ~tab->checked_keys)
  2156.   {
  2157.     tab->keys=sel->quick_keys | sel->needed_reg;
  2158.     tab->use_quick= (sel->needed_reg &&
  2159.      (!select->quick_keys ||
  2160.       (select->quick &&
  2161.        (select->quick->records >= 100L)))) ?
  2162.       2 : 1;
  2163.     sel->read_tables= used_tables;
  2164.   }
  2165.   if (i != join->const_tables && tab->use_quick != 2)
  2166.   { /* Read with cache */
  2167.     if ((tmp=make_cond_for_table(cond,
  2168.  join->const_table_map |
  2169.  current_map,
  2170.  current_map)))
  2171.     {
  2172.       DBUG_EXECUTE("where",print_where(tmp,"cache"););
  2173.       tab->cache.select=(SQL_SELECT*) sql_memdup((gptr) sel,
  2174.     sizeof(SQL_SELECT));
  2175.       tab->cache.select->cond=tmp;
  2176.       tab->cache.select->read_tables=join->const_table_map;
  2177.     }
  2178.   }
  2179. }
  2180. if (tab->type == JT_REF && sel->quick &&
  2181.     tab->ref.key_length < sel->quick->max_used_key_length)
  2182. {
  2183.   /* Range uses longer key;  Use this instead of ref on key */
  2184.   tab->type=JT_ALL;
  2185.   tab->use_quick=1;
  2186.   tab->ref.key_parts=0; // Don't use ref key.
  2187.   join->best_positions[i].records_read=sel->quick->records;
  2188. }
  2189.       }
  2190.     }
  2191.   }
  2192.   DBUG_RETURN(0);
  2193. }
  2194. static void
  2195. make_join_readinfo(JOIN *join,uint options)
  2196. {
  2197.   uint i;
  2198.   DBUG_ENTER("make_join_readinfo");
  2199.   for (i=join->const_tables ; i < join->tables ; i++)
  2200.   {
  2201.     JOIN_TAB *tab=join->join_tab+i;
  2202.     TABLE *table=tab->table;
  2203.     tab->read_record.table= table;
  2204.     tab->read_record.file=table->file;
  2205.     tab->next_select=sub_select; /* normal select */
  2206.     switch (tab->type) {
  2207.     case JT_SYSTEM: // Only happens with left join
  2208.       table->status=STATUS_NO_RECORD;
  2209.       tab->read_first_record= join_read_system;
  2210.       tab->read_record.read_record= join_no_more_records;
  2211.       break;
  2212.     case JT_CONST: // Only happens with left join
  2213.       table->status=STATUS_NO_RECORD;
  2214.       tab->read_first_record= join_read_const;
  2215.       tab->read_record.read_record= join_no_more_records;
  2216.       break;
  2217.     case JT_EQ_REF:
  2218.       table->status=STATUS_NO_RECORD;
  2219.       if (tab->select)
  2220.       {
  2221. delete tab->select->quick;
  2222. tab->select->quick=0;
  2223.       }
  2224.       delete tab->quick;
  2225.       tab->quick=0;
  2226.       table->file->index_init(tab->ref.key);
  2227.       tab->read_first_record= join_read_key;
  2228.       tab->read_record.read_record= join_no_more_records;
  2229.       if (table->used_keys & ((key_map) 1 << tab->ref.key))
  2230.       {
  2231. table->key_read=1;
  2232. table->file->extra(HA_EXTRA_KEYREAD);
  2233.       }
  2234.       break;
  2235.     case JT_REF:
  2236.       table->status=STATUS_NO_RECORD;
  2237.       if (tab->select)
  2238.       {
  2239. delete tab->select->quick;
  2240. tab->select->quick=0;
  2241.       }
  2242.       delete tab->quick;
  2243.       tab->quick=0;
  2244.       table->file->index_init(tab->ref.key);
  2245.       tab->read_first_record= join_read_always_key;
  2246.       tab->read_record.read_record= join_read_next;
  2247.       if (table->used_keys & ((key_map) 1 << tab->ref.key))
  2248.       {
  2249. table->key_read=1;
  2250. table->file->extra(HA_EXTRA_KEYREAD);
  2251.       }
  2252.       break;
  2253.     case JT_FT:
  2254.       table->status=STATUS_NO_RECORD;
  2255.       table->file->index_init(tab->ref.key);
  2256.       tab->read_first_record= join_ft_read_first;
  2257.       tab->read_record.read_record= join_ft_read_next;
  2258.       break;
  2259.     case JT_ALL:
  2260.       /*
  2261.       ** if previous table use cache
  2262.       */
  2263.       table->status=STATUS_NO_RECORD;
  2264.       if (i != join->const_tables && (options & SELECT_USE_CACHE) &&
  2265.   tab->use_quick != 2 && !tab->on_expr)
  2266.       {
  2267. if ((options & SELECT_DESCRIBE) ||
  2268.     !join_init_cache(join->thd,join->join_tab+join->const_tables,
  2269.      i-join->const_tables))
  2270. {
  2271.   tab[-1].next_select=sub_select_cache; /* Patch previous */
  2272. }
  2273.       }
  2274.       /* These init changes read_record */
  2275.       if (tab->use_quick == 2)
  2276.       {
  2277. join->thd->lex.options|=QUERY_NO_GOOD_INDEX_USED;
  2278. tab->read_first_record= join_init_quick_read_record;
  2279. statistic_increment(select_range_check_count, &LOCK_status);
  2280.       }
  2281.       else
  2282.       {
  2283. tab->read_first_record= join_init_read_record;
  2284. if (i == join->const_tables)
  2285. {
  2286.   if (tab->select && tab->select->quick)
  2287.   {
  2288.     statistic_increment(select_range_count, &LOCK_status);
  2289.   }
  2290.   else
  2291.   {
  2292.     join->thd->lex.options|=QUERY_NO_INDEX_USED;
  2293.     statistic_increment(select_scan_count, &LOCK_status);
  2294.   }
  2295. }
  2296. else
  2297. {
  2298.   if (tab->select && tab->select->quick)
  2299.   {
  2300.     statistic_increment(select_full_range_join_count, &LOCK_status);
  2301.   }
  2302.   else
  2303.   {
  2304.     join->thd->lex.options|=QUERY_NO_INDEX_USED;
  2305.     statistic_increment(select_full_join_count, &LOCK_status);
  2306.   }
  2307. }
  2308. if (tab->select && tab->select->quick &&
  2309.     table->used_keys & ((key_map) 1 << tab->select->quick->index))
  2310. {
  2311.   table->key_read=1;
  2312.   table->file->extra(HA_EXTRA_KEYREAD);
  2313. }
  2314. else if (table->used_keys && ! (tab->select && tab->select->quick))
  2315. { // Only read index tree
  2316.   tab->index=find_shortest_key(table, table->used_keys);
  2317.   tab->table->file->index_init(tab->index);
  2318.   tab->read_first_record= join_init_read_first_with_key;
  2319.   tab->type=JT_NEXT; // Read with index_first / index_next
  2320. }
  2321.       }
  2322.       break;
  2323.     default:
  2324.       DBUG_PRINT("error",("Table type %d found",tab->type)); /* purecov: deadcode */
  2325.       break; /* purecov: deadcode */
  2326.     case JT_UNKNOWN:
  2327.     case JT_MAYBE_REF:
  2328.       abort(); /* purecov: deadcode */
  2329.     }
  2330.   }
  2331.   join->join_tab[join->tables-1].next_select=0; /* Set by do_select */
  2332.   DBUG_VOID_RETURN;
  2333. }
  2334. static void
  2335. join_free(JOIN *join)
  2336. {
  2337.   JOIN_TAB *tab,*end;
  2338.   if (join->table)
  2339.   {
  2340.     /*
  2341.       Only a sorted table may be cached.  This sorted table is always the
  2342.       first non const table in join->table
  2343.     */
  2344.     if (join->tables > join->const_tables) // Test for not-const tables
  2345.       free_io_cache(join->table[join->const_tables]);
  2346.     for (tab=join->join_tab,end=tab+join->tables ; tab != end ; tab++)
  2347.     {
  2348.       delete tab->select;
  2349.       delete tab->quick;
  2350.       x_free(tab->cache.buff);
  2351.       end_read_record(&tab->read_record);
  2352.       if (tab->table)
  2353.       {
  2354. if (tab->table->key_read)
  2355. {
  2356.   tab->table->key_read=0;
  2357.   tab->table->file->extra(HA_EXTRA_NO_KEYREAD);
  2358. }
  2359. tab->table->file->index_end();
  2360.       }
  2361.     }
  2362.     join->table=0;
  2363.   }
  2364.   // We are not using tables anymore
  2365.   // Unlock all tables. We may be in an INSERT .... SELECT statement.
  2366.   if (join->lock && join->thd->lock)
  2367.   {
  2368.     mysql_unlock_read_tables(join->thd, join->lock);// Don't free join->lock
  2369.     join->lock=0;
  2370.   }
  2371.   join->group_fields.delete_elements();
  2372.   join->tmp_table_param.copy_funcs.delete_elements();
  2373.   delete [] join->tmp_table_param.copy_field;
  2374.   join->tmp_table_param.copy_field=0;
  2375. }
  2376. /*****************************************************************************
  2377. ** Remove the following expressions from ORDER BY and GROUP BY:
  2378. ** Constant expressions
  2379. ** Expression that only uses tables that are of type EQ_REF and the reference
  2380. ** is in the ORDER list or if all refereed tables are of the above type.
  2381. **
  2382. ** In the following, the X field can be removed:
  2383. ** SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t1.a,t2.X
  2384. ** SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b ORDER BY t1.a,t3.X
  2385. **
  2386. ** These can't be optimized:
  2387. ** SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.X,t1.a
  2388. ** SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b ORDER BY t1.a,t2.c
  2389. ** SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.b,t1.a
  2390. *****************************************************************************/
  2391. static bool
  2392. eq_ref_table(JOIN *join, ORDER *start_order, JOIN_TAB *tab)
  2393. {
  2394.   if (tab->cached_eq_ref_table) // If cached
  2395.     return tab->eq_ref_table;
  2396.   tab->cached_eq_ref_table=1;
  2397.   if (tab->type == JT_CONST) // We can skip const tables
  2398.     return (tab->eq_ref_table=1); /* purecov: inspected */
  2399.   if (tab->type != JT_EQ_REF)
  2400.     return (tab->eq_ref_table=0); // We must use this
  2401.   Item **ref_item=tab->ref.items;
  2402.   Item **end=ref_item+tab->ref.key_parts;
  2403.   uint found=0;
  2404.   table_map map=tab->table->map;
  2405.   for (; ref_item != end ; ref_item++)
  2406.   {
  2407.     if (! (*ref_item)->const_item())
  2408.     { // Not a const ref
  2409.       ORDER *order;
  2410.       for (order=start_order ; order ; order=order->next)
  2411.       {
  2412. if ((*ref_item)->eq(order->item[0]))
  2413.   break;
  2414.       }
  2415.       if (order)
  2416.       {
  2417. found++;
  2418. dbug_assert(!(order->used & map));
  2419. order->used|=map;
  2420. continue; // Used in ORDER BY
  2421.       }
  2422.       if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))
  2423. return (tab->eq_ref_table=0);
  2424.     }
  2425.   }
  2426.   /* Check that there was no reference to table before sort order */
  2427.   for ( ; found && start_order ; start_order=start_order->next)
  2428.   {
  2429.     if (start_order->used & map)
  2430.     {
  2431.       found--;
  2432.       continue;
  2433.     }
  2434.     if (start_order->depend_map & map)
  2435.       return (tab->eq_ref_table=0);
  2436.   }
  2437.   return tab->eq_ref_table=1;
  2438. }
  2439. static bool
  2440. only_eq_ref_tables(JOIN *join,ORDER *order,table_map tables)
  2441. {
  2442.   if (specialflag &  SPECIAL_SAFE_MODE)
  2443.     return 0; // skip this optimize /* purecov: inspected */
  2444.   for (JOIN_TAB **tab=join->map2table ; tables ; tab++, tables>>=1)
  2445.   {
  2446.     if (tables & 1 && !eq_ref_table(join, order, *tab))
  2447.       return 0;
  2448.   }
  2449.   return 1;
  2450. }
  2451. /* Update the dependency map for the tables */
  2452. static void update_depend_map(JOIN *join)
  2453. {
  2454.   JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;
  2455.   for ( ; join_tab != end ; join_tab++)
  2456.   {
  2457.     TABLE_REF *ref= &join_tab->ref;
  2458.     table_map depend_map=0;
  2459.     Item **item=ref->items;
  2460.     uint i;
  2461.     for (i=0 ; i < ref->key_parts ; i++,item++)
  2462.       depend_map|=(*item)->used_tables();
  2463.     ref->depend_map=depend_map;
  2464.     for (JOIN_TAB *join_tab2=join->join_tab;
  2465.  depend_map ;
  2466.  join_tab2++,depend_map>>=1 )
  2467.     {
  2468.       if (depend_map & 1)
  2469. ref->depend_map|=join_tab2->ref.depend_map;
  2470.     }
  2471.   }
  2472. }
  2473. /* Update the dependency map for the sort order */
  2474. static void update_depend_map(JOIN *join, ORDER *order)
  2475. {
  2476.   for ( ; order ; order=order->next)
  2477.   {
  2478.     table_map depend_map;
  2479.     order->item[0]->update_used_tables();
  2480.     order->depend_map=depend_map=order->item[0]->used_tables();
  2481.     if (!(order->depend_map & RAND_TABLE_BIT)) // Not item_sum() or RAND()
  2482.     {
  2483.       for (JOIN_TAB *join_tab=join->join_tab;
  2484.    depend_map ;
  2485.    join_tab++, depend_map>>=1)
  2486.       {
  2487. if (depend_map & 1)
  2488.   order->depend_map|=join_tab->ref.depend_map;
  2489.       }
  2490.     }
  2491.   }
  2492. }
  2493. /*
  2494. **  simple_order is set to 1 if sort_order only uses fields from head table
  2495. **  and the head table is not a LEFT JOIN table
  2496. */
  2497. static ORDER *
  2498. remove_const(JOIN *join,ORDER *first_order, COND *cond, bool *simple_order)
  2499. {
  2500.   if (join->tables == join->const_tables)
  2501.     return 0; // No need to sort
  2502.   DBUG_ENTER("remove_const");
  2503.   ORDER *order,**prev_ptr;
  2504.   table_map first_table= join->join_tab[join->const_tables].table->map;
  2505.   table_map not_const_tables= ~join->const_table_map;
  2506.   table_map ref;
  2507.   prev_ptr= &first_order;
  2508.   *simple_order= join->join_tab[join->const_tables].on_expr ? 0 : 1;
  2509.   /* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */
  2510.   update_depend_map(join, first_order);
  2511.   for (order=first_order; order ; order=order->next)
  2512.   {
  2513.     table_map order_tables=order->item[0]->used_tables();
  2514.     if (order->item[0]->with_sum_func)
  2515.       *simple_order=0; // Must do a temp table to sort
  2516.     else if (!(order_tables & not_const_tables))
  2517.     {
  2518.       DBUG_PRINT("info",("removing: %s", order->item[0]->full_name()));
  2519.       continue; // skipp const item
  2520.     }
  2521.     else
  2522.     {
  2523.       if (order_tables & RAND_TABLE_BIT)
  2524. *simple_order=0;
  2525.       else
  2526.       {
  2527. Item *comp_item=0;
  2528. if (cond && const_expression_in_where(cond,order->item[0], &comp_item))
  2529. {
  2530.   DBUG_PRINT("info",("removing: %s", order->item[0]->full_name()));
  2531.   continue;
  2532. }
  2533. if ((ref=order_tables & (not_const_tables ^ first_table)))
  2534. {
  2535.   if (only_eq_ref_tables(join,first_order,ref))
  2536.   {
  2537.     DBUG_PRINT("info",("removing: %s", order->item[0]->full_name()));
  2538.     continue;
  2539.   }
  2540.   *simple_order=0; // Must do a temp table to sort
  2541. }
  2542.       }
  2543.     }
  2544.     *prev_ptr= order; // use this entry
  2545.     prev_ptr= &order->next;
  2546.   }
  2547.   *prev_ptr=0;
  2548.   if (!first_order) // Nothing to sort/group
  2549.     *simple_order=1;
  2550.   DBUG_PRINT("exit",("simple_order: %d",(int) *simple_order));
  2551.   DBUG_RETURN(first_order);
  2552. }
  2553. static int
  2554. return_zero_rows(select_result *result,TABLE_LIST *tables,List<Item> &fields,
  2555.  bool send_row, uint select_options,const char *info,
  2556.  Item *having, Procedure *procedure)
  2557. {
  2558.   DBUG_ENTER("return_zero_rows");
  2559.   if (select_options & SELECT_DESCRIBE)
  2560.   {
  2561.     describe_info(current_thd, info);
  2562.     DBUG_RETURN(0);
  2563.   }
  2564.   if (procedure)
  2565.   {
  2566.     if (result->prepare(fields)) // This hasn't been done yet
  2567.       DBUG_RETURN(-1);
  2568.   }
  2569.   if (send_row)
  2570.   {
  2571.     for (TABLE_LIST *table=tables; table ; table=table->next)
  2572.       mark_as_null_row(table->table); // All fields are NULL
  2573.     if (having && having->val_int() == 0)
  2574.       send_row=0;
  2575.   }
  2576.   if (!tables || !(result->send_fields(fields,1)))
  2577.   {
  2578.     if (send_row)
  2579.       result->send_data(fields);
  2580.     if (tables) // Not from do_select()
  2581.       result->send_eof(); // Should be safe
  2582.   }
  2583.   DBUG_RETURN(0);
  2584. }
  2585. static void clear_tables(JOIN *join)
  2586. {
  2587.   for (uint i=0 ; i < join->tables ; i++)
  2588.     mark_as_null_row(join->table[i]); // All fields are NULL
  2589. }
  2590. /*****************************************************************************
  2591. ** Make som simple condition optimization:
  2592. ** If there is a test 'field = const' change all refs to 'field' to 'const'
  2593. ** Remove all dummy tests 'item = item', 'const op const'.
  2594. ** Remove all 'item is NULL', when item can never be null!
  2595. ** item->marker should be 0 for all items on entry
  2596. ** Return in cond_value FALSE if condition is impossible (1 = 2)
  2597. *****************************************************************************/
  2598. class COND_CMP :public ilink {
  2599. public:
  2600.   static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
  2601.   static void operator delete(void *ptr __attribute__((unused)),
  2602.       size_t size __attribute__((unused))) {} /*lint -e715 */
  2603.   Item *and_level;
  2604.   Item_func *cmp_func;
  2605.   COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}
  2606. };
  2607. #ifdef __GNUC__
  2608. template class I_List<COND_CMP>;
  2609. template class I_List_iterator<COND_CMP>;
  2610. template class List<Item_func_match>;
  2611. template class List_iterator<Item_func_match>;
  2612. #endif
  2613. /*
  2614. ** change field = field to field = const for each found field = const in the
  2615. ** and_level
  2616. */
  2617. static void
  2618. change_cond_ref_to_const(I_List<COND_CMP> *save_list,Item *and_father,
  2619.  Item *cond, Item *field, Item *value)
  2620. {
  2621.   if (cond->type() == Item::COND_ITEM)
  2622.   {
  2623.     bool and_level= ((Item_cond*) cond)->functype() ==
  2624.       Item_func::COND_AND_FUNC;
  2625.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  2626.     Item *item;
  2627.     while ((item=li++))
  2628.       change_cond_ref_to_const(save_list,and_level ? cond : item, item,
  2629.        field, value);
  2630.     return;
  2631.   }
  2632.   if (cond->eq_cmp_result() == Item::COND_OK)
  2633.     return; // Not a boolean function
  2634.   Item_bool_func2 *func=  (Item_bool_func2*) cond;
  2635.   Item *left_item=  func->arguments()[0];
  2636.   Item *right_item= func->arguments()[1];
  2637.   Item_func::Functype functype=  func->functype();
  2638.   if (right_item->eq(field) && left_item != value)
  2639.   {
  2640.     Item *tmp=value->new_item();
  2641.     if (tmp)
  2642.     {
  2643.       func->arguments()[1] = tmp;
  2644.       func->update_used_tables();
  2645.       if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)
  2646.   && and_father != cond && !left_item->const_item())
  2647.       {
  2648. cond->marker=1;
  2649. COND_CMP *tmp2;
  2650. if ((tmp2=new COND_CMP(and_father,func)))
  2651.   save_list->push_back(tmp2);
  2652.       }
  2653.       func->set_cmp_func(item_cmp_type(func->arguments()[0]->result_type(),
  2654.        func->arguments()[1]->result_type()));
  2655.     }
  2656.   }
  2657.   else if (left_item->eq(field) && right_item != value)
  2658.   {
  2659.     Item *tmp=value->new_item();
  2660.     if (tmp)
  2661.     {
  2662.       func->arguments()[0] = value = tmp;
  2663.       func->update_used_tables();
  2664.       if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)
  2665.   && and_father != cond && !right_item->const_item())
  2666.       {
  2667. func->arguments()[0] = func->arguments()[1]; // For easy check
  2668. func->arguments()[1] = value;
  2669. cond->marker=1;
  2670. COND_CMP *tmp2;
  2671. if ((tmp2=new COND_CMP(and_father,func)))
  2672.   save_list->push_back(tmp2);
  2673.       }
  2674.       func->set_cmp_func(item_cmp_type(func->arguments()[0]->result_type(),
  2675.        func->arguments()[1]->result_type()));
  2676.     }
  2677.   }
  2678. }
  2679. static void
  2680. propagate_cond_constants(I_List<COND_CMP> *save_list,COND *and_level,
  2681.  COND *cond)
  2682. {
  2683.   if (cond->type() == Item::COND_ITEM)
  2684.   {
  2685.     bool and_level= ((Item_cond*) cond)->functype() ==
  2686.       Item_func::COND_AND_FUNC;
  2687.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  2688.     Item *item;
  2689.     I_List<COND_CMP> save;
  2690.     while ((item=li++))
  2691.     {
  2692.       propagate_cond_constants(&save,and_level ? cond : item, item);
  2693.     }
  2694.     if (and_level)
  2695.     { // Handle other found items
  2696.       I_List_iterator<COND_CMP> cond_itr(save);
  2697.       COND_CMP *cond_cmp;
  2698.       while ((cond_cmp=cond_itr++))
  2699. if (!cond_cmp->cmp_func->arguments()[0]->const_item())
  2700.   change_cond_ref_to_const(&save,cond_cmp->and_level,
  2701.    cond_cmp->and_level,
  2702.    cond_cmp->cmp_func->arguments()[0],
  2703.    cond_cmp->cmp_func->arguments()[1]);
  2704.     }
  2705.   }
  2706.   else if (and_level != cond && !cond->marker) // In a AND group
  2707.   {
  2708.     if (cond->type() == Item::FUNC_ITEM &&
  2709. (((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||
  2710.  ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))
  2711.     {
  2712.       Item_func_eq *func=(Item_func_eq*) cond;
  2713.       bool left_const= func->arguments()[0]->const_item();
  2714.       bool right_const=func->arguments()[1]->const_item();
  2715.       if (!(left_const && right_const))
  2716.       {
  2717. if (right_const)
  2718. {
  2719.   func->arguments()[1]=resolve_const_item(func->arguments()[1],
  2720.   func->arguments()[0]);
  2721.   func->update_used_tables();
  2722.   change_cond_ref_to_const(save_list,and_level,and_level,
  2723.    func->arguments()[0],
  2724.    func->arguments()[1]);
  2725. }
  2726. else if (left_const)
  2727. {
  2728.   func->arguments()[0]=resolve_const_item(func->arguments()[0],
  2729.   func->arguments()[1]);
  2730.   func->update_used_tables();
  2731.   change_cond_ref_to_const(save_list,and_level,and_level,
  2732.    func->arguments()[1],
  2733.    func->arguments()[0]);
  2734. }
  2735.       }
  2736.     }
  2737.   }
  2738. }
  2739. static COND *
  2740. optimize_cond(COND *conds,Item::cond_result *cond_value)
  2741. {
  2742.   if (!conds)
  2743.   {
  2744.     *cond_value= Item::COND_TRUE;
  2745.     return conds;
  2746.   }
  2747.   /* change field = field to field = const for each found field = const */
  2748.   DBUG_EXECUTE("where",print_where(conds,"original"););
  2749.   propagate_cond_constants((I_List<COND_CMP> *) 0,conds,conds);
  2750.   /*
  2751.   ** Remove all instances of item == item
  2752.   ** Remove all and-levels where CONST item != CONST item
  2753.   */
  2754.   DBUG_EXECUTE("where",print_where(conds,"after const change"););
  2755.   conds=remove_eq_conds(conds,cond_value) ;
  2756.   DBUG_EXECUTE("info",print_where(conds,"after remove"););
  2757.   return conds;
  2758. }
  2759. /*
  2760. ** remove const and eq items. Return new item, or NULL if no condition
  2761. ** cond_value is set to according:
  2762. ** COND_OK    query is possible (field = constant)
  2763. ** COND_TRUE  always true ( 1 = 1 )
  2764. ** COND_FALSE always false ( 1 = 2 )
  2765. */
  2766. static COND *
  2767. remove_eq_conds(COND *cond,Item::cond_result *cond_value)
  2768. {
  2769.   if (cond->type() == Item::COND_ITEM)
  2770.   {
  2771.     bool and_level= ((Item_cond*) cond)->functype()
  2772.       == Item_func::COND_AND_FUNC;
  2773.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  2774.     Item::cond_result tmp_cond_value;
  2775.     *cond_value=Item::COND_UNDEF;
  2776.     Item *item;
  2777.     while ((item=li++))
  2778.     {
  2779.       Item *new_item=remove_eq_conds(item,&tmp_cond_value);
  2780.       if (!new_item)
  2781.       {
  2782. #ifdef DELETE_ITEMS
  2783. delete item; // This may be shared
  2784. #endif
  2785. li.remove();
  2786.       }
  2787.       else if (item != new_item)
  2788.       {
  2789. #ifdef DELETE_ITEMS
  2790. delete item; // This may be shared
  2791. #endif
  2792. VOID(li.replace(new_item));
  2793.       }
  2794.       if (*cond_value == Item::COND_UNDEF)
  2795. *cond_value=tmp_cond_value;
  2796.       switch (tmp_cond_value) {
  2797.       case Item::COND_OK: // Not TRUE or FALSE
  2798. if (and_level || *cond_value == Item::COND_FALSE)
  2799.   *cond_value=tmp_cond_value;
  2800. break;
  2801.       case Item::COND_FALSE:
  2802. if (and_level)
  2803. {
  2804.   *cond_value=tmp_cond_value;
  2805.   return (COND*) 0; // Always false
  2806. }
  2807. break;
  2808.       case Item::COND_TRUE:
  2809. if (!and_level)
  2810. {
  2811.   *cond_value= tmp_cond_value;
  2812.   return (COND*) 0; // Always true
  2813. }
  2814. break;
  2815.       case Item::COND_UNDEF: // Impossible
  2816. break; /* purecov: deadcode */
  2817.       }
  2818.     }
  2819.     if (!((Item_cond*) cond)->argument_list()->elements ||
  2820. *cond_value != Item::COND_OK)
  2821.       return (COND*) 0;
  2822.     if (((Item_cond*) cond)->argument_list()->elements == 1)
  2823.     { // Remove list
  2824.       item= ((Item_cond*) cond)->argument_list()->head();
  2825.       ((Item_cond*) cond)->argument_list()->empty();
  2826.       return item;
  2827.     }
  2828.   }
  2829.   else if (cond->type() == Item::FUNC_ITEM &&
  2830.    ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)
  2831.   {
  2832.     /*
  2833.     ** Handles this special case for some ODBC applications:
  2834.     ** The are requesting the row that was just updated with a auto_increment
  2835.     ** value with this construct:
  2836.     **
  2837.     ** SELECT * from table_name where auto_increment_column IS NULL
  2838.     ** This will be changed to:
  2839.     ** SELECT * from table_name where auto_increment_column = LAST_INSERT_ID
  2840.     */
  2841.     Item_func_isnull *func=(Item_func_isnull*) cond;
  2842.     Item **args= func->arguments();
  2843.     THD *thd=current_thd;
  2844.     if (args[0]->type() == Item::FIELD_ITEM)
  2845.     {
  2846.       Field *field=((Item_field*) args[0])->field;
  2847.       if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&
  2848.   (thd->options & OPTION_AUTO_IS_NULL) &&
  2849.   thd->insert_id())
  2850.       {
  2851. COND *new_cond;
  2852. if ((new_cond= new Item_func_eq(args[0],
  2853. new Item_int("last_insert_id()",
  2854.      thd->insert_id(),
  2855.      21))))
  2856. {
  2857.   cond=new_cond;
  2858.   cond->fix_fields(thd,0);
  2859. }
  2860. thd->insert_id(0); // Clear for next request
  2861.       }
  2862.       /* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */
  2863.       else if (((field->type() == FIELD_TYPE_DATE) ||
  2864. (field->type() == FIELD_TYPE_DATETIME)) &&
  2865. (field->flags & NOT_NULL_FLAG))
  2866.       {
  2867. COND *new_cond;
  2868. if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))
  2869. {
  2870.   cond=new_cond;
  2871.   cond->fix_fields(thd,0);
  2872. }
  2873.       }
  2874.     }
  2875.   }
  2876.   else if (cond->const_item())
  2877.   {
  2878.     *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
  2879.     return (COND*) 0;
  2880.   }
  2881.   else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)
  2882.   { // boolan compare function
  2883.     Item *left_item= ((Item_func*) cond)->arguments()[0];
  2884.     Item *right_item= ((Item_func*) cond)->arguments()[1];
  2885.     if (left_item->eq(right_item))
  2886.     {
  2887.       if (!left_item->maybe_null ||
  2888.   ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)
  2889. return (COND*) 0; // Compare of identical items
  2890.     }
  2891.   }
  2892.   *cond_value=Item::COND_OK;
  2893.   return cond; /* Point at next and level */
  2894. }
  2895. /*
  2896. ** Return 1 if the item is a const value in all the WHERE clause
  2897. */
  2898. static bool
  2899. const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)
  2900. {
  2901.   if (cond->type() == Item::COND_ITEM)
  2902.   {
  2903.     bool and_level= (((Item_cond*) cond)->functype()
  2904.      == Item_func::COND_AND_FUNC);
  2905.     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  2906.     Item *item;
  2907.     while ((item=li++))
  2908.     {
  2909.       bool res=const_expression_in_where(item, comp_item, const_item);
  2910.       if (res) // Is a const value
  2911.       {
  2912. if (and_level)
  2913.   return 1;
  2914.       }
  2915.       else if (!and_level)
  2916. return 0;
  2917.     }
  2918.     return and_level ? 0 : 1;
  2919.   }
  2920.   else if (cond->eq_cmp_result() != Item::COND_OK)
  2921.   { // boolan compare function
  2922.     Item_func* func= (Item_func*) cond;
  2923.     if (func->functype() != Item_func::EQUAL_FUNC &&
  2924. func->functype() != Item_func::EQ_FUNC)
  2925.       return 0;
  2926.     Item *left_item= ((Item_func*) cond)->arguments()[0];
  2927.     Item *right_item= ((Item_func*) cond)->arguments()[1];
  2928.     if (left_item->eq(comp_item))
  2929.     {
  2930.       if (right_item->const_item())
  2931.       {
  2932. if (*const_item)
  2933.   return right_item->eq(*const_item);
  2934. *const_item=right_item;
  2935. return 1;
  2936.       }
  2937.     }
  2938.     else if (right_item->eq(comp_item))
  2939.     {
  2940.       if (left_item->const_item())
  2941.       {
  2942. if (*const_item)
  2943.   return left_item->eq(*const_item);
  2944. *const_item=left_item;
  2945. return 1;
  2946.       }
  2947.     }
  2948.   }
  2949.   return 0;
  2950. }
  2951. /****************************************************************************
  2952. ** Create a temp table according to a field list.
  2953. ** Set distinct if duplicates could be removed
  2954. ** Given fields field pointers are changed to point at tmp_table
  2955. ** for send_fields
  2956. ****************************************************************************/
  2957. Field *create_tmp_field(TABLE *table,Item *item, Item::Type type,
  2958. Item_result_field ***copy_func, Field **from_field,
  2959. bool group, bool modify_item)
  2960. {
  2961.   switch (type) {
  2962.   case Item::SUM_FUNC_ITEM:
  2963.   {
  2964.     Item_sum *item_sum=(Item_sum*) item;
  2965.     bool maybe_null=item_sum->maybe_null;
  2966.     switch (item_sum->sum_func()) {
  2967.     case Item_sum::AVG_FUNC: /* Place for sum & count */
  2968.       if (group)
  2969. return new Field_string(sizeof(double)+sizeof(longlong),
  2970. maybe_null, item->name,table,1);
  2971.       else
  2972. return new Field_double(item_sum->max_length,maybe_null,
  2973. item->name, table, item_sum->decimals);
  2974.     case Item_sum::STD_FUNC: /* Place for sum & count */
  2975.       if (group)
  2976. return new Field_string(sizeof(double)*2+sizeof(longlong),
  2977.  maybe_null, item->name,table,1);
  2978.       else
  2979. return new Field_double(item_sum->max_length, maybe_null,
  2980. item->name,table,item_sum->decimals);
  2981.     case Item_sum::UNIQUE_USERS_FUNC:
  2982.       return new Field_long(9,maybe_null,item->name,table,1);
  2983.     default:
  2984.       switch (item_sum->result_type()) {
  2985.       case REAL_RESULT:
  2986. return new Field_double(item_sum->max_length,maybe_null,
  2987. item->name,table,item_sum->decimals);
  2988.       case INT_RESULT:
  2989. return new Field_longlong(item_sum->max_length,maybe_null,
  2990.   item->name,table);
  2991.       case STRING_RESULT:
  2992. if (item_sum->max_length > 255)
  2993.   return  new Field_blob(item_sum->max_length,maybe_null,
  2994.  item->name,table,item->binary);
  2995. return new Field_string(item_sum->max_length,maybe_null,
  2996.  item->name,table,item->binary);
  2997.       }
  2998.     }
  2999.     current_thd->fatal_error=1;
  3000.     return 0; // Error
  3001.   }
  3002.   case Item::FIELD_ITEM:
  3003.   {
  3004.     Field *org_field=((Item_field*) item)->field,*new_field;
  3005.     *from_field=org_field;
  3006.     if ((new_field= org_field->new_field(table))) // Should always be true
  3007.     {
  3008.       if (modify_item)
  3009. ((Item_field*) item)->result_field= new_field;
  3010.       else
  3011. new_field->field_name=item->name;
  3012.       if (org_field->maybe_null())
  3013. new_field->flags&= ~NOT_NULL_FLAG; // Because of outer join
  3014.     }
  3015.     return new_field;
  3016.   }
  3017.   case Item::PROC_ITEM:
  3018.   case Item::FUNC_ITEM:
  3019.   case Item::COND_ITEM:
  3020.   case Item::FIELD_AVG_ITEM:
  3021.   case Item::FIELD_STD_ITEM:
  3022.     /* The following can only happen with 'CREATE TABLE ... SELECT' */
  3023.   case Item::INT_ITEM:
  3024.   case Item::REAL_ITEM:
  3025.   case Item::STRING_ITEM:
  3026.   case Item::REF_ITEM:
  3027.   case Item::NULL_ITEM:
  3028.   {
  3029.     bool maybe_null=item->maybe_null;
  3030.     Field *new_field;
  3031.     LINT_INIT(new_field);
  3032.     switch (item->result_type()) {
  3033.     case REAL_RESULT:
  3034.       new_field=new Field_double(item->max_length,maybe_null,
  3035.  item->name,table,item->decimals);
  3036.       break;
  3037.     case INT_RESULT:
  3038.       new_field=new Field_longlong(item->max_length,maybe_null,
  3039.    item->name,table);
  3040.       break;
  3041.     case STRING_RESULT:
  3042.       if (item->max_length > 255)
  3043. new_field=  new Field_blob(item->max_length,maybe_null,
  3044.    item->name,table,item->binary);
  3045.       else
  3046. new_field= new Field_string(item->max_length,maybe_null,
  3047.     item->name,table,item->binary);
  3048.       break;
  3049.     }
  3050.     if (copy_func)
  3051.       *((*copy_func)++) = (Item_result_field*) item; // Save for copy_funcs
  3052.     if (modify_item)
  3053.       ((Item_result_field*) item)->result_field=new_field;
  3054.     return new_field;
  3055.   }
  3056.   default: // Dosen't have to be stored
  3057.     return 0;
  3058.   }
  3059. }
  3060. TABLE *
  3061. create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
  3062.  ORDER *group, bool distinct, bool save_sum_fields,
  3063.  bool allow_distinct_limit, uint select_options)
  3064. {
  3065.   TABLE *table;
  3066.   uint i,field_count,reclength,null_count,null_pack_length,
  3067.         hidden_null_count, hidden_null_pack_length, hidden_field_count,
  3068. blob_count,group_null_items;
  3069.   bool using_unique_constraint=0;
  3070.   char *tmpname,path[FN_REFLEN];
  3071.   byte *pos,*group_buff;
  3072.   uchar *null_flags;
  3073.   Field **reg_field,**from_field;
  3074.   Copy_field *copy=0;
  3075.   KEY *keyinfo;
  3076.   KEY_PART_INFO *key_part_info;
  3077.   Item_result_field **copy_func;
  3078.   MI_COLUMNDEF *recinfo;
  3079.   uint temp_pool_slot=MY_BIT_NONE;
  3080.   DBUG_ENTER("create_tmp_table");
  3081.   DBUG_PRINT("enter",("distinct: %d  save_sum_fields: %d  allow_distinct_limit: %d  group: %d",
  3082.       (int) distinct, (int) save_sum_fields,
  3083.       (int) allow_distinct_limit,test(group)));
  3084.   statistic_increment(created_tmp_tables, &LOCK_status);
  3085.   if (use_temp_pool)
  3086.     temp_pool_slot = bitmap_set_next(&temp_pool);
  3087.   if (temp_pool_slot != MY_BIT_NONE) // we got a slot
  3088.     sprintf(path, "%s%s_%lx_%i", mysql_tmpdir, tmp_file_prefix, 
  3089.     current_pid, temp_pool_slot);
  3090.   else // if we run out of slots or we are not using tempool
  3091.     sprintf(path,"%s%s%lx_%lx_%x",mysql_tmpdir,tmp_file_prefix,current_pid,
  3092.             thd->thread_id, thd->tmp_table++);
  3093.   if (group)
  3094.   {
  3095.     if (!param->quick_group)
  3096.       group=0; // Can't use group key
  3097.     else for (ORDER *tmp=group ; tmp ; tmp=tmp->next)
  3098.       (*tmp->item)->marker=4; // Store null in key
  3099.     if (param->group_length >= MAX_BLOB_WIDTH)
  3100.       using_unique_constraint=1;
  3101.     if (group)
  3102.       distinct=0; // Can't use distinct
  3103.   }
  3104.   field_count=param->field_count+param->func_count+param->sum_func_count;
  3105.   hidden_field_count=param->hidden_field_count;
  3106.   if (!my_multi_malloc(MYF(MY_WME),
  3107.        &table,sizeof(*table),
  3108.        &reg_field,sizeof(Field*)*(field_count+1),
  3109.        &from_field,sizeof(Field*)*field_count,
  3110.        &copy_func,sizeof(*copy_func)*(param->func_count+1),
  3111.        &param->keyinfo,sizeof(*param->keyinfo),
  3112.        &key_part_info,
  3113.        sizeof(*key_part_info)*(param->group_parts+1),